use crate::bundle::{Accepted, Bundle, BundleError};
use crate::emit::{Kem, NoteOpening};
use crate::lattice::Noise;
use crate::poseidon::Rng;
use crate::ratchet::{Handshake, Ratchet, ReceiverKeys, ReceiverPublic, SenderChain};
use crate::{Error, Fr};
#[derive(Clone, Debug)]
pub struct KemWitness {
pub receiver: ReceiverPublic,
pub e: Fr,
pub m: [u8; 32],
pub noise: Noise,
pub handshake: Handshake,
}
impl KemWitness {
pub fn new(receiver: &ReceiverPublic) -> Result<Self, Error> {
let (e, m, noise) = (Rng::field(), Rng::bytes(), Noise::random());
let handshake = Handshake::new(receiver, e, &noise, &m)?;
Ok(Self {
receiver: receiver.clone(),
e,
m,
noise,
handshake,
})
}
pub fn kem(&self) -> Kem {
let h = &self.handshake;
Kem {
ephemeral: h.ephemeral,
tag: h.tag,
ct_commitment: h.ct_commitment,
ct: h.ct.clone(),
}
}
}
#[derive(Clone, Debug)]
pub struct ChannelWitness {
pub is_handshake: bool,
pub t: u64,
pub s: Fr,
pub c_t: Fr,
pub kem: KemWitness,
}
impl ChannelWitness {
pub fn throwaway() -> Result<Self, Error> {
let s = Rng::field();
let kem = KemWitness::new(&ReceiverKeys::generate().public)?;
Ok(Self {
is_handshake: false,
t: 0,
s,
c_t: Ratchet::commit(s),
kem,
})
}
pub fn seal_note(&self, ctx: Fr, note: &NoteOpening) -> Result<(Fr, [Fr; 6]), Error> {
Ratchet::seal_payload(Ratchet::key_note(), self.s, ctx, ¬e.to_payload())
}
}
#[derive(Clone, Debug)]
pub struct Sender {
pub(crate) pk_b: Fr,
pub(crate) to: ReceiverPublic,
pub(crate) not_after: u64,
pub(crate) chain: Option<SenderChain>,
}
impl Sender {
pub fn accept(
bundle: &[u8],
chain_id: u64,
now: u64,
fetch: &dyn Fn(&str) -> Option<Vec<u8>>,
) -> Result<Self, BundleError> {
Ok(Self::from_accepted(Bundle::accept(
bundle, chain_id, now, fetch,
)?))
}
pub fn from_accepted(a: Accepted) -> Self {
Self {
pk_b: a.pk_b,
to: a.receiver,
not_after: a.not_after,
chain: None,
}
}
pub fn pk_b(&self) -> Fr {
self.pk_b
}
pub fn receiver(&self) -> &ReceiverPublic {
&self.to
}
pub fn not_after(&self) -> u64 {
self.not_after
}
pub fn index(&self) -> Option<u64> {
self.chain.as_ref().map(SenderChain::index)
}
pub fn handshake(&mut self) -> Result<ChannelWitness, Error> {
if self.chain.is_some() {
return Err(Error::ChannelAlreadyOpen);
}
let kem = KemWitness::new(&self.to)?;
let s = kem.handshake.root;
self.chain = Some(SenderChain::after_handshake(s));
Ok(ChannelWitness {
is_handshake: true,
t: 0,
s,
c_t: Ratchet::commit(s),
kem,
})
}
pub fn advance(&mut self) -> Result<ChannelWitness, Error> {
let chain = self.chain.as_mut().ok_or(Error::ChannelNotOpen)?;
let (t, s) = chain.advance();
let kem = KemWitness::new(&ReceiverKeys::generate().public)?;
Ok(ChannelWitness {
is_handshake: false,
t,
s,
c_t: Ratchet::commit(s),
kem,
})
}
pub fn skip(&mut self, n: u64) -> Result<(), Error> {
let chain = self.chain.as_mut().ok_or(Error::ChannelNotOpen)?;
for _ in 0..n {
chain.advance();
}
Ok(())
}
}