Skip to main content

qualia_core_db/net/qdnf/resolve/qsr/
key.rs

1//! Full-key and four-bit digit operations for QSR.
2//!
3//! `digit` is indexing only. It never certifies that a record exists or that a
4//! cover is authentic. Depth is a nibble index into the 48-byte StrongDigest
5//! (96 four-bit positions). It is not a first-byte bucket count.
6
7use crate::net::qdnf::errors::QdnfError;
8use crate::net::qdnf::types::StrongDigest;
9
10/// Nibbles in a 48-byte StrongDigest (384 bits).
11pub const KEY_DEPTH: usize = 96;
12/// Four-bit radix at each depth.
13pub const DIGIT_RADIX: u8 = 16;
14
15/// Nibble at `depth` (0..96). Even depth is the high nibble of that byte.
16pub fn digit(key: &StrongDigest, depth: usize) -> Result<u8, QdnfError> {
17    if depth >= KEY_DEPTH {
18        return Err(QdnfError::Range);
19    }
20    let byte = key.0[depth / 2];
21    Ok(if depth % 2 == 0 {
22        byte >> 4
23    } else {
24        byte & 0x0f
25    })
26}
27
28/// Full 48-byte equality. Callers must not substitute a first-byte test.
29pub fn keys_equal(a: &StrongDigest, b: &StrongDigest) -> bool {
30    let mut eq = true;
31    let mut i = 0usize;
32    while i < 48 {
33        if a.0[i] != b.0[i] {
34            eq = false;
35        }
36        i += 1;
37    }
38    eq
39}
40
41#[cfg(test)]
42mod tests {
43    use super::*;
44
45    fn key_bytes(b0: u8, b1: u8) -> StrongDigest {
46        let mut k = StrongDigest::ZERO;
47        k.0[0] = b0;
48        k.0[1] = b1;
49        k.0[47] = 0xab;
50        k
51    }
52
53    #[test]
54    fn digit_zero_is_high_nibble_of_byte_zero() {
55        let key = key_bytes(0xab, 0xcd);
56        assert_eq!(digit(&key, 0), Ok(0x0a));
57    }
58
59    #[test]
60    fn digit_one_is_low_nibble_of_byte_zero() {
61        let key = key_bytes(0xab, 0xcd);
62        assert_eq!(digit(&key, 1), Ok(0x0b));
63    }
64
65    #[test]
66    fn digit_two_and_three_are_byte_one() {
67        let key = key_bytes(0xab, 0xcd);
68        assert_eq!(digit(&key, 2), Ok(0x0c));
69        assert_eq!(digit(&key, 3), Ok(0x0d));
70    }
71
72    #[test]
73    fn digit_ninety_five_is_last_nibble() {
74        let key = key_bytes(0xab, 0xcd);
75        assert_eq!(digit(&key, 95), Ok(0x0b));
76    }
77
78    #[test]
79    fn digit_depth_ninety_six_is_range() {
80        let key = StrongDigest::ZERO;
81        assert_eq!(digit(&key, KEY_DEPTH), Err(QdnfError::Range));
82        assert_eq!(digit(&key, 97), Err(QdnfError::Range));
83    }
84
85    #[test]
86    fn keys_equal_distinguishes_later_bytes() {
87        let mut a = StrongDigest::ZERO;
88        let mut b = StrongDigest::ZERO;
89        a.0[0] = 0x10;
90        b.0[0] = 0x10;
91        b.0[47] = 1;
92        assert!(!keys_equal(&a, &b));
93        assert!(keys_equal(&a, &a));
94    }
95}