zescrow-core 0.3.0

Core library for Zescrow: zero-knowledge escrow transactions via RISC Zero zkVM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use bincode::{Decode, Encode};
#[cfg(feature = "json")]
use hex::serde as hex_serde;
#[cfg(feature = "json")]
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use subtle::ConstantTimeEq;

#[cfg(feature = "json")]
use crate::serde::utf8_serde;

/// A hashlock condition requiring SHA-256 preimage verification.
///
/// The condition is satisfied when `SHA-256(preimage) == hash`.
///
/// # Example
///
/// ```
/// use sha2::{Digest, Sha256};
/// use zescrow_core::Condition;
///
/// let preimage = b"my-secret-preimage".to_vec();
/// let hash: [u8; 32] = Sha256::digest(&preimage).into();
///
/// let condition = Condition::hashlock(hash, preimage);
/// assert!(condition.verify().is_ok());
/// ```
#[cfg_attr(feature = "json", derive(Serialize, Deserialize))]
#[derive(Debug, Clone, Encode, Decode, PartialEq, Eq)]
pub struct Hashlock {
    /// The expected SHA-256 digest of the preimage.
    #[cfg_attr(feature = "json", serde(with = "hex_serde"))]
    pub hash: [u8; 32],

    /// Secret preimage as UTF-8 string.
    #[cfg_attr(feature = "json", serde(with = "utf8_serde"))]
    pub preimage: Vec<u8>,
}

impl Hashlock {
    /// Verifies that `SHA-256(preimage) == hash` using constant-time comparison.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Mismatch`] if the computed hash does not match.
    pub fn verify(&self) -> Result<(), Error> {
        let computed = Sha256::digest(&self.preimage);
        computed[..]
            .ct_eq(&self.hash)
            .unwrap_u8()
            .eq(&1)
            .then_some(())
            .ok_or(Error::Mismatch)
    }
}

/// Errors from hashlock verification.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// The provided preimage did not hash to the expected value.
    #[error("SHA256(preimage) != hash")]
    Mismatch,
}