package octez-libs

  1. Overview
  2. Docs
package octez-libs
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Source file libsrs.ml

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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
(*****************************************************************************)
(*                                                                           *)
(* Open Source License                                                       *)
(* Copyright (c) 2023 Nomadic Labs <contact@nomadic-labs.com>           *)
(*                                                                           *)
(* Permission is hereby granted, free of charge, to any person obtaining a   *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense,  *)
(* and/or sell copies of the Software, and to permit persons to whom the     *)
(* Software is furnished to do so, subject to the following conditions:      *)
(*                                                                           *)
(* The above copyright notice and this permission notice shall be included   *)
(* in all copies or substantial portions of the Software.                    *)
(*                                                                           *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL   *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING   *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER       *)
(* DEALINGS IN THE SOFTWARE.                                                 *)
(*                                                                           *)
(*****************************************************************************)

open Bls12_381
module G1 = G1
module G2 = G2
module G1_carray = Octez_bls12_381_polynomial.G1_carray
module G2_carray = Octez_bls12_381_polynomial.G2_carray

module Checks = struct
  let equality (g1_elements : G1_carray.t) (g2_elements : G2_carray.t) =
    let g1 = G1_carray.get g1_elements 0 in
    let g2 = G2_carray.get g2_elements 0 in
    G1_carray.iteri_copy_elt
      (fun i g1i ->
        let g2i = G2_carray.get g2_elements i in
        let gt_element1 = Pairing.pairing g1i g2 in
        let gt_element2 = Pairing.pairing g1 g2i in
        assert (GT.eq gt_element1 gt_element2))
      g1_elements

  let incrementation_g1 g1_elements g2_elements =
    let g2 = G2_carray.get g2_elements 0 in
    let g2x = G2_carray.get g2_elements 1 in
    for i = 0 to G1_carray.length g1_elements - 2 do
      let g1i = G1_carray.get g1_elements i in
      let g1iplus = G1_carray.get g1_elements (i + 1) in
      let gt_element1 = Pairing.pairing g1i g2x in
      let gt_element2 = Pairing.pairing g1iplus g2 in
      assert (GT.eq gt_element1 gt_element2)
    done

  let incrementation_g2 g1_elements g2_elements =
    let g1 = G1_carray.get g1_elements 0 in
    let g1x = G1_carray.get g1_elements 1 in
    for i = 0 to G2_carray.length g2_elements - 2 do
      let g2i = G2_carray.get g2_elements i in
      let g2iplus = G2_carray.get g2_elements (i + 1) in
      let gt_element1 = Pairing.pairing g1x g2i in
      let gt_element2 = Pairing.pairing g1 g2iplus in
      assert (GT.eq gt_element1 gt_element2)
    done

  let pairings g1_elements g2_elements =
    equality g1_elements g2_elements ;
    incrementation_g1 g1_elements g2_elements ;
    incrementation_g2 g1_elements g2_elements
end

let exact_log2 p =
  if p <= 0 then raise @@ Invalid_argument (string_of_int p) ;
  let rec aux res p =
    if p = 1 then res
    else
      let p' = p lsr 1 in
      if p' = 1 then
        if p mod 2 <> 0 then raise @@ Invalid_argument "not a power of 2"
        else res + 1
      else aux (res + 1) p'
  in
  aux 0 p

(** The binary format of our Srs is a sequence of G1 or G2 elements. *)
module Srs = struct
  let to_file gs file to_compressed_bytes iter =
    let oc = open_out_bin file in
    try
      iter (fun g1 -> output_bytes oc (to_compressed_bytes g1)) gs ;
      close_out oc
    with e ->
      close_out oc ;
      raise e

  let gs1_to_file gs output_file =
    to_file gs output_file G1.to_compressed_bytes G1_carray.iter_copy_elt

  let gs2_to_file gs output_file =
    to_file gs output_file G2.to_compressed_bytes G2_carray.iter_copy_elt
