knock-verify (Rust)

[dependencies]
knock-verify = { git = "https://github.com/getknock/knock" }
alloy = { version = "2.5", default-features = false, features = ["std"] }

use knock_verify::{Store, Strict, Verifier, accepted_binding};

fn now() -> u64 {
    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs()
}

pub async fn example(chain: MyChain, assertion: serde_json::Value) -> anyhow::Result<()> {
    let verifier = Verifier::new(
        chain,                                     // your Chain: mainnet and World Chain
        Store::open("knock.db")?,                  // or ":memory:" for tests
        "https://club.example".to_string(),        // the origin knocks must be for
        accepted_binding().map_err(anyhow::Error::msg)?, // KnockBinding v3, production
        365 * 86_400,                              // the oldest binding it takes, in seconds
    )
    .strict(Strict::Off);

    // For the page: pass challenge.challenge to knock()
    let challenge = verifier.challenge(now()).map_err(|r| anyhow::anyhow!(r.why))?;

    // The knock the page sent back
    match verifier.verify(&assertion, Some("enter"), now()).await {
        Ok(knocked) => println!("in: {} (human {})", knocked.name, knocked.nullifier),
        Err(no) => println!("refused at check {}: {} ({})", no.check, no.why, no.error),
    }
    Ok(())
}

pub struct Verifier<C> {
    pub chain: C,
    pub store: Store,
    pub origin: String,
    pub contract: Address,
    pub max_binding_age: u64,
    pub strict: Strict,
    /* a cache of deep ENS reads */
}

pub trait Chain: Sync {
    fn head(&self) -> impl Future<Output = Result<u64, Unavailable>> + Send;
    fn records(&self, name: &str, block: u64) -> impl Future<Output = Result<Records, Unavailable>> + Send;
    fn receipt(&self, tx: B256) -> impl Future<Output = Result<Option<Receipt>, Unavailable>> + Send;
    fn final_block(&self, strict: Strict) -> impl Future<Output = Result<u64, Unavailable>> + Send;
}

impl Chain for MyChain {
    async fn head(&self) -> Result<u64, Unavailable> {
        self.eth.get_block_number().await.map_err(|e| Unavailable(format!("mainnet: {e}")))
    }
    // records, receipt, final_block …
}