libecvrf 1.1.2

A ECVRF that's friendly with EVM, based on curve secp256k1 and keccak256
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

extern crate alloc;
use crate::helper::random_bytes;
use alloc::{string::String, vec::Vec};
use libsecp256k1::curve::{Affine, Field, Jacobian, Scalar};
use tiny_keccak::{Hasher, Keccak};

/// Extend Affine
pub trait AffineExtend {
    /// Compose Affine for its coordinate X,Y
    fn compose(x: &Field, y: &Field) -> Self;

    /// Create Affine from Jacobian
    fn from_jacobian(j: &Jacobian) -> Self;

    /// Serialize Affine to hex string
    fn to_hex_string(&self) -> String;

    /// Keccak Affine to bytes array
    fn keccak256(&self) -> [u8; 32];
}

/// Extend Scalar
pub trait ScalarExtend {
    /// Create Scalar from bytes array
    fn from_bytes(bytes: &[u8]) -> Self;

    /// Randomize Scalar
    fn randomize() -> Self;

    /// Keccak a vector to scalar
    fn keccak256(a: &Vec<u8>) -> Self;

    /// Make sure self > b
    fn gt(&self, b: &Scalar) -> bool;

    /// Make sure self >= b
    fn gte(&self, b: &Scalar) -> bool;
}

impl AffineExtend for Affine {
    fn compose(x: &Field, y: &Field) -> Self {
        let mut r = Affine::default();
        r.set_xy(x, y);
        r.x.normalize();
        r.y.normalize();
        r
    }

    fn to_hex_string(&self) -> String {
        hex::encode([self.x.b32(), self.y.b32()].concat())
    }

    fn keccak256(&self) -> [u8; 32] {
        let mut output = [0u8; 32];
        let mut hasher = Keccak::v256();
        hasher.update(self.x.b32().as_ref());
        hasher.update(self.y.b32().as_ref());
        hasher.finalize(&mut output);
        output
    }

    fn from_jacobian(j: &Jacobian) -> Self {
        let mut ra = Affine::from_gej(j);
        ra.x.normalize();
        ra.y.normalize();
        ra
    }
}

impl ScalarExtend for Scalar {
    fn from_bytes(bytes: &[u8]) -> Self {
        if bytes.len() > 32 {
            panic!("Bytes length must be less than 32")
        }
        let mut tmp_bytes = [0u8; 32];
        tmp_bytes[0..bytes.len()].copy_from_slice(bytes);
        let mut r = Scalar::default();
        r.set_b32(&tmp_bytes).unwrap_u8();
        r
    }

    /// Return true if a > b
    fn gt(&self, b: &Scalar) -> bool {
        for i in (0..self.0.len()).rev() {
            if self.0[i] < b.0[i] {
                return false;
            }
            if self.0[i] > b.0[i] {
                return true;
            }
        }
        false
    }

    /// Return true if a >= b
    fn gte(&self, b: &Scalar) -> bool {
        for i in (0..self.0.len()).rev() {
            if self.0[i] < b.0[i] {
                return false;
            }
            if self.0[i] > b.0[i] {
                return true;
            }
        }
        true
    }

    fn keccak256(a: &Vec<u8>) -> Self {
        let mut output = [0u8; 32];
        let mut hasher = Keccak::v256();
        hasher.update(a.as_slice());
        hasher.finalize(&mut output);
        Self::from_bytes(&output)
    }

    fn randomize() -> Self {
        let mut buf = [0u8; 32];
        random_bytes(&mut buf);
        Self::from_bytes(&buf)
    }
}