end

(** This module handles the file format of the result of powers-of-tau ceremony.

  The layout of the file can be found at the bottom of this file
  https://github.com/ebfull/powersoftau/blob/master/src/bin/verify.rs
  to be
  let tau_powers_length = 1 lsl power in
    G1.size_in_bytes (* alpha in g1 *)
  + G1.size_in_bytes (* beta in g1 *)
  + G2.size_in_bytes (* beta in g2 *)
  + (tau_powers_length * G1.size_in_bytes) (* g1_coeffs *)
  + (tau_powers_length * G2.size_in_bytes) (* g2_coeffs *)
  + (tau_powers_length * G1.size_in_bytes) (* g1_alpha_coeffs *)
  + (tau_powers_length * G1.size_in_bytes) (* g1_beta_coeffs *)
  + ((tau_powers_length - 1) * G1.size_in_bytes) (* h *)
*)
module Powers_of_tau = struct
  let generate_domain power =
    let size = 1 lsl power in
    let rec get_omega limit =
      if limit < 32 then Fr.square (get_omega (limit + 1))
      else
        Fr.of_string
          "0x16a2a19edfe81f20d09b681922c813b4b63683508c2280b93829971f439f0d2b"
    in
    let omega = get_omega power in
    let rec encoded_pow_x acc xi i =
      if i = 0 then List.rev acc
      else encoded_pow_x (xi :: acc) (Fr.mul xi omega) (i - 1)
    in
    Array.of_list @@ encoded_pow_x [] Fr.one size

  (* Derives the power that generated the file from the total size of the
     file using this formula:
     let tau_powers_length = (total - g1 - g2) / (4g1+g2)
     let power = log2 tau_powers_length
  *)
  let power_of_radixfile radixfile =
    let ic = open_in_bin radixfile in
    try
      let g1 = G1.size_in_bytes in
      let g2 = G2.size_in_bytes in
      let filesize = in_channel_length ic in
      close_in ic ;
      let nb_elements = (filesize - g1 - g2) / ((4 * g1) + g2) in
      exact_log2 nb_elements
    with e ->
      close_in ic ;
      raise e

  let to_gs radixfile skip size_in_bytes of_bytes_exn evaluation_ecfft of_array
      =
    let power = power_of_radixfile radixfile in
    let buf = Bytes.create size_in_bytes in
    let read ic =
      Stdlib.really_input ic buf 0 size_in_bytes ;
      of_bytes_exn buf
    in
    let ic = open_in_bin radixfile in
    try
      Stdlib.seek_in ic skip ;
      let size = 1 lsl power in
      let points = Array.init size (fun _i -> read ic) |> of_array in
      close_in ic ;
      let domain = Octez_bls12_381_polynomial.Domain.build_power_of_two power in
      let points = evaluation_ecfft ~domain ~points in
      points
    with e ->
      close_in ic ;
      raise e

  let to_g1s radixfile =
    let skip_header =
      (* Skip alpha_g1, beta_g1 and beta_g2 *)
      (2 * G1.size_in_bytes) + G2.size_in_bytes
    in
    to_gs
      radixfile
      skip_header
      G1.size_in_bytes
      G1.of_bytes_exn
      G1_carray.evaluation_ecfft
      G1_carray.of_array

  let to_g2s radixfile =
    let power = power_of_radixfile radixfile in
    let size = 1 lsl power in
    let skip_header =
      (* Skip alpha_g1, beta_g1 and beta_g2 *)
      (2 * G1.size_in_bytes) + G2.size_in_bytes
    in
    let skip_g2s =
      let skip_g1s = size * G1.size_in_bytes in
      skip_header + skip_g1s
    in
    to_gs
      radixfile
      skip_g2s
      G2.size_in_bytes
      G2.of_bytes_exn
      G2_carray.evaluation_ecfft
      G2_carray.of_array
end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct