mod gate;
mod payload;
pub use gate::{HashChainGate, MerkleGate, NullGate, WriteGate};
pub use payload::{GateError, GateVariant, WritePayload, WriteReceipt};
#[cfg(test)]
mod tests {
use super::*;
use crate::gate::{HashChainGate, MerkleGate, NullGate, WriteGate};
fn make_payload(id: u64) -> WritePayload {
WritePayload::new(id, vec![id as f32 * 0.1, id as f32 * 0.2, id as f32 * 0.3])
}
#[test]
fn null_gate_admits_all() {
let mut g = NullGate::new();
for i in 0..10u64 {
let r = g.admit(&make_payload(i)).unwrap();
assert_eq!(r.sequence, i);
assert_eq!(r.gate_variant, GateVariant::Null);
}
assert_eq!(g.len(), 10);
}
#[test]
fn null_gate_verify_always_true() {
let mut g = NullGate::new();
let r = g.admit(&make_payload(0)).unwrap();
assert!(g.verify_receipt(&r));
}
#[test]
fn hash_chain_receipts_are_unique() {
let mut g = HashChainGate::new();
let r0 = g.admit(&make_payload(0)).unwrap();
let r1 = g.admit(&make_payload(1)).unwrap();
assert_ne!(r0.chain_commitment, r1.chain_commitment);
assert_eq!(r0.sequence, 0);
assert_eq!(r1.sequence, 1);
}
#[test]
fn hash_chain_verify_receipts() {
let mut g = HashChainGate::new();
let receipts: Vec<_> = (0..20u64).map(|i| g.admit(&make_payload(i)).unwrap()).collect();
for r in &receipts {
assert!(g.verify_receipt(r), "receipt {} failed verification", r.sequence);
}
}
#[test]
fn hash_chain_root_non_zero_after_writes() {
let mut g = HashChainGate::new();
g.admit(&make_payload(0)).unwrap();
assert_ne!(g.chain_root(), [0u8; 32]);
}
#[test]
fn hash_chain_same_payload_same_commitment_chain() {
let mut g = HashChainGate::new();
let p = make_payload(42);
let r0 = g.admit(&p).unwrap();
let r1 = g.admit(&p).unwrap();
assert_ne!(r0.chain_commitment, r1.chain_commitment);
}
#[test]
fn merkle_gate_roots_change_on_each_write() {
let mut g = MerkleGate::new();
let mut roots = Vec::new();
for i in 0..8u64 {
g.admit(&make_payload(i)).unwrap();
roots.push(g.chain_root());
}
let unique: std::collections::HashSet<_> = roots.iter().collect();
assert_eq!(unique.len(), 8, "expected 8 distinct roots");
}
#[test]
fn merkle_gate_verify_receipts() {
let mut g = MerkleGate::new();
let receipts: Vec<_> = (0..20u64).map(|i| g.admit(&make_payload(i)).unwrap()).collect();
for r in &receipts {
assert!(g.verify_receipt(r), "receipt {} failed", r.sequence);
}
}
#[test]
fn merkle_gate_root_non_zero_after_writes() {
let mut g = MerkleGate::new();
g.admit(&make_payload(0)).unwrap();
assert_ne!(g.chain_root(), [0u8; 32]);
}
#[test]
fn merkle_gate_power_of_two_leaves_stable() {
let mut g = MerkleGate::new();
for i in 0..8u64 {
g.admit(&make_payload(i)).unwrap();
}
let root_a = g.chain_root();
let root_b = g.chain_root();
assert_eq!(root_a, root_b, "root must be deterministic");
}
#[test]
fn synthetic_payloads_length_and_dims() {
let ps = synthetic_payloads(100, 64);
assert_eq!(ps.len(), 100);
assert!(ps.iter().all(|p| p.vector.len() == 64));
}
#[test]
fn synthetic_payloads_deterministic() {
let a = synthetic_payloads(50, 32);
let b = synthetic_payloads(50, 32);
assert!(a.iter().zip(b.iter()).all(|(x, y)| x.vector == y.vector));
}
#[test]
fn acceptance_hash_chain_bulk_verify() {
let payloads = synthetic_payloads(500, 64);
let mut gate = HashChainGate::new();
let receipts: Vec<_> = payloads.iter().map(|p| gate.admit(p).unwrap()).collect();
let all_ok = receipts.iter().all(|r| gate.verify_receipt(r));
assert!(all_ok, "bulk receipt verification failed for HashChainGate");
assert_eq!(gate.len(), 500);
assert_ne!(gate.chain_root(), [0u8; 32]);
}
#[test]
fn acceptance_merkle_bulk_verify() {
let payloads = synthetic_payloads(500, 64);
let mut gate = MerkleGate::new();
let receipts: Vec<_> = payloads.iter().map(|p| gate.admit(p).unwrap()).collect();
let all_ok = receipts.iter().all(|r| gate.verify_receipt(r));
assert!(all_ok, "bulk receipt verification failed for MerkleGate");
assert_eq!(gate.len(), 500);
assert_ne!(gate.chain_root(), [0u8; 32]);
}
#[test]
fn acceptance_all_gates_distinct_roots() {
let payloads = synthetic_payloads(16, 32);
let mut null = NullGate::new();
let mut chain = HashChainGate::new();
let mut merkle = MerkleGate::new();
for p in &payloads {
null.admit(p).unwrap();
chain.admit(p).unwrap();
merkle.admit(p).unwrap();
}
assert_eq!(null.chain_root(), [0u8; 32], "NullGate root must be zero");
assert_ne!(chain.chain_root(), [0u8; 32], "HashChain root must be non-zero");
assert_ne!(merkle.chain_root(), [0u8; 32], "Merkle root must be non-zero");
assert_ne!(
chain.chain_root(),
merkle.chain_root(),
"HashChain and Merkle roots must differ"
);
}
}
pub fn synthetic_payloads(n: usize, dims: usize) -> Vec<WritePayload> {
let mut state: u64 = 0x6b37_9d3c_2a85_f1e4;
let mut next = move || -> f32 {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
(state as i64 as f64 / i64::MAX as f64) as f32
};
(0..n)
.map(|i| {
let vector: Vec<f32> = (0..dims).map(|_| next()).collect();
WritePayload::new(i as u64, vector)
})
.collect()
}