#[derive(Debug)]
pub struct Totp(totp_rs::TOTP);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TotpVerifyResult {
    pub success: bool,
    pub matched_step: Option<u64>,
}
impl Totp {
    pub fn verify(&self, token: &str) -> Result<TotpVerifyResult, Error> {
        let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
        let current_step = now / self.0.step;
        let base_step = current_step.saturating_sub(self.0.skew as u64);
        let window = (self.0.skew as u64) * 2 + 1;
        for offset in 0..window {
            let step = base_step + offset;
            if self.0.generate(step * self.0.step) == token {
                return Ok(TotpVerifyResult {
                    success: true,
                    matched_step: Some(step),
                });
            }
        }
        Ok(TotpVerifyResult {
            success: false,
            matched_step: None,
        })
    }
}

...
    /// Will check if token is valid given the provided timestamp in seconds, accounting [skew](struct.TOTP.html#structfield.skew)
    pub fn check(&self, token: &str, time: u64) -> bool {
        let basestep = time / self.step - (self.skew as u64);
        for i in 0..(self.skew as u16) * 2 + 1 {
            let step_time = (basestep + (i as u64)) * self.step;
            if constant_time_eq(self.generate(step_time).as_bytes(), token.as_bytes()) {
                return true;
            }
        }
        false
    }
    /// Will check if token is valid by current system time, accounting [skew](struct.TOTP.html#structfield.skew)
    pub fn check_current(&self, token: &str) -> Result<bool, SystemTimeError> {
        let t = system_time()?;
        Ok(self.check(token, t))
    }
...

use std::time::Duration;
use moka::{
    future::Cache,
    ops::compute::{CompResult, Op},
};
use uuid::Uuid;
#[derive(Debug, Hash, PartialEq, PartialOrd, Eq)]
struct TotpStepRecord {
    id: Uuid,
    matched_step: u64,
}
#[derive(Debug, Clone)]
pub struct TotpAntiReplay {
    cache: Cache<TotpStepRecord, ()>,
}
impl TotpAntiReplay {
    pub async fn consume(&self, id: Uuid, matched_step: u64) -> bool {
        let key = TotpStepRecord { id, matched_step };
        matches!(
            self.cache
                .entry(key)
                .and_compute_with(|entry| async move {
                    if entry.is_some() {
                        Op::Nop
                    } else {
                        Op::Put(())
                    }
                })
                .await,
            CompResult::Inserted(_)
        )
    }
}