use crate::emit::{Delivery, Dg1, NoteOpening};
use crate::ratchet::{Ratchet, ReceiverKeys, Session};
use crate::{Error, Fr};
use std::collections::VecDeque;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Scan {
Handshake { note: NoteOpening, dg1: Dg1 },
Ratchet { t: u64, note: NoteOpening, dg1: Dg1 },
NotMine,
Invalid(Error),
}
pub struct Receiver {
pub(crate) keys: ReceiverKeys,
pub(crate) pk: Fr,
pub(crate) window: u64,
pub(crate) max_skipped: usize,
pub(crate) sessions: Vec<Session>,
pub(crate) consumed: VecDeque<Fr>,
pub(crate) channels: Vec<Fr>,
}
impl Receiver {
pub fn generate(pk: Fr, window: u64) -> Self {
Self::new(
ReceiverKeys::generate(),
pk,
window,
usize::try_from(window).expect("window fits usize"),
)
}
pub fn new(keys: ReceiverKeys, pk: Fr, window: u64, max_skipped: usize) -> Self {
Self {
keys,
pk,
window,
max_skipped,
sessions: vec![],
consumed: VecDeque::new(),
channels: vec![],
}
}
pub fn keys(&self) -> &ReceiverKeys {
&self.keys
}
pub fn pk(&self) -> Fr {
self.pk
}
pub fn window(&self) -> u64 {
self.window
}
pub fn channels(&self) -> usize {
self.sessions.len()
}
pub fn consumed_limit(&self) -> usize {
(usize::try_from(self.window).expect("window fits usize") + 4) * self.sessions.len().max(1)
}
pub fn consumed(&self) -> usize {
self.consumed.len()
}
pub fn held(&self) -> usize {
self.sessions.iter().map(Session::held).sum()
}
pub fn resync(&mut self, n: u64) {
for s in &mut self.sessions {
s.resync(n);
}
}
fn open(&self, d: &Delivery, s: Fr) -> Result<(NoteOpening, Dg1), Error> {
let ctx = d.ctx();
let e = &d.envelope;
let note = NoteOpening::from_payload(&Ratchet::open_payload(
Ratchet::key_note(),
s,
e.c_t,
ctx,
&e.c_note,
)?)?;
if note.commitment(d.cid, self.pk) != d.commitments[0].0 {
return Err(Error::HandshakeMismatch);
}
Ok((note, Dg1::open(s, e.c_t, ctx, &e.c_id)?))
}
#[allow(clippy::single_match_else)]
pub fn scan(&mut self, d: &Delivery) -> Scan {
let e = &d.envelope;
let held = self
.sessions
.iter()
.enumerate()
.find_map(|(i, x)| x.peek(e.c_t).map(|(t, s)| (i, t, s)));
let (s, t, session) = if let Some((i, t, s)) = held {
(s, t, Some(i))
} else if self.consumed.contains(&e.c_t) || self.channels.contains(&e.c_t) {
return Scan::Invalid(Error::ReusedIndex);
} else {
let k = &e.kem;
match self
.keys
.handshake_root(k.ephemeral, k.tag, k.ct_commitment, e.c_t, &k.ct)
{
Ok(s0) => (s0, 0, None),
Err(Error::NotForUs) => return Scan::NotMine,
Err(err) => return Scan::Invalid(err),
}
};
let (note, dg1) = match self.open(d, s) {
Ok(x) => x,
Err(err) => {
return Scan::Invalid(err);
}
};
match session {
Some(i) => {
self.sessions[i].take(e.c_t).expect("peeked");
self.consumed.push_back(e.c_t);
while self.consumed.len() > self.consumed_limit() {
self.consumed.pop_front();
}
Scan::Ratchet { t, note, dg1 }
}
None => {
self.sessions
.push(Session::start_with(s, self.window, self.max_skipped));
self.channels.push(e.c_t);
Scan::Handshake { note, dg1 }
}
}
}
pub fn sessions(&self) -> &[Session] {
&self.sessions
}
}