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;
10#[doc = " config struct to hold the chosen backend"]
11#[repr(C)]
12#[derive(Debug, Copy, Clone)]
13pub struct sxt_config {
14 pub backend: ::std::os::raw::c_int,
15 pub num_precomputed_generators: u64,
16}
17#[test]
18fn bindgen_test_layout_sxt_config() {
19 const UNINIT: ::std::mem::MaybeUninit<sxt_config> = ::std::mem::MaybeUninit::uninit();
20 let ptr = UNINIT.as_ptr();
21 assert_eq!(
22 ::std::mem::size_of::<sxt_config>(),
23 16usize,
24 concat!("Size of: ", stringify!(sxt_config))
25 );
26 assert_eq!(
27 ::std::mem::align_of::<sxt_config>(),
28 8usize,
29 concat!("Alignment of ", stringify!(sxt_config))
30 );
31 assert_eq!(
32 unsafe { ::std::ptr::addr_of!((*ptr).backend) as usize - ptr as usize },
33 0usize,
34 concat!(
35 "Offset of field: ",
36 stringify!(sxt_config),
37 "::",
38 stringify!(backend)
39 )
40 );
41 assert_eq!(
42 unsafe { ::std::ptr::addr_of!((*ptr).num_precomputed_generators) as usize - ptr as usize },
43 8usize,
44 concat!(
45 "Offset of field: ",
46 stringify!(sxt_config),
47 "::",
48 stringify!(num_precomputed_generators)
49 )
50 );
51}
52#[doc = " encodes an element of the `ristretto255` group"]
53#[repr(C)]
54#[derive(Debug, Copy, Clone)]
55pub struct sxt_ristretto255_compressed {
56 pub ristretto_bytes: [u8; 32usize],
57}
58#[test]
59fn bindgen_test_layout_sxt_ristretto255_compressed() {
60 const UNINIT: ::std::mem::MaybeUninit<sxt_ristretto255_compressed> =
61 ::std::mem::MaybeUninit::uninit();
62 let ptr = UNINIT.as_ptr();
63 assert_eq!(
64 ::std::mem::size_of::<sxt_ristretto255_compressed>(),
65 32usize,
66 concat!("Size of: ", stringify!(sxt_ristretto255_compressed))
67 );
68 assert_eq!(
69 ::std::mem::align_of::<sxt_ristretto255_compressed>(),
70 1usize,
71 concat!("Alignment of ", stringify!(sxt_ristretto255_compressed))
72 );
73 assert_eq!(
74 unsafe { ::std::ptr::addr_of!((*ptr).ristretto_bytes) as usize - ptr as usize },
75 0usize,
76 concat!(
77 "Offset of field: ",
78 stringify!(sxt_ristretto255_compressed),
79 "::",
80 stringify!(ristretto_bytes)
81 )
82 );
83}
84#[doc = " encodes an element of the `bls12-381` `G1` group in compressed form"]
85#[repr(C)]
86#[derive(Debug, Copy, Clone)]
87pub struct sxt_bls12_381_g1_compressed {
88 pub g1_bytes: [u8; 48usize],
89}
90#[test]
91fn bindgen_test_layout_sxt_bls12_381_g1_compressed() {
92 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1_compressed> =
93 ::std::mem::MaybeUninit::uninit();
94 let ptr = UNINIT.as_ptr();
95 assert_eq!(
96 ::std::mem::size_of::<sxt_bls12_381_g1_compressed>(),
97 48usize,
98 concat!("Size of: ", stringify!(sxt_bls12_381_g1_compressed))
99 );
100 assert_eq!(
101 ::std::mem::align_of::<sxt_bls12_381_g1_compressed>(),
102 1usize,
103 concat!("Alignment of ", stringify!(sxt_bls12_381_g1_compressed))
104 );
105 assert_eq!(
106 unsafe { ::std::ptr::addr_of!((*ptr).g1_bytes) as usize - ptr as usize },
107 0usize,
108 concat!(
109 "Offset of field: ",
110 stringify!(sxt_bls12_381_g1_compressed),
111 "::",
112 stringify!(g1_bytes)
113 )
114 );
115}
116#[doc = " encodes an element of the finite field for `curve25519`\n\n modulo `(2^252 + 27742317777372353535851937790883648493)`"]
117#[repr(C)]
118#[derive(Debug, Copy, Clone)]
119pub struct sxt_curve25519_scalar {
120 pub bytes: [u8; 32usize],
121}
122#[test]
123fn bindgen_test_layout_sxt_curve25519_scalar() {
124 const UNINIT: ::std::mem::MaybeUninit<sxt_curve25519_scalar> =
125 ::std::mem::MaybeUninit::uninit();
126 let ptr = UNINIT.as_ptr();
127 assert_eq!(
128 ::std::mem::size_of::<sxt_curve25519_scalar>(),
129 32usize,
130 concat!("Size of: ", stringify!(sxt_curve25519_scalar))
131 );
132 assert_eq!(
133 ::std::mem::align_of::<sxt_curve25519_scalar>(),
134 1usize,
135 concat!("Alignment of ", stringify!(sxt_curve25519_scalar))
136 );
137 assert_eq!(
138 unsafe { ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize },
139 0usize,
140 concat!(
141 "Offset of field: ",
142 stringify!(sxt_curve25519_scalar),
143 "::",
144 stringify!(bytes)
145 )
146 );
147}
148#[doc = " encodes a strobe-based transcript"]
149#[repr(C)]
150#[derive(Debug, Copy, Clone)]
151pub struct sxt_transcript {
152 pub bytes: [u8; 203usize],
153}
154#[test]
155fn bindgen_test_layout_sxt_transcript() {
156 const UNINIT: ::std::mem::MaybeUninit<sxt_transcript> = ::std::mem::MaybeUninit::uninit();
157 let ptr = UNINIT.as_ptr();
158 assert_eq!(
159 ::std::mem::size_of::<sxt_transcript>(),
160 203usize,
161 concat!("Size of: ", stringify!(sxt_transcript))
162 );
163 assert_eq!(
164 ::std::mem::align_of::<sxt_transcript>(),
165 1usize,
166 concat!("Alignment of ", stringify!(sxt_transcript))
167 );
168 assert_eq!(
169 unsafe { ::std::ptr::addr_of!((*ptr).bytes) as usize - ptr as usize },
170 0usize,
171 concat!(
172 "Offset of field: ",
173 stringify!(sxt_transcript),
174 "::",
175 stringify!(bytes)
176 )
177 );
178}
179#[doc = " encodes an element of the `curve25519` group"]
180#[repr(C)]
181#[derive(Debug, Copy, Clone)]
182pub struct sxt_ristretto255 {
183 pub X: [u64; 5usize],
184 pub Y: [u64; 5usize],
185 pub Z: [u64; 5usize],
186 pub T: [u64; 5usize],
187}
188#[test]
189fn bindgen_test_layout_sxt_ristretto255() {
190 const UNINIT: ::std::mem::MaybeUninit<sxt_ristretto255> = ::std::mem::MaybeUninit::uninit();
191 let ptr = UNINIT.as_ptr();
192 assert_eq!(
193 ::std::mem::size_of::<sxt_ristretto255>(),
194 160usize,
195 concat!("Size of: ", stringify!(sxt_ristretto255))
196 );
197 assert_eq!(
198 ::std::mem::align_of::<sxt_ristretto255>(),
199 8usize,
200 concat!("Alignment of ", stringify!(sxt_ristretto255))
201 );
202 assert_eq!(
203 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
204 0usize,
205 concat!(
206 "Offset of field: ",
207 stringify!(sxt_ristretto255),
208 "::",
209 stringify!(X)
210 )
211 );
212 assert_eq!(
213 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
214 40usize,
215 concat!(
216 "Offset of field: ",
217 stringify!(sxt_ristretto255),
218 "::",
219 stringify!(Y)
220 )
221 );
222 assert_eq!(
223 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
224 80usize,
225 concat!(
226 "Offset of field: ",
227 stringify!(sxt_ristretto255),
228 "::",
229 stringify!(Z)
230 )
231 );
232 assert_eq!(
233 unsafe { ::std::ptr::addr_of!((*ptr).T) as usize - ptr as usize },
234 120usize,
235 concat!(
236 "Offset of field: ",
237 stringify!(sxt_ristretto255),
238 "::",
239 stringify!(T)
240 )
241 );
242}
243#[doc = " encodes an affine element of the `bls12-381` `G1` group"]
244#[repr(C)]
245#[derive(Debug, Copy, Clone)]
246pub struct sxt_bls12_381_g1 {
247 pub X: [u64; 6usize],
248 pub Y: [u64; 6usize],
249}
250#[test]
251fn bindgen_test_layout_sxt_bls12_381_g1() {
252 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1> = ::std::mem::MaybeUninit::uninit();
253 let ptr = UNINIT.as_ptr();
254 assert_eq!(
255 ::std::mem::size_of::<sxt_bls12_381_g1>(),
256 96usize,
257 concat!("Size of: ", stringify!(sxt_bls12_381_g1))
258 );
259 assert_eq!(
260 ::std::mem::align_of::<sxt_bls12_381_g1>(),
261 8usize,
262 concat!("Alignment of ", stringify!(sxt_bls12_381_g1))
263 );
264 assert_eq!(
265 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
266 0usize,
267 concat!(
268 "Offset of field: ",
269 stringify!(sxt_bls12_381_g1),
270 "::",
271 stringify!(X)
272 )
273 );
274 assert_eq!(
275 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
276 48usize,
277 concat!(
278 "Offset of field: ",
279 stringify!(sxt_bls12_381_g1),
280 "::",
281 stringify!(Y)
282 )
283 );
284}
285#[doc = " encodes an affine element of the `bls12-381` `G1` group in projective form"]
286#[repr(C)]
287#[derive(Debug, Copy, Clone)]
288pub struct sxt_bls12_381_g1_p2 {
289 pub X: [u64; 6usize],
290 pub Y: [u64; 6usize],
291 pub Z: [u64; 6usize],
292}
293#[test]
294fn bindgen_test_layout_sxt_bls12_381_g1_p2() {
295 const UNINIT: ::std::mem::MaybeUninit<sxt_bls12_381_g1_p2> = ::std::mem::MaybeUninit::uninit();
296 let ptr = UNINIT.as_ptr();
297 assert_eq!(
298 ::std::mem::size_of::<sxt_bls12_381_g1_p2>(),
299 144usize,
300 concat!("Size of: ", stringify!(sxt_bls12_381_g1_p2))
301 );
302 assert_eq!(
303 ::std::mem::align_of::<sxt_bls12_381_g1_p2>(),
304 8usize,
305 concat!("Alignment of ", stringify!(sxt_bls12_381_g1_p2))
306 );
307 assert_eq!(
308 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
309 0usize,
310 concat!(
311 "Offset of field: ",
312 stringify!(sxt_bls12_381_g1_p2),
313 "::",
314 stringify!(X)
315 )
316 );
317 assert_eq!(
318 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
319 48usize,
320 concat!(
321 "Offset of field: ",
322 stringify!(sxt_bls12_381_g1_p2),
323 "::",
324 stringify!(Y)
325 )
326 );
327 assert_eq!(
328 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
329 96usize,
330 concat!(
331 "Offset of field: ",
332 stringify!(sxt_bls12_381_g1_p2),
333 "::",
334 stringify!(Z)
335 )
336 );
337}
338#[doc = " encodes an affine element of the `bn254` `G1` group"]
339#[repr(C)]
340#[derive(Debug, Copy, Clone)]
341pub struct sxt_bn254_g1 {
342 pub X: [u64; 4usize],
343 pub Y: [u64; 4usize],
344 pub infinity: u8,
345}
346#[test]
347fn bindgen_test_layout_sxt_bn254_g1() {
348 const UNINIT: ::std::mem::MaybeUninit<sxt_bn254_g1> = ::std::mem::MaybeUninit::uninit();
349 let ptr = UNINIT.as_ptr();
350 assert_eq!(
351 ::std::mem::size_of::<sxt_bn254_g1>(),
352 72usize,
353 concat!("Size of: ", stringify!(sxt_bn254_g1))
354 );
355 assert_eq!(
356 ::std::mem::align_of::<sxt_bn254_g1>(),
357 8usize,
358 concat!("Alignment of ", stringify!(sxt_bn254_g1))
359 );
360 assert_eq!(
361 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
362 0usize,
363 concat!(
364 "Offset of field: ",
365 stringify!(sxt_bn254_g1),
366 "::",
367 stringify!(X)
368 )
369 );
370 assert_eq!(
371 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
372 32usize,
373 concat!(
374 "Offset of field: ",
375 stringify!(sxt_bn254_g1),
376 "::",
377 stringify!(Y)
378 )
379 );
380 assert_eq!(
381 unsafe { ::std::ptr::addr_of!((*ptr).infinity) as usize - ptr as usize },
382 64usize,
383 concat!(
384 "Offset of field: ",
385 stringify!(sxt_bn254_g1),
386 "::",
387 stringify!(infinity)
388 )
389 );
390}
391#[doc = " encodes an affine element of the `bn254` `G1` group in projective form"]
392#[repr(C)]
393#[derive(Debug, Copy, Clone)]
394pub struct sxt_bn254_g1_p2 {
395 pub X: [u64; 4usize],
396 pub Y: [u64; 4usize],
397 pub Z: [u64; 4usize],
398}
399#[test]
400fn bindgen_test_layout_sxt_bn254_g1_p2() {
401 const UNINIT: ::std::mem::MaybeUninit<sxt_bn254_g1_p2> = ::std::mem::MaybeUninit::uninit();
402 let ptr = UNINIT.as_ptr();
403 assert_eq!(
404 ::std::mem::size_of::<sxt_bn254_g1_p2>(),
405 96usize,
406 concat!("Size of: ", stringify!(sxt_bn254_g1_p2))
407 );
408 assert_eq!(
409 ::std::mem::align_of::<sxt_bn254_g1_p2>(),
410 8usize,
411 concat!("Alignment of ", stringify!(sxt_bn254_g1_p2))
412 );
413 assert_eq!(
414 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
415 0usize,
416 concat!(
417 "Offset of field: ",
418 stringify!(sxt_bn254_g1_p2),
419 "::",
420 stringify!(X)
421 )
422 );
423 assert_eq!(
424 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
425 32usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(sxt_bn254_g1_p2),
429 "::",
430 stringify!(Y)
431 )
432 );
433 assert_eq!(
434 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
435 64usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(sxt_bn254_g1_p2),
439 "::",
440 stringify!(Z)
441 )
442 );
443}
444#[doc = " encodes an affine element of the `grumpkin` group"]
445#[repr(C)]
446#[derive(Debug, Copy, Clone)]
447pub struct sxt_grumpkin {
448 pub X: [u64; 4usize],
449 pub Y: [u64; 4usize],
450 pub infinity: u8,
451}
452#[test]
453fn bindgen_test_layout_sxt_grumpkin() {
454 const UNINIT: ::std::mem::MaybeUninit<sxt_grumpkin> = ::std::mem::MaybeUninit::uninit();
455 let ptr = UNINIT.as_ptr();
456 assert_eq!(
457 ::std::mem::size_of::<sxt_grumpkin>(),
458 72usize,
459 concat!("Size of: ", stringify!(sxt_grumpkin))
460 );
461 assert_eq!(
462 ::std::mem::align_of::<sxt_grumpkin>(),
463 8usize,
464 concat!("Alignment of ", stringify!(sxt_grumpkin))
465 );
466 assert_eq!(
467 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
468 0usize,
469 concat!(
470 "Offset of field: ",
471 stringify!(sxt_grumpkin),
472 "::",
473 stringify!(X)
474 )
475 );
476 assert_eq!(
477 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
478 32usize,
479 concat!(
480 "Offset of field: ",
481 stringify!(sxt_grumpkin),
482 "::",
483 stringify!(Y)
484 )
485 );
486 assert_eq!(
487 unsafe { ::std::ptr::addr_of!((*ptr).infinity) as usize - ptr as usize },
488 64usize,
489 concat!(
490 "Offset of field: ",
491 stringify!(sxt_grumpkin),
492 "::",
493 stringify!(infinity)
494 )
495 );
496}
497#[doc = " encodes an affine element of the `grumpkin` group in projective form"]
498#[repr(C)]
499#[derive(Debug, Copy, Clone)]
500pub struct sxt_grumpkin_p2 {
501 pub X: [u64; 4usize],
502 pub Y: [u64; 4usize],
503 pub Z: [u64; 4usize],
504}
505#[test]
506fn bindgen_test_layout_sxt_grumpkin_p2() {
507 const UNINIT: ::std::mem::MaybeUninit<sxt_grumpkin_p2> = ::std::mem::MaybeUninit::uninit();
508 let ptr = UNINIT.as_ptr();
509 assert_eq!(
510 ::std::mem::size_of::<sxt_grumpkin_p2>(),
511 96usize,
512 concat!("Size of: ", stringify!(sxt_grumpkin_p2))
513 );
514 assert_eq!(
515 ::std::mem::align_of::<sxt_grumpkin_p2>(),
516 8usize,
517 concat!("Alignment of ", stringify!(sxt_grumpkin_p2))
518 );
519 assert_eq!(
520 unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize },
521 0usize,
522 concat!(
523 "Offset of field: ",
524 stringify!(sxt_grumpkin_p2),
525 "::",
526 stringify!(X)
527 )
528 );
529 assert_eq!(
530 unsafe { ::std::ptr::addr_of!((*ptr).Y) as usize - ptr as usize },
531 32usize,
532 concat!(
533 "Offset of field: ",
534 stringify!(sxt_grumpkin_p2),
535 "::",
536 stringify!(Y)
537 )
538 );
539 assert_eq!(
540 unsafe { ::std::ptr::addr_of!((*ptr).Z) as usize - ptr as usize },
541 64usize,
542 concat!(
543 "Offset of field: ",
544 stringify!(sxt_grumpkin_p2),
545 "::",
546 stringify!(Z)
547 )
548 );
549}
550#[doc = " describes a sequence of values"]
551#[repr(C)]
552#[derive(Debug, Copy, Clone)]
553pub struct sxt_sequence_descriptor {
554 pub element_nbytes: u8,
555 pub n: u64,
556 pub data: *const u8,
557 pub is_signed: ::std::os::raw::c_int,
558}
559#[test]
560fn bindgen_test_layout_sxt_sequence_descriptor() {
561 const UNINIT: ::std::mem::MaybeUninit<sxt_sequence_descriptor> =
562 ::std::mem::MaybeUninit::uninit();
563 let ptr = UNINIT.as_ptr();
564 assert_eq!(
565 ::std::mem::size_of::<sxt_sequence_descriptor>(),
566 32usize,
567 concat!("Size of: ", stringify!(sxt_sequence_descriptor))
568 );
569 assert_eq!(
570 ::std::mem::align_of::<sxt_sequence_descriptor>(),
571 8usize,
572 concat!("Alignment of ", stringify!(sxt_sequence_descriptor))
573 );
574 assert_eq!(
575 unsafe { ::std::ptr::addr_of!((*ptr).element_nbytes) as usize - ptr as usize },
576 0usize,
577 concat!(
578 "Offset of field: ",
579 stringify!(sxt_sequence_descriptor),
580 "::",
581 stringify!(element_nbytes)
582 )
583 );
584 assert_eq!(
585 unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
586 8usize,
587 concat!(
588 "Offset of field: ",
589 stringify!(sxt_sequence_descriptor),
590 "::",
591 stringify!(n)
592 )
593 );
594 assert_eq!(
595 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
596 16usize,
597 concat!(
598 "Offset of field: ",
599 stringify!(sxt_sequence_descriptor),
600 "::",
601 stringify!(data)
602 )
603 );
604 assert_eq!(
605 unsafe { ::std::ptr::addr_of!((*ptr).is_signed) as usize - ptr as usize },
606 24usize,
607 concat!(
608 "Offset of field: ",
609 stringify!(sxt_sequence_descriptor),
610 "::",
611 stringify!(is_signed)
612 )
613 );
614}
615#[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."]
616#[repr(C)]
617#[derive(Debug, Copy, Clone)]
618pub struct sumcheck_descriptor {
619 pub mles: *const ::std::os::raw::c_void,
620 pub product_table: *const ::std::os::raw::c_void,
621 pub product_terms: *const ::std::os::raw::c_uint,
622 pub n: ::std::os::raw::c_uint,
623 pub num_mles: ::std::os::raw::c_uint,
624 pub num_products: ::std::os::raw::c_uint,
625 #[doc = " The total number of total product terms in the sumcheck polynomial"]
626 pub num_product_terms: ::std::os::raw::c_uint,
627 pub round_degree: ::std::os::raw::c_uint,
628}
629#[test]
630fn bindgen_test_layout_sumcheck_descriptor() {
631 const UNINIT: ::std::mem::MaybeUninit<sumcheck_descriptor> = ::std::mem::MaybeUninit::uninit();
632 let ptr = UNINIT.as_ptr();
633 assert_eq!(
634 ::std::mem::size_of::<sumcheck_descriptor>(),
635 48usize,
636 concat!("Size of: ", stringify!(sumcheck_descriptor))
637 );
638 assert_eq!(
639 ::std::mem::align_of::<sumcheck_descriptor>(),
640 8usize,
641 concat!("Alignment of ", stringify!(sumcheck_descriptor))
642 );
643 assert_eq!(
644 unsafe { ::std::ptr::addr_of!((*ptr).mles) as usize - ptr as usize },
645 0usize,
646 concat!(
647 "Offset of field: ",
648 stringify!(sumcheck_descriptor),
649 "::",
650 stringify!(mles)
651 )
652 );
653 assert_eq!(
654 unsafe { ::std::ptr::addr_of!((*ptr).product_table) as usize - ptr as usize },
655 8usize,
656 concat!(
657 "Offset of field: ",
658 stringify!(sumcheck_descriptor),
659 "::",
660 stringify!(product_table)
661 )
662 );
663 assert_eq!(
664 unsafe { ::std::ptr::addr_of!((*ptr).product_terms) as usize - ptr as usize },
665 16usize,
666 concat!(
667 "Offset of field: ",
668 stringify!(sumcheck_descriptor),
669 "::",
670 stringify!(product_terms)
671 )
672 );
673 assert_eq!(
674 unsafe { ::std::ptr::addr_of!((*ptr).n) as usize - ptr as usize },
675 24usize,
676 concat!(
677 "Offset of field: ",
678 stringify!(sumcheck_descriptor),
679 "::",
680 stringify!(n)
681 )
682 );
683 assert_eq!(
684 unsafe { ::std::ptr::addr_of!((*ptr).num_mles) as usize - ptr as usize },
685 28usize,
686 concat!(
687 "Offset of field: ",
688 stringify!(sumcheck_descriptor),
689 "::",
690 stringify!(num_mles)
691 )
692 );
693 assert_eq!(
694 unsafe { ::std::ptr::addr_of!((*ptr).num_products) as usize - ptr as usize },
695 32usize,
696 concat!(
697 "Offset of field: ",
698 stringify!(sumcheck_descriptor),
699 "::",
700 stringify!(num_products)
701 )
702 );
703 assert_eq!(
704 unsafe { ::std::ptr::addr_of!((*ptr).num_product_terms) as usize - ptr as usize },
705 36usize,
706 concat!(
707 "Offset of field: ",
708 stringify!(sumcheck_descriptor),
709 "::",
710 stringify!(num_product_terms)
711 )
712 );
713 assert_eq!(
714 unsafe { ::std::ptr::addr_of!((*ptr).round_degree) as usize - ptr as usize },
715 40usize,
716 concat!(
717 "Offset of field: ",
718 stringify!(sumcheck_descriptor),
719 "::",
720 stringify!(round_degree)
721 )
722 );
723}
724#[doc = " resources for multiexponentiations with pre-specified generators"]
725#[repr(C)]
726#[derive(Debug, Copy, Clone)]
727pub struct sxt_multiexp_handle {
728 _unused: [u8; 0],
729}
730extern "C" {
731 #[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"]
732 pub fn sxt_init(config: *const sxt_config) -> ::std::os::raw::c_int;
733}
734extern "C" {
735 #[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"]
736 pub fn sxt_curve25519_compute_pedersen_commitments(
737 commitments: *mut sxt_ristretto255_compressed,
738 num_sequences: u32,
739 descriptors: *const sxt_sequence_descriptor,
740 offset_generators: u64,
741 );
742}
743extern "C" {
744 #[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"]
745 pub fn sxt_curve25519_compute_pedersen_commitments_with_generators(
746 commitments: *mut sxt_ristretto255_compressed,
747 num_sequences: u32,
748 descriptors: *const sxt_sequence_descriptor,
749 generators: *const sxt_ristretto255,
750 );
751}
752extern "C" {
753 #[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"]
754 pub fn sxt_bls12_381_g1_compute_pedersen_commitments_with_generators(
755 commitments: *mut sxt_bls12_381_g1_compressed,
756 num_sequences: u32,
757 descriptors: *const sxt_sequence_descriptor,
758 generators: *const sxt_bls12_381_g1,
759 );
760}
761extern "C" {
762 #[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"]
763 pub fn sxt_bn254_g1_uncompressed_compute_pedersen_commitments_with_generators(
764 commitments: *mut sxt_bn254_g1,
765 num_sequences: u32,
766 descriptors: *const sxt_sequence_descriptor,
767 generators: *const sxt_bn254_g1,
768 );
769}
770extern "C" {
771 #[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"]
772 pub fn sxt_grumpkin_uncompressed_compute_pedersen_commitments_with_generators(
773 commitments: *mut sxt_grumpkin,
774 num_sequences: u32,
775 descriptors: *const sxt_sequence_descriptor,
776 generators: *const sxt_grumpkin,
777 );
778}
779extern "C" {
780 #[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"]
781 pub fn sxt_ristretto255_get_generators(
782 generators: *mut sxt_ristretto255,
783 offset_generators: u64,
784 num_generators: u64,
785 ) -> ::std::os::raw::c_int;
786}
787extern "C" {
788 #[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`"]
789 pub fn sxt_curve25519_get_one_commit(
790 one_commit: *mut sxt_ristretto255,
791 n: u64,
792 ) -> ::std::os::raw::c_int;
793}
794extern "C" {
795 #[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`"]
796 pub fn sxt_curve25519_prove_inner_product(
797 l_vector: *mut sxt_ristretto255_compressed,
798 r_vector: *mut sxt_ristretto255_compressed,
799 ap_value: *mut sxt_curve25519_scalar,
800 transcript: *mut sxt_transcript,
801 n: u64,
802 generators_offset: u64,
803 a_vector: *const sxt_curve25519_scalar,
804 b_vector: *const sxt_curve25519_scalar,
805 );
806}
807extern "C" {
808 #[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`"]
809 pub fn sxt_curve25519_verify_inner_product(
810 transcript: *mut sxt_transcript,
811 n: u64,
812 generators_offset: u64,
813 b_vector: *const sxt_curve25519_scalar,
814 product: *const sxt_curve25519_scalar,
815 a_commit: *const sxt_ristretto255,
816 l_vector: *const sxt_ristretto255_compressed,
817 r_vector: *const sxt_ristretto255_compressed,
818 ap_value: *const sxt_curve25519_scalar,
819 ) -> ::std::os::raw::c_int;
820}
821extern "C" {
822 #[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*"]
823 pub fn sxt_multiexp_handle_new(
824 curve_id: ::std::os::raw::c_uint,
825 generators: *const ::std::os::raw::c_void,
826 n: ::std::os::raw::c_uint,
827 ) -> *mut sxt_multiexp_handle;
828}
829extern "C" {
830 #[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."]
831 pub fn sxt_multiexp_handle_new_from_file(
832 curve_id: ::std::os::raw::c_uint,
833 filename: *const ::std::os::raw::c_char,
834 ) -> *mut sxt_multiexp_handle;
835}
836extern "C" {
837 #[doc = " Write a multiexponentiation handle to file.\n\n Use this function in combination with sxt_multiexp_handle_new_from_file."]
838 pub fn sxt_multiexp_handle_write_to_file(
839 handle: *const sxt_multiexp_handle,
840 filename: *const ::std::os::raw::c_char,
841 );
842}
843extern "C" {
844 #[doc = " Free resources for a multiexponentiation handle"]
845 pub fn sxt_multiexp_handle_free(handle: *mut sxt_multiexp_handle);
846}
847extern "C" {
848 #[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."]
849 pub fn sxt_fixed_multiexponentiation(
850 res: *mut ::std::os::raw::c_void,
851 handle: *const sxt_multiexp_handle,
852 element_num_bytes: ::std::os::raw::c_uint,
853 num_outputs: ::std::os::raw::c_uint,
854 n: ::std::os::raw::c_uint,
855 scalars: *const u8,
856 );
857}
858extern "C" {
859 #[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."]
860 pub fn sxt_fixed_packed_multiexponentiation(
861 res: *mut ::std::os::raw::c_void,
862 handle: *const sxt_multiexp_handle,
863 output_bit_table: *const ::std::os::raw::c_uint,
864 num_outputs: ::std::os::raw::c_uint,
865 n: ::std::os::raw::c_uint,
866 scalars: *const u8,
867 );
868}
869extern "C" {
870 #[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."]
871 pub fn sxt_fixed_vlen_multiexponentiation(
872 res: *mut ::std::os::raw::c_void,
873 handle: *const sxt_multiexp_handle,
874 output_bit_table: *const ::std::os::raw::c_uint,
875 output_lengths: *const ::std::os::raw::c_uint,
876 num_outputs: ::std::os::raw::c_uint,
877 scalars: *const u8,
878 );
879}
880extern "C" {
881 #[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"]
882 pub fn sxt_prove_sumcheck(
883 polynomials: *mut ::std::os::raw::c_void,
884 evaluation_point: *mut ::std::os::raw::c_void,
885 field_id: ::std::os::raw::c_uint,
886 descriptor: *const sumcheck_descriptor,
887 transcript_callback: *mut ::std::os::raw::c_void,
888 transcript_context: *mut ::std::os::raw::c_void,
889 );
890}