proof_system 0.34.0

Proof system to comprise various cryptographic primitives
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

use crate::statement::Statement;
use ark_ec::{pairing::Pairing, AffineRepr};
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use ark_std::vec::Vec;
use dock_crypto_utils::serde_utils::ArkObjectBytes;
use serde::{Deserialize, Serialize};
use serde_with::serde_as;
use vb_accumulator::setup::SecretKey;

macro_rules! impl_struct_and_funcs {
    ($(#[$doc:meta])*
    $name:ident, $name_full_verifier: ident, $stmt_variant: ident, $stmt_full_verifier_variant: ident) => {
        #[serde_as]
        #[derive(
            Clone,
            Debug,
            PartialEq,
            Eq,
            CanonicalSerialize,
            CanonicalDeserialize,
            Serialize,
            Deserialize,
        )]
        #[serde(bound = "")]
        pub struct $name<G: AffineRepr> {
            #[serde_as(as = "ArkObjectBytes")]
            pub accumulator_value: G,
        }

        #[serde_as]
        #[derive(
            Clone,
            Debug,
            PartialEq,
            Eq,
            CanonicalSerialize,
            CanonicalDeserialize,
            Serialize,
            Deserialize,
        )]
        #[serde(bound = "")]
        pub struct $name_full_verifier<G: AffineRepr> {
            #[serde_as(as = "ArkObjectBytes")]
            pub accumulator_value: G,
            pub secret_key: SecretKey<G::ScalarField>,
        }

        impl<G: AffineRepr> $name<G> {
            pub fn new<E: Pairing<G1Affine = G>>(accumulator_value: G) -> Statement<E> {
                Statement::$stmt_variant(Self { accumulator_value })
            }
        }

        impl<G: AffineRepr> $name_full_verifier<G> {
            pub fn new<E: Pairing<G1Affine = G>>(
                accumulator_value: G,
                secret_key: SecretKey<G::ScalarField>,
            ) -> Statement<E> {
                Statement::$stmt_full_verifier_variant(Self {
                    accumulator_value,
                    secret_key,
                })
            }
        }
    };
}

impl_struct_and_funcs!(
    VBAccumulatorMembershipKV,
    VBAccumulatorMembershipKVFullVerifier,
    VBAccumulatorMembershipKV,
    VBAccumulatorMembershipKVFullVerifier
);

impl_struct_and_funcs!(
    KBUniversalAccumulatorMembershipKV,
    KBUniversalAccumulatorMembershipKVFullVerifier,
    KBUniversalAccumulatorMembershipKV,
    KBUniversalAccumulatorMembershipKVFullVerifier
);

impl_struct_and_funcs!(
    KBUniversalAccumulatorNonMembershipKV,
    KBUniversalAccumulatorNonMembershipKVFullVerifier,
    KBUniversalAccumulatorNonMembershipKV,
    KBUniversalAccumulatorNonMembershipKVFullVerifier
);