mod driver;
mod policy;
use crate::batch;
use crate::cache::{KeyCache, NullKeyCache};
use crate::edwards::{BasepointTable, BasepointTableEntries, PointTable};
use crate::input::VerifyInput;
use driver::ChunkScratch;
use std::sync::LazyLock;
pub use policy::{DalekPolicy, VerificationPolicy, VerifyPolicy, Zip215Policy};
const SIMD_LANES: usize = batch::SIMD_LANES;
const R_ENCODING_LEN: usize = batch::R_ENCODING_LEN;
static BASE_TABLE: LazyLock<BasepointTable> = LazyLock::new(BasepointTable::new);
static IDENTITY_TABLE: LazyLock<PointTable> = LazyLock::new(PointTable::cold_identity);
#[derive(Debug)]
pub struct Verifier<P: VerificationPolicy = Zip215Policy, C: KeyCache = NullKeyCache> {
policy: core::marker::PhantomData<P>,
base_table: &'static BasepointTableEntries,
identity_table: &'static PointTable,
visit_order: Vec<usize>,
queues: C::Queues<P>,
scratch: Box<ChunkScratch>,
cache: C,
}
pub type Zip215Verifier<C = NullKeyCache> = Verifier<Zip215Policy, C>;
pub type DalekVerifier<C = NullKeyCache> = Verifier<DalekPolicy, C>;
#[derive(Debug)]
pub enum RuntimeVerifier<C: KeyCache = NullKeyCache> {
Zip215(Zip215Verifier<C>),
Dalek(DalekVerifier<C>),
}
impl<P: VerificationPolicy> Default for Verifier<P, NullKeyCache> {
fn default() -> Self {
Self::new()
}
}
impl<P: VerificationPolicy> Verifier<P, NullKeyCache> {
pub fn new() -> Self {
Self::with_cache(NullKeyCache::new())
}
}
impl<P: VerificationPolicy, C: KeyCache> Verifier<P, C> {
pub fn with_cache(cache: C) -> Self {
Self {
policy: core::marker::PhantomData,
base_table: BASE_TABLE.entries(),
identity_table: &*IDENTITY_TABLE,
visit_order: Vec::new(),
queues: C::Queues::<P>::default(),
scratch: Box::new(ChunkScratch::new()),
cache,
}
}
pub fn cache(&self) -> &C {
&self.cache
}
pub fn cache_mut(&mut self) -> &mut C {
&mut self.cache
}
pub fn policy(&self) -> VerifyPolicy {
P::POLICY
}
pub fn verify_batch(&mut self, inputs: &[VerifyInput<'_>], out: &mut [bool]) {
C::dispatch_verify_batch(self, inputs, out);
}
}
impl Default for RuntimeVerifier<NullKeyCache> {
fn default() -> Self {
Self::new()
}
}
impl RuntimeVerifier<NullKeyCache> {
pub fn new() -> Self {
Self::with_policy(VerifyPolicy::default())
}
pub fn with_policy(policy: VerifyPolicy) -> Self {
Self::with_cache(policy, NullKeyCache::new())
}
}
impl<C: KeyCache> RuntimeVerifier<C> {
pub fn with_cache(policy: VerifyPolicy, cache: C) -> Self {
match policy {
VerifyPolicy::Zip215 => Self::Zip215(Zip215Verifier::with_cache(cache)),
VerifyPolicy::Dalek => Self::Dalek(DalekVerifier::with_cache(cache)),
}
}
pub fn cache(&self) -> &C {
match self {
Self::Zip215(verifier) => verifier.cache(),
Self::Dalek(verifier) => verifier.cache(),
}
}
pub fn cache_mut(&mut self) -> &mut C {
match self {
Self::Zip215(verifier) => verifier.cache_mut(),
Self::Dalek(verifier) => verifier.cache_mut(),
}
}
pub fn policy(&self) -> VerifyPolicy {
match self {
Self::Zip215(_) => VerifyPolicy::Zip215,
Self::Dalek(_) => VerifyPolicy::Dalek,
}
}
pub fn verify_batch(&mut self, inputs: &[VerifyInput<'_>], out: &mut [bool]) {
match self {
Self::Zip215(verifier) => verifier.verify_batch(inputs, out),
Self::Dalek(verifier) => verifier.verify_batch(inputs, out),
}
}
}