lilium-transcript 0.1.0

Transcript implementation for Lilium
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

use crate::{
    messages::PointRound,
    params::{ParamResolver, ParamStack},
    protocols::{Protocol, Reduction},
    Message, Transcript,
};
use ark_ff::Field;
use sponge::sponge::{Duplex, SpongeBuilder};
use std::any::{Any, TypeId};

pub struct TranscriptBuilder {
    rounds: Vec<(TypeId, usize)>,
    //TODO: can likely be handled through params
    vars: usize,
    sponge_builder: SpongeBuilder,
    params: ParamStack,
}

impl TranscriptBuilder {
    pub fn with_params<F>(mut self, params: ParamResolver, f: F) -> Self
    where
        F: Fn(Self) -> Self,
    {
        self.params.push(params);
        let mut builder = f(self);
        builder.params.pop();
        builder
    }

    pub fn add_protocol_patter<F: Field, S: Protocol<F>>(self, key: &S::Key) -> Self {
        S::transcript_pattern(key, self)
    }

    pub fn add_reduction_patter<F: Field, S: Reduction<F>>(self, key: &S::Key) -> Self {
        S::transcript_pattern(key, self)
    }

    pub fn new(vars: usize, params: ParamResolver) -> Self {
        let sponge_builder = SpongeBuilder::new();
        Self {
            rounds: vec![],
            vars,
            sponge_builder,
            params: ParamStack::new(vec![params]),
        }
    }

    pub fn round<F: Field, T: Any + Message<F>, const N: usize>(self) -> Self {
        let Self {
            mut rounds,
            sponge_builder,
            vars,
            params,
        } = self;
        let id = TypeId::of::<T>();
        rounds.push((id, N));

        let resolver = params.top();
        let sponge_builder = sponge_builder
            .absorb(T::len(vars, resolver).try_into().unwrap())
            .squeeze(N.try_into().unwrap());

        Self {
            rounds,
            sponge_builder,
            params,
            ..self
        }
    }

    pub fn point(self) -> Self {
        let Self {
            mut rounds,
            vars,
            sponge_builder,
            ..
        } = self;
        let round = (TypeId::of::<PointRound>(), vars);
        rounds.push(round);
        let sponge_builder = sponge_builder.squeeze(vars.try_into().unwrap());
        Self {
            rounds,
            vars,
            sponge_builder,
            ..self
        }
    }

    fn fold_round_rec<F: Field, T: Any + Message<F>, const N: usize>(self, left: usize) -> Self {
        if left == 0 {
            self
        } else {
            let builder = self.round::<F, T, N>();
            builder.fold_round_rec::<F, T, N>(left - 1)
        }
    }

    /// Adds V rounds for the V variables in the transcript for split and fold
    /// protocols which send one message per variable.
    pub fn fold_rounds<F: Field, T: Any + Message<F>, const N: usize>(self) -> Self {
        let vars = self.vars;
        self.fold_round_rec::<F, T, N>(vars)
    }

    pub fn finish<F: Field, S: Duplex<F>>(self) -> TranscriptDescriptor<F, S> {
        let Self {
            rounds,
            sponge_builder,
            vars,
            ..
        } = self;
        let sponge = S::from_builder(sponge_builder);
        TranscriptDescriptor {
            sponge,
            rounds,
            vars,
        }
    }

    pub fn repeat<const N: usize, M: Fn(Self, usize) -> Self>(self, f: M) -> Self {
        (0..N).fold(self, f)
    }
}

pub struct TranscriptDescriptor<F: Field, S: Duplex<F>> {
    sponge: S::Initializer,
    rounds: Vec<(TypeId, usize)>,
    vars: usize,
}

impl<F: Field, S: Duplex<F>> TranscriptDescriptor<F, S> {
    pub fn instanciate(&self) -> Transcript<F, S> {
        let sponge = S::instanciate(&self.sponge);
        let rounds = self.rounds.clone().into_iter();
        Transcript::new(sponge, rounds, self.vars)
    }
}