bp-pp 0.1.1

Rust library for Bulletproofs++ - range-proof protocol in discret loggarithm setting
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::cmp::max;
use std::ops::{Add, Mul, Sub};
use k256::elliptic_curve::Field;
use k256::elliptic_curve::ops::Invert;
use k256::Scalar;

pub fn reduce<T>(v: &[T]) -> (Vec<T>, Vec<T>) where T: Copy {
    let res0 = v.iter().
        enumerate().
        filter(|(i, _)| *i as i32 % 2 == 0).
        map(|(_, x)| *x).
        collect::<Vec<T>>();


    let res1 = v.iter().
        enumerate().
        filter(|(i, _)| *i as i32 % 2 == 1).
        map(|(_, x)| *x).
        collect::<Vec<T>>();

    (res0, res1)
}

pub fn vector_extend<T>(v: &[T], n: usize) -> Vec<T> where T: Copy + Default {
    (0..n).map(|i| if i < v.len() { v[i] } else { T::default() }).collect::<Vec<T>>()
}

pub fn weight_vector_mul<T>(a: &[T], b: &[Scalar], weight: &Scalar) -> T
    where
        T: Copy + Default + Mul<Scalar, Output=T> + Add<Output=T>
{
    let mut exp = Scalar::ONE;
    let mut result = T::default();

    let a_ext = vector_extend(a, max(a.len(), b.len()));
    let b_ext = &vector_extend(b, max(a.len(), b.len()));

    a_ext.iter().zip(b_ext).for_each(|(a_val, b_val)| {
        exp = exp.mul(weight);
        result = result.add(a_val.mul(b_val.mul(&exp)));
    });

    result
}

pub fn vector_mul<T>(a: &[T], b: &[Scalar]) -> T
    where
        T: Copy + Default + Mul<Scalar, Output=T> + Add<Output=T>
{
    let mut result = T::default();

    let a_ext = &vector_extend(a, max(a.len(), b.len()));
    let b_ext = &vector_extend(b, max(a.len(), b.len()));

    a_ext.iter().zip(b_ext).for_each(|(a_val, b_val)| {
        result = result.add(a_val.mul(*b_val));
    });

    result
}

pub fn vector_mul_on_scalar<'a, T>(a: &[T], s: &'a Scalar) -> Vec<T>
    where
        T: Copy + Mul<&'a Scalar, Output=T>
{
    a.iter().map(|x| x.mul(s)).collect::<Vec<T>>()
}

pub fn vector_add<T>(a: &[T], b: &[T]) -> Vec<T>
    where
        T: Copy + Default + Add<Output=T>
{
    let a_ext = &vector_extend(a, max(a.len(), b.len()));
    let b_ext = &vector_extend(b, max(a.len(), b.len()));
    a_ext.iter().zip(b_ext).map(|(a_val, b_val)| a_val.add(*b_val)).collect::<Vec<T>>()
}

pub fn vector_sub<'a, T>(a: &'a [T], b: &'a [T]) -> Vec<T>
    where
        T: Copy + Default + Sub<Output=T>
{
    let a_ext = &vector_extend(a, max(a.len(), b.len()));
    let b_ext = &vector_extend(b, max(a.len(), b.len()));
    a_ext.iter().zip(b_ext).map(|(a_val, b_val)| a_val.sub(*b_val)).collect::<Vec<T>>()
}

pub fn e(v: &Scalar, n: usize) -> Vec<Scalar> {
    let mut buf = Scalar::ONE;

    (0..n).map(|_| {
        let val = buf;
        buf = buf.mul(v);
        val
    }).collect::<Vec<Scalar>>()
}

pub fn pow(s: &Scalar, n: usize) -> Scalar {
    s.pow_vartime([n as u64])
}

#[allow(dead_code)]
pub fn vector_hadamard_mul<T>(a: &[T], b: &[Scalar]) -> Vec<T>
    where
        T: Copy + Default + Mul<Scalar, Output=T>
{
    let a_ext = &vector_extend(a, max(a.len(), b.len()));
    let b_ext = &vector_extend(b, max(a.len(), b.len()));
    a_ext.iter().zip(b_ext).map(|(a_val, b_val)| a_val.mul(*b_val)).collect::<Vec<T>>()
}

pub fn vector_tensor_mul<'a, T>(a: &'a [T], b: &'a [Scalar]) -> Vec<T>
    where
        T: Copy + Mul<&'a Scalar, Output=T>
{
    b.iter().map(|x| vector_mul_on_scalar(a, x)).collect::<Vec<Vec<T>>>().concat()
}

pub fn diag_inv(x: &Scalar, n: usize) -> Vec<Vec<Scalar>> {
    let x_inv = x.invert_vartime().unwrap();
    let mut val = Scalar::ONE;

    (0..n).map(|i|
        (0..n).map(|j|
            if i == j {
                val = val.mul(x_inv);
                val
            } else {
                Scalar::ZERO
            }
        ).collect::<Vec<Scalar>>()
    ).collect::<Vec<Vec<Scalar>>>()
}

pub fn vector_mul_on_matrix<T>(a: &[T], m: &[Vec<Scalar>]) -> Vec<T>
    where
        T: Copy + Default + Mul<Scalar, Output=T> + Add<Output=T>
{
    (0..m[0].len()).map(|j| {
        let column = m.iter().map(|row| row[j]).collect::<Vec<Scalar>>();
        vector_mul(a, &column)
    }).collect::<Vec<T>>()
}

#[allow(dead_code)]
pub fn matrix_mul_on_vector<T>(a: &[T], m: &[Vec<Scalar>]) -> Vec<T>
    where
        T: Copy + Default + Mul<Scalar, Output=T> + Add<Output=T>
{
    m.iter().map(|v| vector_mul(a, v)).collect::<Vec<T>>()
}


pub fn minus<T>(v: &T) -> T where T: Copy + Mul<Scalar, Output=T> {
    v.mul(Scalar::ZERO.sub(&Scalar::ONE))
}