proof-of-sql 0.128.2

High performance zero knowledge (ZK) prover for SQL.
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

use super::{fold_columns, fold_vals};
use crate::{
    base::{database::Column, math::decimal::Precision},
    proof_primitive::inner_product::curve_25519_scalar::Curve25519Scalar,
};
use bumpalo::Bump;
use num_traits::Zero;

#[test]
fn we_can_fold_columns_with_scalars() {
    let expected = vec![
        Curve25519Scalar::from(77 + 1602 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("1"),
        Curve25519Scalar::from(77 + 2703 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("2"),
        Curve25519Scalar::from(77 + 3805 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("3"),
        Curve25519Scalar::from(77 + 4907 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("4"),
        Curve25519Scalar::from(77 + 5001 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("5"),
    ];

    let str_scalars: [Curve25519Scalar; 5] =
        ["1".into(), "2".into(), "3".into(), "4".into(), "5".into()];
    let scalars = [2.into(), 3.into(), 5.into(), 7.into(), 1.into()];
    let mut columns = vec![
        Column::BigInt(&[1, 2, 3, 4, 5]),
        Column::Int128(&[6, 7, 8, 9, 0]),
        Column::VarChar((&["1", "2", "3", "4", "5"], &str_scalars)),
        Column::Scalar(&scalars),
    ];

    let alloc = Bump::new();
    let result = alloc.alloc_slice_fill_copy(5, 77.into());
    fold_columns(result, 33.into(), 10.into(), &columns);

    assert_eq!(result, expected);

    columns.pop();
    columns.push(Column::Decimal75(Precision::new(75).unwrap(), -1, &scalars));

    let alloc = Bump::new();
    let result = alloc.alloc_slice_fill_copy(5, 77.into());
    fold_columns(result, 33.into(), 10.into(), &columns);

    assert_eq!(result, expected);
}

#[test]
fn we_can_fold_columns_with_that_get_padded() {
    let expected = vec![
        Curve25519Scalar::from(77 + 1602 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("1"),
        Curve25519Scalar::from(77 + 2703 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("2"),
        Curve25519Scalar::from(77 + 3800 * 33)
            + Curve25519Scalar::from(10 * 33) * Curve25519Scalar::from("3"),
        Curve25519Scalar::from(77 + 4900 * 33),
        Curve25519Scalar::from(77 + 5000 * 33),
        Curve25519Scalar::from(77),
        Curve25519Scalar::from(77),
        Curve25519Scalar::from(77),
        Curve25519Scalar::from(77),
        Curve25519Scalar::from(77),
        Curve25519Scalar::from(77),
    ];

    let str_scalars: [Curve25519Scalar; 3] = ["1".into(), "2".into(), "3".into()];
    let scalars = [2.into(), 3.into()];
    let mut columns = vec![
        Column::BigInt(&[1, 2, 3, 4, 5]),
        Column::Int128(&[6, 7, 8, 9]),
        Column::VarChar((&["1", "2", "3"], &str_scalars)),
        Column::Scalar(&scalars),
    ];
    let alloc = Bump::new();
    let result = alloc.alloc_slice_fill_copy(11, 77.into());
    fold_columns(result, 33.into(), 10.into(), &columns);

    assert_eq!(result, expected);

    columns.pop();
    columns.push(Column::Decimal75(Precision::new(75).unwrap(), -1, &scalars));

    let alloc = Bump::new();
    let result = alloc.alloc_slice_fill_copy(11, 77.into());
    fold_columns(result, 33.into(), 10.into(), &columns);

    assert_eq!(result, expected);
}

#[test]
fn we_can_fold_empty_columns() {
    let columns = vec![
        Column::BigInt::<Curve25519Scalar>(&[]),
        Column::Int128(&[]),
        Column::VarChar((&[], &[])),
        Column::Scalar(&[]),
        Column::Decimal75(Precision::new(75).unwrap(), -1, &[]),
    ];
    let alloc = Bump::new();
    let result = alloc.alloc_slice_fill_copy(0, 77.into());
    fold_columns(result, 33.into(), 10.into(), &columns);
    assert_eq!(result, vec![]);
}

#[test]
fn we_can_fold_vals() {
    assert_eq!(fold_vals(Curve25519Scalar::from(10), &[]), Zero::zero());
    assert_eq!(
        fold_vals(
            10.into(),
            &[
                Curve25519Scalar::from(1),
                2.into(),
                3.into(),
                4.into(),
                5.into()
            ]
        ),
        (12345).into()
    );
}