1pub const SXT_CPU_BACKEND: u32 = 1;
4pub const SXT_GPU_BACKEND: u32 = 2;
5pub const SXT_CURVE_RISTRETTO255: u32 = 0;
6pub const SXT_CURVE_BLS_381: u32 = 1;
7pub const SXT_CURVE_BN_254: u32 = 2;
8pub const SXT_CURVE_GRUMPKIN: u32 = 3;
9pub const SXT_FIELD_SCALAR255: u32 = 0;
10pub const SXT_FIELD_GRUMPKIN: u32 = 1;
11#[doc = " config struct to hold the chosen backend"]
12#[repr(C)]
13#[derive(Debug, Copy, Clone)]
14pub struct sxt_config {
15 pub backend: ::std::os::raw::c_int,
16 pub num_precomputed_generators: u64,
17}
18#[test]
19fn bindgen_test_layout_sxt_config() {
20 const UNINIT: ::std::mem::MaybeUninit<sxt_config> = ::std::mem::MaybeUninit::uninit();
21 let ptr = UNINIT.as_ptr();
22 assert_eq!(
23 ::std::mem::size_of::<sxt_config>(),
24 16usize,
25 concat!("Size of: ", stringify!(sxt_config))
26 );
27 assert_eq!(
28 ::std::mem::align_of::<sxt_config>(),
29 8usize,
30 concat!("Alignment of ", stringify!(sxt_config))
31 );
32 assert_eq!(
33 unsafe { ::std::ptr::addr_of!((*ptr).backend) as usize - ptr as usize },
34 0usize,
35 concat!(
36 "Offset of field: ",
37 stringify!(sxt_config),
38 "::",
39 stringify!(backend)
40 )
41 );
42 assert_eq!(
43 unsafe { ::std::ptr::addr_of!((*ptr).num_precomputed_generators) as usize - ptr as usize },
44 8usize,
45 concat!(
46 "Offset of field: ",
47 stringify!(sxt_config),
48 "::",
49 stringify!(num_precomputed_generators)
50 )
51 );
52}
53#[doc = " encodes an element of the `ristretto255` group"]
54#[repr(C)]
55#[derive(Debug, Copy, Clone)]
56pub struct sxt_ristretto255_compressed {
57 pub ristretto_bytes: [u8; 32usize],
58}
59#[test]
60fn bindgen_test_layout_sxt_ristretto255_compressed() {
61 const UNINIT: ::std::mem::MaybeUninit<sxt_ristretto255_compressed> =
62 ::std::mem::MaybeUninit::uninit();
63 let ptr = UNINIT.as_ptr();
64 assert_eq!(
65 ::std::mem::size_of::<sxt_ristretto255_compressed>(),
66 32usize,
67 concat!("Size of: ", stringify!(sxt_ristretto255_compressed))
68 );
69 assert_eq!(
70 ::std::mem::align_of::<sxt_ristretto255_compressed>(),
71 1usize,
72 concat!("Alignment of ", stringify!(sxt_ristretto255_compressed))
73 );
74 assert_eq!(
75 unsafe { ::std::ptr::addr_of!((*ptr).ristretto_bytes) as usize - ptr as usize },
76 0usize,
77 concat!(
78 "Offset of field: ",
79 stringify!(sxt_ristretto255_compressed),
80 "::",
81 stringify!(ristretto_bytes)
82 )
83 );
84}
85#[doc = " encodes an element of the `bls12-381` `G1` group in compressed form"]
86#[repr(C)]
87#[derive(Debug, Copy, Clone)]
88pub struct sxt_bls12_381_g1_compressed {
89 pub g1_bytes: [u8; 48usize],
90}
91#[test]
92fn bindgen_test_layout_sxt_bls12_381_g1_compressed() {
93 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1_compressed> =
94 ::std::mem::MaybeUninit::uninit();
95 let ptr = UNINIT.as_ptr();
96 assert_eq!(
97 ::std::mem::size_of::<sxt_bls12_381_g1_compressed>(),
98 48usize,
99 concat!("Size of: ", stringify!(sxt_bls12_381_g1_compressed))
100 );
101 assert_eq!(
102 ::std::mem::align_of::<sxt_bls12_381_g1_compressed>(),
103 1usize,
104 concat!("Alignment of ", stringify!(sxt_bls12_381_g1_compressed))
105 );
106 assert_eq!(
107 unsafe { ::std::ptr::addr_of!((*ptr).g1_bytes) as usize - ptr as usize },
108 0usize,
109 concat!(
110 "Offset of field: ",
111 stringify!(sxt_bls12_381_g1_compressed),
112 "::",
113 stringify!(g1_bytes)
114 )
115 );
116}
117#[doc = " encodes an element of the finite field for `curve25519`\n\n modulo `(2^252 + 27742317777372353535851937790883648493)`"]
118#[repr(C)]
119#[derive(Debug, Copy, Clone)]
120pub struct sxt_curve25519_scalar {
121 pub bytes: [u8; 32usize],
122}
123#[test]
124fn bindgen_test_layout_sxt_curve25519_scalar() {
125 const UNINIT: ::std::mem::MaybeUninit<sxt_curve25519_scalar> =
126 ::std::mem::MaybeUninit::uninit();
127 let ptr = UNINIT.as_ptr();
128 assert_eq!(
129 ::std::mem::size_of::<sxt_curve25519_scalar>(),
130 32usize,
131 concat!("Size of: ", stringify!(sxt_curve25519_scalar))
132 );
133 assert_eq!(
134 ::std::mem::align_of::<sxt_curve25519_scalar>(),
135 1usize,
136 concat!("Alignment of ", stringify!(sxt_curve25519_scalar))
137 );
138 assert_eq!(
139 unsafe { ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize },
140 0usize,
141 concat!(
142 "Offset of field: ",
143 stringify!(sxt_curve25519_scalar),
144 "::",
145 stringify!(bytes)
146 )
147 );
148}
149#[doc = " encodes a strobe-based transcript"]
150#[repr(C)]
151#[derive(Debug, Copy, Clone)]
152pub struct sxt_transcript {
153 pub bytes: [u8; 203usize],
154}
155#[test]
156fn bindgen_test_layout_sxt_transcript() {
157 const UNINIT: ::std::mem::MaybeUninit<sxt_transcript> = ::std::mem::MaybeUninit::uninit();
158 let ptr = UNINIT.as_ptr();
159 assert_eq!(
160 ::std::mem::size_of::<sxt_transcript>(),
161 203usize,
162 concat!("Size of: ", stringify!(sxt_transcript))
163 );
164 assert_eq!(
165 ::std::mem::align_of::<sxt_transcript>(),
166 1usize,
167 concat!("Alignment of ", stringify!(sxt_transcript))
168 );
169 assert_eq!(
170 unsafe { ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize },
171 0usize,
172 concat!(
173 "Offset of field: ",
174 stringify!(sxt_transcript),
175 "::",
176 stringify!(bytes)
177 )
178 );
179}
180#[doc = " encodes an element of the `curve25519` group"]
181#[repr(C)]
182#[derive(Debug, Copy, Clone)]
183pub struct sxt_ristretto255 {
184 pub X: [u64; 5usize],
185 pub Y: [u64; 5usize],
186 pub Z: [u64; 5usize],
187 pub T: [u64; 5usize],
188}
189#[test]
190fn bindgen_test_layout_sxt_ristretto255() {
191 const UNINIT: ::std::mem::MaybeUninit<sxt_ristretto255> = ::std::mem::MaybeUninit::uninit();
192 let ptr = UNINIT.as_ptr();
193 assert_eq!(
194 ::std::mem::size_of::<sxt_ristretto255>(),
195 160usize,
196 concat!("Size of: ", stringify!(sxt_ristretto255))
197 );
198 assert_eq!(
199 ::std::mem::align_of::<sxt_ristretto255>(),
200 8usize,
201 concat!("Alignment of ", stringify!(sxt_ristretto255))
202 );
203 assert_eq!(
204 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
205 0usize,
206 concat!(
207 "Offset of field: ",
208 stringify!(sxt_ristretto255),
209 "::",
210 stringify!(X)
211 )
212 );
213 assert_eq!(
214 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
215 40usize,
216 concat!(
217 "Offset of field: ",
218 stringify!(sxt_ristretto255),
219 "::",
220 stringify!(Y)
221 )
222 );
223 assert_eq!(
224 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
225 80usize,
226 concat!(
227 "Offset of field: ",
228 stringify!(sxt_ristretto255),
229 "::",
230 stringify!(Z)
231 )
232 );
233 assert_eq!(
234 unsafe { ::std::ptr::addr_of!((*ptr).T) as usize - ptr as usize },
235 120usize,
236 concat!(
237 "Offset of field: ",
238 stringify!(sxt_ristretto255),
239 "::",
240 stringify!(T)
241 )
242 );
243}
244#[doc = " encodes an affine element of the `bls12-381` `G1` group"]
245#[repr(C)]
246#[derive(Debug, Copy, Clone)]
247pub struct sxt_bls12_381_g1 {
248 pub X: [u64; 6usize],
249 pub Y: [u64; 6usize],
250}
251#[test]
252fn bindgen_test_layout_sxt_bls12_381_g1() {
253 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1> = ::std::mem::MaybeUninit::uninit();
254 let ptr = UNINIT.as_ptr();
255 assert_eq!(
256 ::std::mem::size_of::<sxt_bls12_381_g1>(),
257 96usize,
258 concat!("Size of: ", stringify!(sxt_bls12_381_g1))
259 );
260 assert_eq!(
261 ::std::mem::align_of::<sxt_bls12_381_g1>(),
262 8usize,
263 concat!("Alignment of ", stringify!(sxt_bls12_381_g1))
264 );
265 assert_eq!(
266 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
267 0usize,
268 concat!(
269 "Offset of field: ",
270 stringify!(sxt_bls12_381_g1),
271 "::",
272 stringify!(X)
273 )
274 );
275 assert_eq!(
276 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
277 48usize,
278 concat!(
279 "Offset of field: ",
280 stringify!(sxt_bls12_381_g1),
281 "::",
282 stringify!(Y)
283 )
284 );
285}
286#[doc = " encodes an affine element of the `bls12-381` `G1` group in projective form"]
287#[repr(C)]
288#[derive(Debug, Copy, Clone)]
289pub struct sxt_bls12_381_g1_p2 {
290 pub X: [u64; 6usize],
291 pub Y: [u64; 6usize],
292 pub Z: [u64; 6usize],
293}
294#[test]
295fn bindgen_test_layout_sxt_bls12_381_g1_p2() {
296 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1_p2> = ::std::mem::MaybeUninit::uninit();
297 let ptr = UNINIT.as_ptr();
298 assert_eq!(
299 ::std::mem::size_of::<sxt_bls12_381_g1_p2>(),
300 144usize,
301 concat!("Size of: ", stringify!(sxt_bls12_381_g1_p2))
302 );
303 assert_eq!(
304 ::std::mem::align_of::<sxt_bls12_381_g1_p2>(),
305 8usize,
306 concat!("Alignment of ", stringify!(sxt_bls12_381_g1_p2))
307 );
308 assert_eq!(
309 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
310 0usize,
311 concat!(
312 "Offset of field: ",
313 stringify!(sxt_bls12_381_g1_p2),
314 "::",
315 stringify!(X)
316 )
317 );
318 assert_eq!(
319 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
320 48usize,
321 concat!(
322 "Offset of field: ",
323 stringify!(sxt_bls12_381_g1_p2),
324 "::",
325 stringify!(Y)
326 )
327 );
328 assert_eq!(
329 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
330 96usize,
331 concat!(
332 "Offset of field: ",
333 stringify!(sxt_bls12_381_g1_p2),
334 "::",
335 stringify!(Z)
336 )
337 );
338}
339#[doc = " encodes an affine element of the `bn254` `G1` group"]
340#[repr(C)]
341#[derive(Debug, Copy, Clone)]
342pub struct sxt_bn254_g1 {
343 pub X: [u64; 4usize],
344 pub Y: [u64; 4usize],
345 pub infinity: u8,
346}
347#[test]
348fn bindgen_test_layout_sxt_bn254_g1() {
349 const UNINIT: ::std::mem::MaybeUninit<sxt_bn254_g1> = ::std::mem::MaybeUninit::uninit();
350 let ptr = UNINIT.as_ptr();
351 assert_eq!(
352 ::std::mem::size_of::<sxt_bn254_g1>(),
353 72usize,
354 concat!("Size of: ", stringify!(sxt_bn254_g1))
355 );
356 assert_eq!(
357 ::std::mem::align_of::<sxt_bn254_g1>(),
358 8usize,
359 concat!("Alignment of ", stringify!(sxt_bn254_g1))
360 );
361 assert_eq!(
362 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
363 0usize,
364 concat!(
365 "Offset of field: ",
366 stringify!(sxt_bn254_g1),
367 "::",
368 stringify!(X)
369 )
370 );
371 assert_eq!(
372 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
373 32usize,
374 concat!(
375 "Offset of field: ",
376 stringify!(sxt_bn254_g1),
377 "::",
378 stringify!(Y)
379 )
380 );
381 assert_eq!(
382 unsafe { ::std::ptr::addr_of!((*ptr).infinity) as usize - ptr as usize },
383 64usize,
384 concat!(
385 "Offset of field: ",
386 stringify!(sxt_bn254_g1),
387 "::",
388 stringify!(infinity)
389 )
390 );
391}
392#[doc = " encodes an affine element of the `bn254` `G1` group in projective form"]
393#[repr(C)]
394#[derive(Debug, Copy, Clone)]
395pub struct sxt_bn254_g1_p2 {
396 pub X: [u64; 4usize],
397 pub Y: [u64; 4usize],
398 pub Z: [u64; 4usize],
399}
400#[test]
401fn bindgen_test_layout_sxt_bn254_g1_p2() {
402 const UNINIT: ::std::mem::MaybeUninit<sxt_bn254_g1_p2> = ::std::mem::MaybeUninit::uninit();
403 let ptr = UNINIT.as_ptr();
404 assert_eq!(
405 ::std::mem::size_of::<sxt_bn254_g1_p2>(),
406 96usize,
407 concat!("Size of: ", stringify!(sxt_bn254_g1_p2))
408 );
409 assert_eq!(
410 ::std::mem::align_of::<sxt_bn254_g1_p2>(),
411 8usize,
412 concat!("Alignment of ", stringify!(sxt_bn254_g1_p2))
413 );
414 assert_eq!(
415 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
416 0usize,
417 concat!(
418 "Offset of field: ",
419 stringify!(sxt_bn254_g1_p2),
420 "::",
421 stringify!(X)
422 )
423 );
424 assert_eq!(
425 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
426 32usize,
427 concat!(
428 "Offset of field: ",
429 stringify!(sxt_bn254_g1_p2),
430 "::",
431 stringify!(Y)
432 )
433 );
434 assert_eq!(
435 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
436 64usize,
437 concat!(
438 "Offset of field: ",
439 stringify!(sxt_bn254_g1_p2),
440 "::",
441 stringify!(Z)
442 )
443 );
444}
445#[doc = " encodes an affine element of the `grumpkin` group"]
446#[repr(C)]
447#[derive(Debug, Copy, Clone)]
448pub struct sxt_grumpkin {
449 pub X: [u64; 4usize],
450 pub Y: [u64; 4usize],
451 pub infinity: u8,
452}
453#[test]
454fn bindgen_test_layout_sxt_grumpkin() {
455 const UNINIT: ::std::mem::MaybeUninit<sxt_grumpkin> = ::std::mem::MaybeUninit::uninit();
456 let ptr = UNINIT.as_ptr();
457 assert_eq!(
458 ::std::mem::size_of::<sxt_grumpkin>(),
459 72usize,
460 concat!("Size of: ", stringify!(sxt_grumpkin))
461 );
462 assert_eq!(
463 ::std::mem::align_of::<sxt_grumpkin>(),
464 8usize,
465 concat!("Alignment of ", stringify!(sxt_grumpkin))
466 );
467 assert_eq!(
468 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
469 0usize,
470 concat!(
471 "Offset of field: ",
472 stringify!(sxt_grumpkin),
473 "::",
474 stringify!(X)
475 )
476 );
477 assert_eq!(
478 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
479 32usize,
480 concat!(
481 "Offset of field: ",
482 stringify!(sxt_grumpkin),
483 "::",
484 stringify!(Y)
485 )
486 );
487 assert_eq!(
488 unsafe { ::std::ptr::addr_of!((*ptr).infinity) as usize - ptr as usize },
489 64usize,
490 concat!(
491 "Offset of field: ",
492 stringify!(sxt_grumpkin),
493 "::",
494 stringify!(infinity)
495 )
496 );
497}
498#[doc = " encodes an affine element of the `grumpkin` group in projective form"]
499#[repr(C)]
500#[derive(Debug, Copy, Clone)]
501pub struct sxt_grumpkin_p2 {
502 pub X: [u64; 4usize],
503 pub Y: [u64; 4usize],
504 pub Z: [u64; 4usize],
505}
506#[test]
507fn bindgen_test_layout_sxt_grumpkin_p2() {
508 const UNINIT: ::std::mem::MaybeUninit<sxt_grumpkin_p2> = ::std::mem::MaybeUninit::uninit();
509 let ptr = UNINIT.as_ptr();
510 assert_eq!(
511 ::std::mem::size_of::<sxt_grumpkin_p2>(),
512 96usize,
513 concat!("Size of: ", stringify!(sxt_grumpkin_p2))
514 );
515 assert_eq!(
516 ::std::mem::align_of::<sxt_grumpkin_p2>(),
517 8usize,
518 concat!("Alignment of ", stringify!(sxt_grumpkin_p2))
519 );
520 assert_eq!(
521 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
522 0usize,
523 concat!(
524 "Offset of field: ",
525 stringify!(sxt_grumpkin_p2),
526 "::",
527 stringify!(X)
528 )
529 );
530 assert_eq!(
531 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
532 32usize,
533 concat!(
534 "Offset of field: ",
535 stringify!(sxt_grumpkin_p2),
536 "::",
537 stringify!(Y)
538 )
539 );
540 assert_eq!(
541 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
542 64usize,
543 concat!(
544 "Offset of field: ",
545 stringify!(sxt_grumpkin_p2),
546 "::",
547 stringify!(Z)
548 )
549 );
550}
551#[doc = " describes a sequence of values"]
552#[repr(C)]
553#[derive(Debug, Copy, Clone)]
554pub struct sxt_sequence_descriptor {
555 pub element_nbytes: u8,
556 pub n: u64,
557 pub data: *const u8,
558 pub is_signed: ::std::os::raw::c_int,
559}
560#[test]
561fn bindgen_test_layout_sxt_sequence_descriptor() {
562 const UNINIT: ::std::mem::MaybeUninit<sxt_sequence_descriptor> =
563 ::std::mem::MaybeUninit::uninit();
564 let ptr = UNINIT.as_ptr();
565 assert_eq!(
566 ::std::mem::size_of::<sxt_sequence_descriptor>(),
567 32usize,
568 concat!("Size of: ", stringify!(sxt_sequence_descriptor))
569 );
570 assert_eq!(
571 ::std::mem::align_of::<sxt_sequence_descriptor>(),
572 8usize,
573 concat!("Alignment of ", stringify!(sxt_sequence_descriptor))
574 );
575 assert_eq!(
576 unsafe { ::std::ptr::addr_of!((*ptr).element_nbytes) as usize - ptr as usize },
577 0usize,
578 concat!(
579 "Offset of field: ",
580 stringify!(sxt_sequence_descriptor),
581 "::",
582 stringify!(element_nbytes)
583 )
584 );
585 assert_eq!(
586 unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
587 8usize,
588 concat!(
589 "Offset of field: ",
590 stringify!(sxt_sequence_descriptor),
591 "::",
592 stringify!(n)
593 )
594 );
595 assert_eq!(
596 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
597 16usize,
598 concat!(
599 "Offset of field: ",
600 stringify!(sxt_sequence_descriptor),
601 "::",
602 stringify!(data)
603 )
604 );
605 assert_eq!(
606 unsafe { ::std::ptr::addr_of!((*ptr).is_signed) as usize - ptr as usize },
607 24usize,
608 concat!(
609 "Offset of field: ",
610 stringify!(sxt_sequence_descriptor),
611 "::",
612 stringify!(is_signed)
613 )
614 );
615}
616#[doc = " Describe inputs to a sumcheck proof.\n\n The sumcheck proof is constructed using a polynomial of the form\n\n sum_i^num_products {mult_i x prod_j^product_length_i f_j(X1, ..., Xr)}\n\n where f_j(X1, ..., Xr) denotes a multilinear extension of r variables.\n\n Pointer types are dependent on the field type as specified\n by the field id.\n\n We will let FIELD denote the field type when describing fields."]
617#[repr(C)]
618#[derive(Debug, Copy, Clone)]
619pub struct sumcheck_descriptor {
620 pub mles: *const ::std::os::raw::c_void,
621 pub product_table: *const ::std::os::raw::c_void,
622 pub product_terms: *const ::std::os::raw::c_uint,
623 pub n: ::std::os::raw::c_uint,
624 pub num_mles: ::std::os::raw::c_uint,
625 pub num_products: ::std::os::raw::c_uint,
626 #[doc = " The total number of total product terms in the sumcheck polynomial"]
627 pub num_product_terms: ::std::os::raw::c_uint,
628 pub round_degree: ::std::os::raw::c_uint,
629}
630#[test]
631fn bindgen_test_layout_sumcheck_descriptor() {
632 const UNINIT: ::std::mem::MaybeUninit<sumcheck_descriptor> = ::std::mem::MaybeUninit::uninit();
633 let ptr = UNINIT.as_ptr();
634 assert_eq!(
635 ::std::mem::size_of::<sumcheck_descriptor>(),
636 48usize,
637 concat!("Size of: ", stringify!(sumcheck_descriptor))
638 );
639 assert_eq!(
640 ::std::mem::align_of::<sumcheck_descriptor>(),
641 8usize,
642 concat!("Alignment of ", stringify!(sumcheck_descriptor))
643 );
644 assert_eq!(
645 unsafe { ::std::ptr::addr_of!((*ptr).mles) as usize - ptr as usize },
646 0usize,
647 concat!(
648 "Offset of field: ",
649 stringify!(sumcheck_descriptor),
650 "::",
651 stringify!(mles)
652 )
653 );
654 assert_eq!(
655 unsafe { ::std::ptr::addr_of!((*ptr).product_table) as usize - ptr as usize },
656 8usize,
657 concat!(
658 "Offset of field: ",
659 stringify!(sumcheck_descriptor),
660 "::",
661 stringify!(product_table)
662 )
663 );
664 assert_eq!(
665 unsafe { ::std::ptr::addr_of!((*ptr).product_terms) as usize - ptr as usize },
666 16usize,
667 concat!(
668 "Offset of field: ",
669 stringify!(sumcheck_descriptor),
670 "::",
671 stringify!(product_terms)
672 )
673 );
674 assert_eq!(
675 unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
676 24usize,
677 concat!(
678 "Offset of field: ",
679 stringify!(sumcheck_descriptor),
680 "::",
681 stringify!(n)
682 )
683 );
684 assert_eq!(
685 unsafe { ::std::ptr::addr_of!((*ptr).num_mles) as usize - ptr as usize },
686 28usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(sumcheck_descriptor),
690 "::",
691 stringify!(num_mles)
692 )
693 );
694 assert_eq!(
695 unsafe { ::std::ptr::addr_of!((*ptr).num_products) as usize - ptr as usize },
696 32usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(sumcheck_descriptor),
700 "::",
701 stringify!(num_products)
702 )
703 );
704 assert_eq!(
705 unsafe { ::std::ptr::addr_of!((*ptr).num_product_terms) as usize - ptr as usize },
706 36usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(sumcheck_descriptor),
710 "::",
711 stringify!(num_product_terms)
712 )
713 );
714 assert_eq!(
715 unsafe { ::std::ptr::addr_of!((*ptr).round_degree) as usize - ptr as usize },
716 40usize,
717 concat!(
718 "Offset of field: ",
719 stringify!(sumcheck_descriptor),
720 "::",
721 stringify!(round_degree)
722 )
723 );
724}
725#[doc = " resources for multiexponentiations with pre-specified generators"]
726#[repr(C)]
727#[derive(Debug, Copy, Clone)]
728pub struct sxt_multiexp_handle {
729 _unused: [u8; 0],
730}
731extern "C" {
732 #[doc = " Initializes the library.\n\n This should only be called once.\n\n # Arguments:\n\n - config (in): specifies which backend should be used in the computations. Those\n available are: `SXT_GPU_BACKEND`, and `SXT_CPU_BACKEND`.\n\n # Return:\n\n - `0` on success; otherwise a nonzero error code"]
733 pub fn sxt_init(config: *const sxt_config) -> ::std::os::raw::c_int;
734}
735extern "C" {
736 #[doc = " Compute the Pedersen commitments for sequences of values that internally generates `curve25519`\n group elements.\n\n Denote an element of a sequence by `a_ij` where `i` represents the sequence index\n and `j` represents the element index. Let `*` represent the operator for the\n ristretto255 group. Then `res[i]` encodes the ristretto255 group value\n\n ```text\n Prod_{j=1 to n_i} g_{offset_generators + j} ^ a_ij\n ```\n\n where `n_i` represents the number of elements in sequence `i` and `g_{offset_generators + j}`\n is a group element determined by a prespecified function\n\n ```text\n g: uint64_t -> ristretto255\n ```\n\n # Arguments:\n\n - `commitments` (out): an array of length num_sequences where the computed commitments\n of each sequence must be written into\n\n - `num_sequences` (in): specifies the number of sequences\n - `descriptors` (in): an array of length `num_sequences` that specifies each sequence\n - `offset_generators` (in): specifies the offset used to fetch the generators\n\n # Abnormal program termination in case of:\n\n - backend not initialized or incorrectly initialized\n - `descriptors == nullptr`\n - `commitments == nullptr`\n - `descriptor[i].element_nbytes == 0`\n - `descriptor[i].element_nbytes > 32`\n - `descriptor[i].n > 0 && descriptor[i].data == nullptr`\n\n # Considerations:\n\n - `num_sequences == 0` will skip the computation"]
737 pub fn sxt_curve25519_compute_pedersen_commitments(
738 commitments: *mut sxt_ristretto255_compressed,
739 num_sequences: u32,
740 descriptors: *const sxt_sequence_descriptor,
741 offset_generators: u64,
742 );
743}
744extern "C" {
745 #[doc = " Compute the Pedersen commitments for sequences of values using `curve25519` group elements.\n\n Denote an element of a sequence by `a_ij` where `i` represents the sequence index\n and `j` represents the element index. Let `*` represent the operator for the\n ristretto255 group. Then `res[i]` encodes the ristretto255 group value.\n\n ```text\n Prod_{j=1 to n_i} g_j ^ a_ij\n ```\n\n where `n_i` represents the number of elements in sequence `i` and `g_j` is a group\n element determined by the `generators[j]` user value given as input.\n\n # Arguments:\n\n - `commitments` (out): an array of length num_sequences where the computed commitments\n of each sequence must be written into\n\n - `num_sequences` (in): specifies the number of sequences\n - `descriptors` (in): an array of length `num_sequences` that specifies each sequence\n - `generators` (in): an array of length `max_num_rows` equals the maximum between all `n_i`\n\n # Abnormal program termination in case of:\n\n - backend not initialized or incorrectly initialized\n - `descriptors == nullptr`\n - `commitments == nullptr`\n - `descriptor[i].element_nbytes == 0`\n - `descriptor[i].element_nbytes > 32`\n - `descriptor[i].n > 0 && descriptor[i].data == nullptr`\n\n # Considerations:\n\n - `num_sequences == 0` will skip the computation"]
746 pub fn sxt_curve25519_compute_pedersen_commitments_with_generators(
747 commitments: *mut sxt_ristretto255_compressed,
748 num_sequences: u32,
749 descriptors: *const sxt_sequence_descriptor,
750 generators: *const sxt_ristretto255,
751 );
752}
753extern "C" {
754 #[doc = " Compute the Pedersen commitments for sequences of values using `bls12-381` `G1` group elements.\n\n Denote an element of a sequence by `a_ij` where `i` represents the sequence index\n and `j` represents the element index. Let `*` represent the operator for the\n `bls12-381` `G1` group. Then `res[i]` encodes the `bls12-381` `G1` group value\n\n ```text\n Prod_{j=1 to n_i} g_j ^ a_ij\n ```\n\n where `n_i` represents the number of elements in sequence `i` and `g_j` is a group\n element determined by the `generators[j]` user value given as input\n\n # Arguments:\n\n - `commitments` (out): an array of length num_sequences where the computed commitments\n of each sequence must be written into\n\n - `num_sequences` (in): specifies the number of sequences\n - `descriptors` (in): an array of length `num_sequences` that specifies each sequence\n - `generators` (in): an array of length `max_num_rows` equals the maximum between all `n_i`\n\n # Abnormal program termination in case of:\n\n - backend not initialized or incorrectly initialized\n - `descriptors == nullptr`\n - `commitments == nullptr`\n - `descriptor[i].element_nbytes == 0`\n - `descriptor[i].element_nbytes > 32`\n - `descriptor[i].n > 0 && descriptor[i].data == nullptr`\n\n # Considerations:\n\n - `num_sequences == 0` will skip the computation"]
755 pub fn sxt_bls12_381_g1_compute_pedersen_commitments_with_generators(
756 commitments: *mut sxt_bls12_381_g1_compressed,
757 num_sequences: u32,
758 descriptors: *const sxt_sequence_descriptor,
759 generators: *const sxt_bls12_381_g1,
760 );
761}
762extern "C" {
763 #[doc = " Compute the Pedersen commitments for sequences of values using `bn254` `G1` group elements.\n\n Denote an element of a sequence by `a_ij` where `i` represents the sequence index\n and `j` represents the element index. Let `*` represent the operator for the\n `bn254` `G1` group. Then `res[i]` encodes the `bn254` `G1` group value\n\n ```text\n Prod_{j=1 to n_i} g_j ^ a_ij\n ```\n\n where `n_i` represents the number of elements in sequence `i` and `g_j` is a group\n element determined by the `generators[j]` user value given as input\n\n # Arguments:\n\n - `commitments` (out): an array of length num_sequences where the computed commitments\n of each sequence must be written into\n\n - `num_sequences` (in): specifies the number of sequences\n - `descriptors` (in): an array of length `num_sequences` that specifies each sequence\n - `generators` (in): an array of length `max_num_rows` equals the maximum between all `n_i`\n\n # Abnormal program termination in case of:\n\n - backend not initialized or incorrectly initialized\n - `descriptors == nullptr`\n - `commitments == nullptr`\n - `descriptor[i].element_nbytes == 0`\n - `descriptor[i].element_nbytes > 32`\n - `descriptor[i].n > 0 && descriptor[i].data == nullptr`\n\n # Considerations:\n\n - `num_sequences == 0` will skip the computation"]
764 pub fn sxt_bn254_g1_uncompressed_compute_pedersen_commitments_with_generators(
765 commitments: *mut sxt_bn254_g1,
766 num_sequences: u32,
767 descriptors: *const sxt_sequence_descriptor,
768 generators: *const sxt_bn254_g1,
769 );
770}
771extern "C" {
772 #[doc = " Compute the Pedersen commitments for sequences of values using `grumpkin` group elements.\n\n Denote an element of a sequence by `a_ij` where `i` represents the sequence index\n and `j` represents the element index. Let `*` represent the operator for the\n `grumpkin` curve. Then `res[i]` encodes the `grumpkin` group value\n\n ```text\n Prod_{j=1 to n_i} g_j ^ a_ij\n ```\n\n where `n_i` represents the number of elements in sequence `i` and `g_j` is a group\n element determined by the `generators[j]` user value given as input\n\n # Arguments:\n\n - `commitments` (out): an array of length num_sequences where the computed commitments\n of each sequence must be written into\n\n - `num_sequences` (in): specifies the number of sequences\n - `descriptors` (in): an array of length `num_sequences` that specifies each sequence\n - `generators` (in): an array of length `max_num_rows` equals the maximum between all `n_i`\n\n # Abnormal program termination in case of:\n\n - backend not initialized or incorrectly initialized\n - `descriptors == nullptr`\n - `commitments == nullptr`\n - `descriptor[i].element_nbytes == 0`\n - `descriptor[i].element_nbytes > 32`\n - `descriptor[i].n > 0 && descriptor[i].data == nullptr`\n\n # Considerations:\n\n - `num_sequences == 0` will skip the computation"]
773 pub fn sxt_grumpkin_uncompressed_compute_pedersen_commitments_with_generators(
774 commitments: *mut sxt_grumpkin,
775 num_sequences: u32,
776 descriptors: *const sxt_sequence_descriptor,
777 generators: *const sxt_grumpkin,
778 );
779}
780extern "C" {
781 #[doc = " Gets the pre-specified random generated elements used for the Pedersen commitments in the\n `sxt_curve25519_compute_pedersen_commitments` function.\n\n ```text\n sxt_ristretto255_get_generators(generators, num_generators, offset_generators) →\n generators[0] = generate_random_ristretto(0 + offset_generators)\n generators[1] = generate_random_ristretto(1 + offset_generators)\n generators[2] = generate_random_ristretto(2 + offset_generators)\n ...\n generators[num_generators - 1] = generate_random_ristretto(num_generators - 1 +\n offset_generators)\n ```\n # Arguments:\n\n - `generators` (out): `sxt_ristretto255` pointer where the results must be written into\n - `offset_generators` (in): the offset that shifts the first element computed from `0` to\n `offset_generators`\n - `num_generators` (in): the total number of random generated elements to be computed\n\n # Return:\n\n - `0` on success; otherwise a nonzero error code\n\n # Invalid input parameters, which generate error code:\n\n - `num_generators > 0 && generators == nullptr`\n\n # Considerations:\n\n - `num_generators == 0` will skip the computation"]
782 pub fn sxt_ristretto255_get_generators(
783 generators: *mut sxt_ristretto255,
784 offset_generators: u64,
785 num_generators: u64,
786 ) -> ::std::os::raw::c_int;
787}
788extern "C" {
789 #[doc = " Gets the `n`-th Ristretto point.\n\n The `n`-th Ristretto point is defined as:\n\n ```text\n if n == 0:\n one_commit[0] = ristretto_identity;\n else:\n one_commit[0] = g[0] + g[1] + ... + g[n - 1];\n ```\n\n where\n\n ```text\n struct sxt_ristretto255 ristretto_identity = {\n {0, 0, 0, 0, 0},\n {1, 0, 0, 0, 0},\n {1, 0, 0, 0, 0},\n {0, 0, 0, 0, 0},\n };\n ```\n\n and `g[i]` is the `i`-th generator provided by `sxt_ristretto255_get_generators` function at\n offset `0`.\n\n # Return:\n\n - `0` on success; otherwise a nonzero error code\n\n # Invalid input parameters, which generate error code:\n\n - `one_commit == nullptr`"]
790 pub fn sxt_curve25519_get_one_commit(
791 one_commit: *mut sxt_ristretto255,
792 n: u64,
793 ) -> ::std::os::raw::c_int;
794}
795extern "C" {
796 #[doc = " Creates an inner product proof.\n\n The proof is created with respect to the base `G`, provided by\n `sxt_ristretto255_get_generators(G, generators_offset, 1ull << ceil(log2(n)))`.\n\n The `verifier` transcript is passed in as a parameter so that the\n challenges depend on the *entire* transcript (including parent\n protocols).\n\n Note that we don't have any restriction to the `n` value, other than\n it has to be non-zero.\n\n # Algorithm description\n\n Initially, we compute `G` and `Q = G[np]`, where `np = 1ull << ceil(log2(n))`\n and `G` is zero-indexed.\n\n The protocol consists of `k = ceil(lg_2(n))` rounds, indexed by `j = k - 1 , ... , 0`.\n\n In the `j`-th round, the prover computes:\n\n ```text\n a_lo = {a[0], a[1], ..., a[n / 2 - 1]}\n a_hi = {a[n/2], a[n/2 + 1], ..., a[n - 1]}\n b_lo = {b[0], b[1], ..., b[n / 2 - 1]}\n b_hi = {b[n/2], b[n/2 + 1], ..., b[n - 1]}\n G_lo = {G[0], G[1], ..., G[n / 2 - 1]}\n G_hi = {G[n/2], G[n/2 + 1], ..., G[n-1]}\n\n l_vector[j] = <a_lo, G_hi> + <a_lo, b_hi> * Q\n r_vector[j] = <a_hi, G_lo> + <a_hi, b_lo> * Q\n ```\n\n Note that if the `a` or `b` length is not a power of `2`,\n then `a` or `b` is padded with zeros until it has a power of `2`.\n `G` always has a power of `2` given how it is constructed.\n\n Then the prover sends `l_vector[j]` and `r_vector[j]` to the verifier,\n and the verifier responds with a\n challenge value `u[j] <- Z_p` (finite field of order p),\n which is non-interactively simulated by\n the input strobe-based transcript:\n\n ```text\n transcript.append(\"L\", l_vector[j]);\n transcript.append(\"R\", r_vector[j]);\n\n u[j] = transcript.challenge_value(\"x\");\n ```\n\n Then the prover uses `u[j]` to compute\n\n ```text\n a = a_lo * u[j] + (u[j]^-1) * a_hi;\n b = b_lo * (u[j]^-1) + u[j] * b_hi;\n ```\n\n Then, the prover and verifier both compute\n\n ```text\n G = G_lo * (u[j]^-1) + u[j] * G_hi\n\n n = n / 2;\n ```\n\n and use these vectors (all of length `2^j`) for the next round.\n\n After the last `(j = 0)` round, the prover sends `ap_value = a[0]` to the verifier.\n\n # Arguments:\n\n - `l_vector` (out): transcript point array with length `ceil(log2(n))`\n - `r_vector` (out): transcript point array with length `ceil(log2(n))`\n - `ap_value` (out): a single scalar\n - `transcript` (in/out): a single strobe-based transcript\n - `n` (in): non-zero length for the input arrays\n - `generators_offset` (in): offset used to fetch the bases\n - `a_vector` (in): array with length `n`\n - `b_vector` (in): array with length `n`\n\n # Abnormal program termination in case of:\n\n - `transcript`, `ap_value`, `b_vector`, or `a_vector` is `nullptr`\n - `n` is zero\n - `n` is non-zero, but `l_vector` or `r_vector` is `nullptr`"]
797 pub fn sxt_curve25519_prove_inner_product(
798 l_vector: *mut sxt_ristretto255_compressed,
799 r_vector: *mut sxt_ristretto255_compressed,
800 ap_value: *mut sxt_curve25519_scalar,
801 transcript: *mut sxt_transcript,
802 n: u64,
803 generators_offset: u64,
804 a_vector: *const sxt_curve25519_scalar,
805 b_vector: *const sxt_curve25519_scalar,
806 );
807}
808extern "C" {
809 #[doc = " Verifies an inner product proof.\n\n The proof is verified with respect to the base G, provided by\n `sxt_ristretto255_get_generators(G, generators_offset, 1ull << ceil(log2(n)))`.\n\n Note that we don't have any restriction to the `n` value, other than\n it has to be non-zero.\n\n # Arguments:\n\n - `transcript` (in/out): a single strobe-based transcript\n - `n` (in): non-zero length for the input arrays\n - `generators_offset` (in): offset used to fetch the bases\n - `b_vector` (in): array with length `n`, the same one used by\n `sxt_curve25519_prove_inner_product`\n - `product` (in): a single scalar, represented by `<a, b>`,\n the inner product of the two vectors `a` and `b` used by\n `sxt_curve25519_prove_inner_product`\n - `a_commit` (in): a single ristretto point, represented by `<a, G>` (the inner product of the\n two vectors)\n - `l_vector` (in): transcript point array with length `ceil(log2(n))`, generated by\n `sxt_curve25519_prove_inner_product`\n - `r_vector` (in): transcript point array with length `ceil(log2(n))`, generated by\n `sxt_curve25519_prove_inner_product`\n - `ap_value` (in): a single scalar, generated by `sxt_curve25519_prove_inner_product`\n\n # Return:\n\n - `1` in case the proof can be verified; otherwise, return `0`\n\n # Abnormal program termination in case of:\n\n - `transcript`, `ap_value`, `product`, `a_commit`, or `b_vector` is `nullptr`\n - `n` is zero\n - `n` is non-zero, but `l_vector` or `r_vector` is `nullptr`"]
810 pub fn sxt_curve25519_verify_inner_product(
811 transcript: *mut sxt_transcript,
812 n: u64,
813 generators_offset: u64,
814 b_vector: *const sxt_curve25519_scalar,
815 product: *const sxt_curve25519_scalar,
816 a_commit: *const sxt_ristretto255,
817 l_vector: *const sxt_ristretto255_compressed,
818 r_vector: *const sxt_ristretto255_compressed,
819 ap_value: *const sxt_curve25519_scalar,
820 ) -> ::std::os::raw::c_int;
821}
822extern "C" {
823 #[doc = " Create a handle for computing multiexponentiations using a fixed sequence of generators.\n\n Note: `generators` must match the type indicated by `curve_id`\n\n curve_id generators type\n SXT_CURVE_RISTRETTO255 struct sxt_ristretto255*\n SXT_CURVE_BLS_381 struct sxt_bls12_381_g1_p2*\n SXT_CURVE_BN_254 struct sxt_bn254_g1_p2*\n SXT_CURVE_GRUMPKIN struct sxt_grumpkin_p2*"]
824 pub fn sxt_multiexp_handle_new(
825 curve_id: ::std::os::raw::c_uint,
826 generators: *const ::std::os::raw::c_void,
827 n: ::std::os::raw::c_uint,
828 ) -> *mut sxt_multiexp_handle;
829}
830extern "C" {
831 #[doc = " Use a serialized file to create a handle for computing multiexponentiations using a fixed\n sequence of generators.\n\n Reading the handle from a file can be significantly faster than calling\n sxt_multiexp_handle_new."]
832 pub fn sxt_multiexp_handle_new_from_file(
833 curve_id: ::std::os::raw::c_uint,
834 filename: *const ::std::os::raw::c_char,
835 ) -> *mut sxt_multiexp_handle;
836}
837extern "C" {
838 #[doc = " Write a multiexponentiation handle to file.\n\n Use this function in combination with sxt_multiexp_handle_new_from_file."]
839 pub fn sxt_multiexp_handle_write_to_file(
840 handle: *const sxt_multiexp_handle,
841 filename: *const ::std::os::raw::c_char,
842 );
843}
844extern "C" {
845 #[doc = " Free resources for a multiexponentiation handle"]
846 pub fn sxt_multiexp_handle_free(handle: *mut sxt_multiexp_handle);
847}
848extern "C" {
849 #[doc = " Compute a multiexponentiation using a handle to pre-specified generators.\n\n On completion `res` contains an array of size `num_outputs` for the multiexponentiation\n of the given `scalars` array.\n\n `scalars` specifies a contiguous multi-dimension `num_outputs` by `n` array laid out in\n column-major order. An entry in the array specifies the `element_num_bytes` bytes of a\n particular scalar.\n\n For example, if `g_1, g_2, ..., g_n` are the generators associated with `handle` and\n\n ```text\n s_11, s_12, ..., s_1n\n s_21, s_22, ..., s_2n\n ```\n\n is the scalar array (laid out in memory as `s_11, s_21, s_12, s_22, ..., s_1n, s_2n`), then `res`\n will contain the two values\n\n ```text\n res[0] = g1^s11 g2^s12 ... gn^s1n\n res[1] = g1^s21 g2^s22 ... gn^s2n\n ```\n\n Note: `res` must match the generator type of the curve. See `sxt_multiexp_handle_new` for\n the types."]
850 pub fn sxt_fixed_multiexponentiation(
851 res: *mut ::std::os::raw::c_void,
852 handle: *const sxt_multiexp_handle,
853 element_num_bytes: ::std::os::raw::c_uint,
854 num_outputs: ::std::os::raw::c_uint,
855 n: ::std::os::raw::c_uint,
856 scalars: *const u8,
857 );
858}
859extern "C" {
860 #[doc = " Compute a multiexponentiation of scalars in packed format using a handle to pre-specified\n generators.\n\n On completion `res` contains an array of size `num_outputs` for the multiexponentiation\n of the given `scalars` array.\n\n An entry output_bit_table[output_index] specifies the number of scalar bits used for\n output_index.\n\n Put\n bit_sum = sum_{output_index} output_bit_table[output_index]\n and let num_bytes denote the smallest integer greater than or equal to bit_sum that is a\n multiple of 8.\n\n\n `scalars` specifies a contiguous multi-dimension `num_bytes` by `n` array laid out in\n a packed column-major order as specified by output_bit_table. A given row determines the scalar\n exponents for generator g_i with the output scalars packed contiguously and padded with zeros.\n\n Note: `res` must match the generator type of the curve. See `sxt_multiexp_handle_new` for\n the types."]
861 pub fn sxt_fixed_packed_multiexponentiation(
862 res: *mut ::std::os::raw::c_void,
863 handle: *const sxt_multiexp_handle,
864 output_bit_table: *const ::std::os::raw::c_uint,
865 num_outputs: ::std::os::raw::c_uint,
866 n: ::std::os::raw::c_uint,
867 scalars: *const u8,
868 );
869}
870extern "C" {
871 #[doc = " Compute a varying lengthing multiexponentiation of scalars in packed format using a handle to\n pre-specified generators.\n\n On completion `res` contains an array of size `num_outputs` for the multiexponentiation\n of the given `scalars` array.\n\n An entry output_bit_table[output_index] specifies the number of scalar bits used for\n output_index and output_lengths[output_index] specifies the length used for output_index.\n\n Note: output_lengths must be sorted in ascending order\n\n Put\n bit_sum = sum_{output_index} output_bit_table[output_index]\n and let num_bytes denote the smallest integer greater than or equal to bit_sum that is a\n multiple of 8.\n\n Let n denote the length of the longest output. Then `scalars` specifies a contiguous\n multi-dimension `num_bytes` by `n` array laid out in a packed column-major order as specified by\n output_bit_table. A given row determines the scalar exponents for generator g_i with the output\n scalars packed contiguously and padded with zeros.\n\n Note: `res` must match the generator type of the curve. See `sxt_multiexp_handle_new` for\n the types."]
872 pub fn sxt_fixed_vlen_multiexponentiation(
873 res: *mut ::std::os::raw::c_void,
874 handle: *const sxt_multiexp_handle,
875 output_bit_table: *const ::std::os::raw::c_uint,
876 output_lengths: *const ::std::os::raw::c_uint,
877 num_outputs: ::std::os::raw::c_uint,
878 scalars: *const u8,
879 );
880}
881extern "C" {
882 #[doc = " Construct a sumcheck proof for a polynomial\n\n sum_i^num_products {mult_i x prod_j^product_length_i f_j(X1, ..., Xr)}\n\n input:\n field_id identifies the field of the sumcheck polynomial\n descriptor describes the sumcheck polynomial\n transcript_callback points to a function with signature\n void (FIELD* r, void* context, FIELD* polynomial, unsigned polynomial_length)\n and will be invoked each sumcheck round to draw a random FIELD entry.\n\n output:\n polynomials points to an (round_degree + 1) x (num_variables) column major matrix of type FIELD\n and will be filled with the sumcheck round polynomials upon completion.\n\n evaluation_point points to a num_variables array of type FIELD and will contain\n the evaluation point for sumcheck upon completion as set by the transcript_callback.\n"]
883 pub fn sxt_prove_sumcheck(
884 polynomials: *mut ::std::os::raw::c_void,
885 evaluation_point: *mut ::std::os::raw::c_void,
886 field_id: ::std::os::raw::c_uint,
887 descriptor: *const sumcheck_descriptor,
888 transcript_callback: *mut ::std::os::raw::c_void,
889 transcript_context: *mut ::std::os::raw::c_void,
890 );
891}