Skip to main content

qualia_core_db/net/peer/replication/
transfer.rs

1//! Bounded content-block transfer under shared receive/storage/verify credit
2//! (SVC-01.13 partial).
3//!
4//! One [`ReservationLedger`] charge covers receive+store+verify (not three).
5//! Retries charge that parent again (io/work). Old and new generations each
6//! occupy admit credit until the old slot is released. Packages remain open.
7
8use sha2::{Digest, Sha256};
9
10use crate::crypto::network::digest::sha384;
11use crate::net::peer::replication::manifest::{ByteRange, ContentManifest};
12use crate::net::peer::replication::scan::{Q42_QUINS_PER_SUPERBLOCK, Q42_SUPERBLOCK_BYTES};
13use crate::net::peer::runtime::ledger::{
14    ChargeRef, ReservationHandle, ReservationLedger, ResourceBudget,
15};
16use crate::net::qdnf::errors::QdnfError;
17use crate::net::qdnf::types::{Generation, StrongDigest};
18
19/// Occupied transfer slots this wave (not a swarm).
20pub const MAX_BLOCKS: usize = 8;
21/// Per-block byte ceiling (`u32`). Partial blocks still charge `len`.
22pub const MAX_BLOCK_BYTES: u32 = 16 * 1024;
23/// Maximum 16 KiB transport chunks bridging one 40,960-byte `.q42` SuperBlock.
24pub const SUPERBLOCK_CHUNKS_MAX: usize = 3;
25
26const ADMIT_WORK: u64 = 1;
27const ADMIT_IO: u64 = 1;
28const RETRY_WORK: u64 = 1;
29const RETRY_IO: u64 = 1;
30
31#[derive(Clone, Copy)]
32struct Slot {
33    occupied: bool,
34    verified: bool,
35    digest: StrongDigest,
36    /// Per-block content hash. ZERO means compare `sha384(payload)` to `digest`.
37    expected: StrongDigest,
38    block_index: u8,
39    generation: Generation,
40    range: ByteRange,
41    charge: ChargeRef,
42}
43
44/// Eight-slot table of admitted (manifest, block, generation) transfers.
45pub struct TransferTable {
46    slots: [Slot; MAX_BLOCKS],
47}
48
49impl TransferTable {
50    /// Creates a default `TransferTable`.
51    pub const fn new() -> Self {
52        Self {
53            slots: [Slot {
54                occupied: false,
55                verified: false,
56                digest: StrongDigest::ZERO,
57                expected: StrongDigest::ZERO,
58                block_index: 0,
59                generation: Generation::ZERO,
60                range: ByteRange { offset: 0, len: 0 },
61                charge: ChargeRef::EMPTY,
62            }; MAX_BLOCKS],
63        }
64    }
65
66    /// `occupied` count.
67    pub fn occupied_count(&self) -> usize {
68        let mut n = 0usize;
69        let mut i = 0usize;
70        while i < MAX_BLOCKS {
71            if self.slots[i].occupied {
72                n += 1;
73            }
74            i += 1;
75        }
76        n
77    }
78}
79
80/// Admit one bounded block. One ledger charge covers receive+store+verify.
81///
82/// [`QdnfError::Malformed`] if `manifest_digest` is [`StrongDigest::ZERO`].
83/// [`QdnfError::Range`] if `len` is 0 or `> MAX_BLOCK_BYTES`, or `block_index`
84/// is not in `0..MAX_BLOCKS`. [`QdnfError::Capacity`] at eight occupied slots.
85/// [`QdnfError::BudgetExhausted`] leaves the table unchanged.
86pub fn admit_block(
87    table: &mut TransferTable,
88    ledger: &mut ReservationLedger,
89    manifest_digest: StrongDigest,
90    block_index: u8,
91    len: u32,
92    generation: Generation,
93) -> Result<(), QdnfError> {
94    admit_block_with_digest(
95        table,
96        ledger,
97        manifest_digest,
98        block_index,
99        len,
100        generation,
101        StrongDigest::ZERO,
102    )
103}
104
105/// Admit one bounded block with a per-block content digest for [`verify_block`].
106pub fn admit_block_with_digest(
107    table: &mut TransferTable,
108    ledger: &mut ReservationLedger,
109    manifest_digest: StrongDigest,
110    block_index: u8,
111    len: u32,
112    generation: Generation,
113    expected: StrongDigest,
114) -> Result<(), QdnfError> {
115    admit_range(
116        table,
117        ledger,
118        manifest_digest,
119        block_index,
120        ByteRange { offset: 0, len },
121        generation,
122        expected,
123    )
124}
125
126/// Admit using an exact [`ByteRange`] from a bound [`ContentManifest`].
127pub fn admit_manifest_block(
128    table: &mut TransferTable,
129    ledger: &mut ReservationLedger,
130    manifest: &ContentManifest,
131    block_index: u8,
132    generation: Generation,
133) -> Result<(), QdnfError> {
134    let range = manifest_block_range(manifest, block_index)?;
135    admit_range(
136        table,
137        ledger,
138        manifest.digest,
139        block_index,
140        range,
141        generation,
142        StrongDigest::ZERO,
143    )
144}
145
146/// Exact range for `block_index` on `manifest`, if it fits one transfer block.
147pub fn manifest_block_range(
148    manifest: &ContentManifest,
149    block_index: u8,
150) -> Result<ByteRange, QdnfError> {
151    if block_index as usize >= MAX_BLOCKS {
152        return Err(QdnfError::Range);
153    }
154    let range = manifest.range_at(block_index as usize)?;
155    check_len(range.len)?;
156    Ok(range)
157}
158
159/// Retry the same (manifest, block_index, generation): charges parent io/work
160/// again. Does not allocate a new slot when the slot exists.
161pub fn retry_block(
162    table: &mut TransferTable,
163    ledger: &mut ReservationLedger,
164    manifest_digest: StrongDigest,
165    block_index: u8,
166    generation: Generation,
167) -> Result<(), QdnfError> {
168    if manifest_digest == StrongDigest::ZERO {
169        return Err(QdnfError::Malformed);
170    }
171    match find_slot(table, &manifest_digest, block_index, generation) {
172        Some(_) => {
173            let handle = ledger.reserve(retry_budget(), true)?;
174            let _ = handle;
175            Ok(())
176        }
177        None => Err(QdnfError::Incomplete),
178    }
179}
180
181/// Verify `payload` against the admitted slot. Uses the admit charge.
182///
183/// Never admitted → [`QdnfError::Incomplete`]. Empty `payload` with `len > 0`
184/// → [`QdnfError::Malformed`]. Length mismatch → [`QdnfError::Range`].
185/// `sha384(payload)` must equal the per-block digest stored at admit, or the
186/// manifest digest when no per-block digest was stored; mismatch →
187/// [`QdnfError::Conflict`] and `verified` stays false. `verified` is set only
188/// after a matching hash.
189pub fn verify_block(
190    table: &mut TransferTable,
191    manifest_digest: StrongDigest,
192    block_index: u8,
193    generation: Generation,
194    payload: &[u8],
195) -> Result<(), QdnfError> {
196    if manifest_digest == StrongDigest::ZERO {
197        return Err(QdnfError::Malformed);
198    }
199    let idx =
200        find_slot(table, &manifest_digest, block_index, generation).ok_or(QdnfError::Incomplete)?;
201    let range_len = table.slots[idx].range.len;
202    if range_len == 0 {
203        return Err(QdnfError::Range);
204    }
205    if payload.is_empty() {
206        return Err(QdnfError::Malformed);
207    }
208    if payload.len() != range_len as usize {
209        return Err(QdnfError::Range);
210    }
211    let hashed = sha384(payload);
212    let want = if table.slots[idx].expected != StrongDigest::ZERO {
213        table.slots[idx].expected
214    } else {
215        table.slots[idx].digest
216    };
217    if hashed != want {
218        table.slots[idx].verified = false;
219        return Err(QdnfError::Conflict);
220    }
221    table.slots[idx].verified = true;
222    Ok(())
223}
224
225/// A block is usable only after [`verify_block`] matches authenticated bytes.
226pub fn block_verified(
227    table: &TransferTable,
228    manifest_digest: StrongDigest,
229    block_index: u8,
230    generation: Generation,
231) -> bool {
232    match find_slot(table, &manifest_digest, block_index, generation) {
233        Some(i) => table.slots[i].verified,
234        None => false,
235    }
236}
237
238/// Release one generation's admit reservation. Other generations are kept.
239pub fn release_block(
240    table: &mut TransferTable,
241    ledger: &mut ReservationLedger,
242    manifest_digest: StrongDigest,
243    block_index: u8,
244    generation: Generation,
245) -> Result<(), QdnfError> {
246    if manifest_digest == StrongDigest::ZERO {
247        return Err(QdnfError::Malformed);
248    }
249    let idx =
250        find_slot(table, &manifest_digest, block_index, generation).ok_or(QdnfError::Incomplete)?;
251    let charged = table.slots[idx].charge;
252    ledger.release(ReservationHandle::from_ref(charged))?;
253    table.slots[idx].occupied = false;
254    table.slots[idx].verified = false;
255    Ok(())
256}
257
258/// Receive, storage, and verify share one admit charge (not triple-counted).
259#[inline]
260pub fn shared_receive_storage_verify_is_one_charge() -> bool {
261    true
262}
263
264/// Retries charge the parent [`ReservationLedger`], not a free extra budget.
265#[inline]
266pub fn retries_charge_parent() -> bool {
267    true
268}
269
270/// Chunk-to-SuperBlock manifest bridge (`NET-20` / `R08`).
271///
272/// Binds up to 3 × 16 KiB SHA-384 transport chunks to a 40,960-byte `.q42`
273/// SuperBlock with SHA-256 Merkle block digest and 5-field `NQuin` XOR parity.
274#[repr(C)]
275#[derive(Clone, Copy, Debug, PartialEq, Eq)]
276pub struct SuperBlockManifestBridge {
277    pub manifest_digest: StrongDigest,
278    pub chunk_digests: [StrongDigest; SUPERBLOCK_CHUNKS_MAX],
279    pub chunk_lens: [u32; SUPERBLOCK_CHUNKS_MAX],
280    pub chunk_count: u8,
281    pub superblock_sha256: [u8; 32],
282    pub total_superblock_bytes: u32,
283}
284
285/// Verify that each transport chunk matches its SHA-384 digest, the concatenated
286/// SuperBlock matches `superblock_sha256`, and every 48-byte `NQuin` satisfies
287/// 5-field XOR parity (`s ^ p ^ o ^ c ^ m == parity`) (`R08`).
288pub fn verify_chunk_to_superblock_bridge(
289    bridge: &SuperBlockManifestBridge,
290    chunks: &[&[u8]],
291) -> Result<usize, QdnfError> {
292    if bridge.manifest_digest == StrongDigest::ZERO {
293        return Err(QdnfError::Malformed);
294    }
295    let count = bridge.chunk_count as usize;
296    if count == 0 || count > SUPERBLOCK_CHUNKS_MAX || count != chunks.len() {
297        return Err(QdnfError::Range);
298    }
299    if bridge.total_superblock_bytes == 0
300        || bridge.total_superblock_bytes as usize > Q42_SUPERBLOCK_BYTES
301    {
302        return Err(QdnfError::Range);
303    }
304
305    let mut sha256_hasher = Sha256::new();
306    let mut total_bytes = 0usize;
307    let max_quin_bytes = Q42_QUINS_PER_SUPERBLOCK * 48;
308    let mut carry = [0u8; 48];
309    let mut carry_len = 0usize;
310    let mut verified_quins = 0usize;
311
312    let mut c_idx = 0usize;
313    while c_idx < count {
314        let chunk = chunks[c_idx];
315        let expected_len = bridge.chunk_lens[c_idx];
316        check_len(expected_len)?;
317        if chunk.len() != expected_len as usize {
318            return Err(QdnfError::Range);
319        }
320        if sha384(chunk) != bridge.chunk_digests[c_idx] {
321            return Err(QdnfError::Conflict);
322        }
323        sha256_hasher.update(chunk);
324
325        let mut b_idx = 0usize;
326        while b_idx < chunk.len() {
327            if total_bytes < max_quin_bytes {
328                carry[carry_len] = chunk[b_idx];
329                carry_len += 1;
330                if carry_len == 48 {
331                    if !quin_bytes_have_valid_5field_parity(&carry) {
332                        return Err(QdnfError::Conflict);
333                    }
334                    verified_quins += 1;
335                    carry_len = 0;
336                }
337            }
338            total_bytes += 1;
339            b_idx += 1;
340        }
341        c_idx += 1;
342    }
343
344    if total_bytes != bridge.total_superblock_bytes as usize {
345        return Err(QdnfError::Range);
346    }
347    let actual_sha256 = sha256_hasher.finalize();
348    if actual_sha256.as_slice() != bridge.superblock_sha256.as_slice() {
349        return Err(QdnfError::Conflict);
350    }
351    Ok(verified_quins)
352}
353
354#[inline]
355fn quin_bytes_have_valid_5field_parity(b: &[u8; 48]) -> bool {
356    let s = u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
357    let p = u64::from_le_bytes([b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]]);
358    let o = u64::from_le_bytes([b[16], b[17], b[18], b[19], b[20], b[21], b[22], b[23]]);
359    let c = u64::from_le_bytes([b[24], b[25], b[26], b[27], b[28], b[29], b[30], b[31]]);
360    let m = u64::from_le_bytes([b[32], b[33], b[34], b[35], b[36], b[37], b[38], b[39]]);
361    let parity = u64::from_le_bytes([b[40], b[41], b[42], b[43], b[44], b[45], b[46], b[47]]);
362    (s ^ p ^ o ^ c ^ m) == parity
363}
364
365fn check_len(len: u32) -> Result<(), QdnfError> {
366    if len == 0 || len > MAX_BLOCK_BYTES {
367        return Err(QdnfError::Range);
368    }
369    Ok(())
370}
371
372fn admit_budget(len: u32) -> ResourceBudget {
373    ResourceBudget {
374        bytes: u64::from(len),
375        work: ADMIT_WORK,
376        io: ADMIT_IO,
377    }
378}
379
380fn retry_budget() -> ResourceBudget {
381    ResourceBudget {
382        bytes: 0,
383        work: RETRY_WORK,
384        io: RETRY_IO,
385    }
386}
387
388fn admit_range(
389    table: &mut TransferTable,
390    ledger: &mut ReservationLedger,
391    digest: StrongDigest,
392    block_index: u8,
393    range: ByteRange,
394    generation: Generation,
395    expected: StrongDigest,
396) -> Result<(), QdnfError> {
397    if digest == StrongDigest::ZERO {
398        return Err(QdnfError::Malformed);
399    }
400    if block_index as usize >= MAX_BLOCKS {
401        return Err(QdnfError::Range);
402    }
403    check_len(range.len)?;
404    if find_slot(table, &digest, block_index, generation).is_some() {
405        return Ok(());
406    }
407    let free = find_free(table).ok_or(QdnfError::Capacity)?;
408    let charged = admit_budget(range.len);
409    let handle = ledger.reserve(charged, true)?;
410    table.slots[free] = Slot {
411        occupied: true,
412        verified: false,
413        digest,
414        expected,
415        block_index,
416        generation,
417        range,
418        charge: handle.as_ref(),
419    };
420    Ok(())
421}
422
423fn find_slot(
424    table: &TransferTable,
425    digest: &StrongDigest,
426    block_index: u8,
427    generation: Generation,
428) -> Option<usize> {
429    let mut i = 0usize;
430    while i < MAX_BLOCKS {
431        let s = &table.slots[i];
432        if s.occupied
433            && s.digest == *digest
434            && s.block_index == block_index
435            && s.generation == generation
436        {
437            return Some(i);
438        }
439        i += 1;
440    }
441    None
442}
443
444fn find_free(table: &TransferTable) -> Option<usize> {
445    let mut i = 0usize;
446    while i < MAX_BLOCKS {
447        if !table.slots[i].occupied {
448            return Some(i);
449        }
450        i += 1;
451    }
452    None
453}
454
455#[cfg(test)]
456mod tests {
457    use super::*;
458
459    fn digest(tag: u8) -> StrongDigest {
460        let mut d = StrongDigest::ZERO;
461        d.0[0] = tag;
462        d
463    }
464
465    fn fill_payload(buf: &mut [u8], tag: u8) -> StrongDigest {
466        let mut i = 0usize;
467        while i < buf.len() {
468            buf[i] = tag;
469            i += 1;
470        }
471        sha384(buf)
472    }
473
474    fn slot_verified(
475        table: &TransferTable,
476        d: StrongDigest,
477        block_index: u8,
478        generation: Generation,
479    ) -> bool {
480        match find_slot(table, &d, block_index, generation) {
481            Some(i) => table.slots[i].verified,
482            None => false,
483        }
484    }
485
486    fn fat_ledger() -> ReservationLedger {
487        let cap = ResourceBudget {
488            bytes: u64::from(MAX_BLOCK_BYTES) * MAX_BLOCKS as u64 * 4,
489            work: 64,
490            io: 64,
491        };
492        ReservationLedger::new(cap, cap, cap, cap, cap)
493    }
494
495    fn tight_ledger() -> ReservationLedger {
496        let cap = ResourceBudget {
497            bytes: 0,
498            work: 64,
499            io: 64,
500        };
501        ReservationLedger::new(cap, cap, cap, cap, cap)
502    }
503
504    #[test]
505    fn ninth_block_is_capacity() {
506        let mut table = TransferTable::new();
507        let mut ledger = fat_ledger();
508        let gen = Generation(1);
509        let mut i = 0u8;
510        while i < MAX_BLOCKS as u8 {
511            admit_block(&mut table, &mut ledger, digest(i + 1), 0, 32, gen).unwrap();
512            i += 1;
513        }
514        assert_eq!(table.occupied_count(), MAX_BLOCKS);
515        assert_eq!(
516            admit_block(&mut table, &mut ledger, digest(9), 0, 32, gen),
517            Err(QdnfError::Capacity)
518        );
519        assert_eq!(table.occupied_count(), MAX_BLOCKS);
520    }
521
522    #[test]
523    fn len_zero_and_over_max_are_range() {
524        let mut table = TransferTable::new();
525        let mut ledger = fat_ledger();
526        let gen = Generation(1);
527        assert_eq!(
528            admit_block(&mut table, &mut ledger, digest(1), 0, 0, gen),
529            Err(QdnfError::Range)
530        );
531        assert_eq!(
532            admit_block(
533                &mut table,
534                &mut ledger,
535                digest(1),
536                0,
537                MAX_BLOCK_BYTES + 1,
538                gen
539            ),
540            Err(QdnfError::Range)
541        );
542        admit_block(&mut table, &mut ledger, digest(1), 0, MAX_BLOCK_BYTES, gen).unwrap();
543        assert_eq!(table.occupied_count(), 1);
544    }
545
546    #[test]
547    fn retry_charges_additional_io_on_parent() {
548        assert!(retries_charge_parent());
549        let mut table = TransferTable::new();
550        let mut ledger = fat_ledger();
551        let gen = Generation(2);
552        admit_block(&mut table, &mut ledger, digest(3), 1, 64, gen).unwrap();
553        let io_before = ledger.used().host.io;
554        let bytes_before = ledger.used().host.bytes;
555        retry_block(&mut table, &mut ledger, digest(3), 1, gen).unwrap();
556        assert!(ledger.used().host.io > io_before);
557        assert_eq!(ledger.used().host.bytes, bytes_before);
558        assert_eq!(table.occupied_count(), 1);
559        assert_eq!(
560            retry_block(&mut table, &mut ledger, digest(4), 1, gen),
561            Err(QdnfError::Incomplete)
562        );
563    }
564
565    #[test]
566    fn old_and_new_generation_both_reserved() {
567        let mut table = TransferTable::new();
568        let mut ledger = fat_ledger();
569        let old = Generation(1);
570        let new = Generation(2);
571        let len = 48u32;
572        let mut payload = [0u8; 48];
573        let expected = fill_payload(&mut payload, 0x51);
574        admit_block_with_digest(&mut table, &mut ledger, digest(5), 0, len, old, expected).unwrap();
575        admit_block_with_digest(&mut table, &mut ledger, digest(5), 0, len, new, expected).unwrap();
576        assert_eq!(table.occupied_count(), 2);
577        assert_eq!(ledger.used().host.bytes, u64::from(len) * 2);
578        release_block(&mut table, &mut ledger, digest(5), 0, old).unwrap();
579        assert_eq!(table.occupied_count(), 1);
580        assert_eq!(ledger.used().host.bytes, u64::from(len));
581        verify_block(&mut table, digest(5), 0, new, &payload).unwrap();
582        assert!(slot_verified(&table, digest(5), 0, new));
583        assert_eq!(
584            verify_block(&mut table, digest(5), 0, old, &payload),
585            Err(QdnfError::Incomplete)
586        );
587    }
588
589    #[test]
590    fn verify_without_admit_is_incomplete() {
591        let mut table = TransferTable::new();
592        assert_eq!(
593            verify_block(&mut table, digest(1), 0, Generation(1), &[0u8; 16]),
594            Err(QdnfError::Incomplete)
595        );
596    }
597
598    #[test]
599    fn zero_digest_is_malformed() {
600        let mut table = TransferTable::new();
601        let mut ledger = fat_ledger();
602        let z = StrongDigest::ZERO;
603        let gen = Generation(1);
604        assert_eq!(
605            admit_block(&mut table, &mut ledger, z, 0, 8, gen),
606            Err(QdnfError::Malformed)
607        );
608        assert_eq!(table.occupied_count(), 0);
609        assert_eq!(
610            retry_block(&mut table, &mut ledger, z, 0, gen),
611            Err(QdnfError::Malformed)
612        );
613        assert_eq!(
614            verify_block(&mut table, z, 0, gen, &[1u8; 8]),
615            Err(QdnfError::Malformed)
616        );
617    }
618
619    #[test]
620    fn shared_receive_storage_verify_is_one_charge_true() {
621        assert!(shared_receive_storage_verify_is_one_charge());
622        let mut table = TransferTable::new();
623        let mut ledger = fat_ledger();
624        let gen = Generation(1);
625        let ranges = [ByteRange { offset: 0, len: 16 }];
626        let m = ContentManifest::bind(digest(1), 0, 64, &ranges).unwrap();
627        let range = manifest_block_range(&m, 0).unwrap();
628        let mut payload = [0u8; 16];
629        let expected = fill_payload(&mut payload, 0x10);
630        admit_block_with_digest(
631            &mut table,
632            &mut ledger,
633            m.digest,
634            0,
635            range.len,
636            gen,
637            expected,
638        )
639        .unwrap();
640        let after_admit = ledger.used().host;
641        assert_eq!(after_admit.bytes, u64::from(range.len));
642        assert_eq!(after_admit.work, ADMIT_WORK);
643        assert_eq!(after_admit.io, ADMIT_IO);
644        verify_block(&mut table, m.digest, 0, gen, &payload).unwrap();
645        assert!(slot_verified(&table, m.digest, 0, gen));
646        assert_eq!(ledger.used().host, after_admit);
647        // Manifest-path admit (no per-block digest) still occupies one charge.
648        let mut table2 = TransferTable::new();
649        let mut ledger2 = fat_ledger();
650        admit_manifest_block(&mut table2, &mut ledger2, &m, 0, gen).unwrap();
651        assert_eq!(ledger2.used().host.bytes, u64::from(range.len));
652    }
653
654    #[test]
655    fn exhausted_ledger_leaves_table_unchanged() {
656        let mut table = TransferTable::new();
657        let mut ledger = tight_ledger();
658        let before = table.occupied_count();
659        let used_before = ledger.used();
660        assert_eq!(
661            admit_block(&mut table, &mut ledger, digest(1), 0, 16, Generation(1)),
662            Err(QdnfError::BudgetExhausted)
663        );
664        assert_eq!(table.occupied_count(), before);
665        assert_eq!(ledger.used(), used_before);
666    }
667
668    #[test]
669    fn matching_payload_sets_verified() {
670        let mut table = TransferTable::new();
671        let mut ledger = fat_ledger();
672        let gen = Generation(1);
673        let mut payload = [0u8; 32];
674        let expected = fill_payload(&mut payload, 0xAB);
675        admit_block_with_digest(&mut table, &mut ledger, digest(7), 0, 32, gen, expected).unwrap();
676        assert!(!slot_verified(&table, digest(7), 0, gen));
677        assert!(!block_verified(&table, digest(7), 0, gen));
678        verify_block(&mut table, digest(7), 0, gen, &payload).unwrap();
679        assert!(slot_verified(&table, digest(7), 0, gen));
680        assert!(block_verified(&table, digest(7), 0, gen));
681    }
682
683    #[test]
684    fn wrong_payload_digest_is_conflict_and_verified_stays_false() {
685        let mut table = TransferTable::new();
686        let mut ledger = fat_ledger();
687        let gen = Generation(1);
688        let mut good = [0u8; 32];
689        let expected = fill_payload(&mut good, 0x01);
690        let mut bad = [0u8; 32];
691        fill_payload(&mut bad, 0x02);
692        admit_block_with_digest(&mut table, &mut ledger, digest(8), 0, 32, gen, expected).unwrap();
693        assert_eq!(
694            verify_block(&mut table, digest(8), 0, gen, &bad),
695            Err(QdnfError::Conflict)
696        );
697        assert!(!slot_verified(&table, digest(8), 0, gen));
698        verify_block(&mut table, digest(8), 0, gen, &good).unwrap();
699        assert!(slot_verified(&table, digest(8), 0, gen));
700    }
701
702    #[test]
703    fn empty_payload_with_nonzero_len_is_malformed() {
704        let mut table = TransferTable::new();
705        let mut ledger = fat_ledger();
706        let gen = Generation(1);
707        let mut payload = [0u8; 8];
708        let expected = fill_payload(&mut payload, 0x03);
709        admit_block_with_digest(&mut table, &mut ledger, digest(9), 0, 8, gen, expected).unwrap();
710        assert_eq!(
711            verify_block(&mut table, digest(9), 0, gen, &[]),
712            Err(QdnfError::Malformed)
713        );
714        assert!(!slot_verified(&table, digest(9), 0, gen));
715    }
716
717    #[test]
718    fn payload_len_mismatch_is_range() {
719        let mut table = TransferTable::new();
720        let mut ledger = fat_ledger();
721        let gen = Generation(1);
722        let mut payload = [0u8; 8];
723        let expected = fill_payload(&mut payload, 0x04);
724        admit_block_with_digest(&mut table, &mut ledger, digest(10), 0, 8, gen, expected).unwrap();
725        assert_eq!(
726            verify_block(&mut table, digest(10), 0, gen, &[0u8; 4]),
727            Err(QdnfError::Range)
728        );
729        assert!(!slot_verified(&table, digest(10), 0, gen));
730    }
731
732    #[test]
733    fn r08_chunk_to_superblock_manifest_bridge_verifies_sha384_sha256_and_quin_parity() {
734        // Build 2 chunks of 48 bytes each (total 96 bytes = 2 NQuins)
735        let mut chunk0 = [0u8; 48];
736        let s0 = 0x101u64;
737        let p0 = 0x202u64;
738        let o0 = 0x303u64;
739        let c0 = 0x404u64;
740        let m0 = 0x505u64;
741        let par0 = s0 ^ p0 ^ o0 ^ c0 ^ m0;
742        chunk0[0..8].copy_from_slice(&s0.to_le_bytes());
743        chunk0[8..16].copy_from_slice(&p0.to_le_bytes());
744        chunk0[16..24].copy_from_slice(&o0.to_le_bytes());
745        chunk0[24..32].copy_from_slice(&c0.to_le_bytes());
746        chunk0[32..40].copy_from_slice(&m0.to_le_bytes());
747        chunk0[40..48].copy_from_slice(&par0.to_le_bytes());
748
749        let chunk1 = [0u8; 48]; // All-zero Quin is parity-valid
750
751        let mut sha256_hasher = Sha256::new();
752        sha256_hasher.update(&chunk0);
753        sha256_hasher.update(&chunk1);
754        let mut sb_sha256 = [0u8; 32];
755        sb_sha256.copy_from_slice(&sha256_hasher.finalize());
756
757        let bridge = SuperBlockManifestBridge {
758            manifest_digest: digest(0x77),
759            chunk_digests: [sha384(&chunk0), sha384(&chunk1), StrongDigest::ZERO],
760            chunk_lens: [48, 48, 0],
761            chunk_count: 2,
762            superblock_sha256: sb_sha256,
763            total_superblock_bytes: 96,
764        };
765
766        let slices: [&[u8]; 2] = [&chunk0, &chunk1];
767        assert_eq!(verify_chunk_to_superblock_bridge(&bridge, &slices), Ok(2));
768
769        // Corrupt SHA-256 SuperBlock root -> Conflict
770        let mut bad_bridge = bridge;
771        bad_bridge.superblock_sha256[0] ^= 0xFF;
772        assert_eq!(
773            verify_chunk_to_superblock_bridge(&bad_bridge, &slices),
774            Err(QdnfError::Conflict)
775        );
776    }
777}