Merge branch 'native/napi' into querolita/napi-proof

Author: querolita

src/bindings/crypto/bindings/conversion-core.ts

@@ -1,3 +1,5 @@
+import { MlArray } from '../../../lib/ml/base.js';
+import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
 import type {
   WasmFpGate,
   WasmFpPolyComm,
@@ -6,27 +8,25 @@ import type {
   WasmGPallas,
   WasmGVesta,
 } from '../../compiled/node_bindings/plonk_wasm.cjs';
-import { OrInfinity, Gate, PolyComm, Wire } from './kimchi-types.js';
-import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
-import { MlArray } from '../../../lib/ml/base.js';
-import { mapTuple } from './util.js';
 import {
   WasmAffine,
   affineFromRust,
   affineToRust,
   fieldsFromRustFlat,
   fieldsToRustFlat,
 } from './conversion-base.js';
+import { Gate, OrInfinity, PolyComm, Wire } from './kimchi-types.js';
+import { mapTuple } from './util.js';
 
 export {
   ConversionCore,
   ConversionCores,
   conversionCore,
   freeOnFinalize,
-  wrap,
-  unwrap,
   mapFromUintArray,
   mapToUint32Array,
+  unwrap,
+  wrap,
 };
 
 // basic conversion functions for each field
@@ -116,7 +116,9 @@ function conversionCorePerField(
       return new PolyComm(rustUnshifted, rustShifted);
     },
     polyCommFromRust(polyComm: WasmPolyComm): PolyComm {
+      console.log('polyComm', polyComm);
       let rustUnshifted = polyComm.unshifted;
+      console.log('polyCommFromRust', rustUnshifted);
       let mlUnshifted = mapFromUintArray(rustUnshifted, (ptr) => {
         return affineFromRust(wrap(ptr, CommitmentCurve));
       });
@@ -174,6 +176,7 @@ function freeOnFinalize<T extends Freeable>(instance: T) {
 }
 
 function mapFromUintArray<T>(array: Uint32Array | Uint8Array, map: (i: number) => T) {
+  console.log('array', array);
   let n = array.length;
   let result: T[] = Array(n);
   for (let i = 0; i < n; i++) {

src/bindings/crypto/bindings/conversion-verifier-index.ts

@@ -1,3 +1,5 @@
+import { MlArray, MlBool, MlOption } from '../../../lib/ml/base.js';
+import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
 import type {
   WasmFpDomain,
   WasmFpLookupSelectors,
@@ -13,11 +15,9 @@ import type {
   WasmFqShifts,
   LookupInfo as WasmLookupInfo,
 } from '../../compiled/node_bindings/plonk_wasm.cjs';
-import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
-import { MlBool, MlArray, MlOption } from '../../../lib/ml/base.js';
-import { Field, VerifierIndex, Domain, VerificationEvals, PolyComm } from './kimchi-types.js';
 import { fieldFromRust, fieldToRust } from './conversion-base.js';
 import { ConversionCore, ConversionCores, freeOnFinalize } from './conversion-core.js';
+import { Domain, Field, PolyComm, VerificationEvals, VerifierIndex } from './kimchi-types.js';
 import { Lookup, LookupInfo, LookupSelectors } from './lookup.js';
 
 export { verifierIndexConversion };
@@ -117,6 +117,8 @@ function verifierIndexConversionPerField(
     );
   }
   function verificationEvalsFromRust(evals: WasmVerificationEvals): VerificationEvals {
+    console.log('evals', evals.coefficients_comm);
+
     let mlEvals: VerificationEvals = [
       0,
       core.polyCommsFromRust(evals.sigma_comm),

src/bindings/crypto/bindings/srs.ts

@@ -104,7 +104,15 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   let maybeLagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
     try {
       console.log(3);
-      return wasm[`caml_${f}_srs_maybe_lagrange_commitment`](srs, domain_size, i);
+      console.log('srs', srs);
+      let bytes = (wasm as any)[`caml_${f}_srs_to_bytes_external`](srs);
+      console.log('bytes', bytes);
+      let wasmSrs = undefined;
+      if (f === 'fp') wasmSrs = wasm.WasmFpSrs.deserialize(bytes);
+      else wasmSrs = wasm.WasmFqSrs.deserialize(bytes);
+      let s = wasm[`caml_${f}_srs_maybe_lagrange_commitment`](wasmSrs, domain_size, i);
+      console.log('S', s);
+      return s;
     } catch (error) {
       console.error(`Error in SRS maybe lagrange commitment for field ${f}`);
       throw error;
@@ -113,7 +121,13 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   let lagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
     try {
       console.log(4);
-      return wasm[`caml_${f}_srs_lagrange_commitment`](srs, domain_size, i);
+      console.log('srs', srs);
+      let bytes = (wasm as any)[`caml_${f}_srs_to_bytes_external`](srs);
+      console.log('bytes', bytes);
+      let wasmSrs = undefined;
+      if (f === 'fp') wasmSrs = wasm.WasmFpSrs.deserialize(bytes);
+      else wasmSrs = wasm.WasmFqSrs.deserialize(bytes);
+      return wasm[`caml_${f}_srs_lagrange_commitment`](wasmSrs, domain_size, i);
     } catch (error) {
       console.error(`Error in SRS lagrange commitment for field ${f}`);
       throw error;
@@ -122,7 +136,13 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   let lagrangeCommitmentsWholeDomainPtr = (srs: WasmSrs, domain_size: number) => {
     try {
       console.log(5);
-      return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](srs, domain_size);
+      console.log('srs', srs);
+      let bytes = (wasm as any)[`caml_${f}_srs_to_bytes_external`](srs);
+      console.log('bytes', bytes);
+      let wasmSrs = undefined;
+      if (f === 'fp') wasmSrs = wasm.WasmFpSrs.deserialize(bytes);
+      else wasmSrs = wasm.WasmFqSrs.deserialize(bytes);
+      return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](wasmSrs, domain_size);
     } catch (error) {
       console.error(`Error in SRS lagrange commitments whole domain ptr for field ${f}`);
       throw error;
@@ -140,7 +160,13 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   let getLagrangeBasis = (srs: WasmSrs, n: number) => {
     try {
       console.log(7);
-      return wasm[`caml_${f}_srs_get_lagrange_basis`](srs, n);
+      console.log('srs', srs);
+      let bytes = (wasm as any)[`caml_${f}_srs_to_bytes_external`](srs);
+      console.log('bytes', bytes);
+      let wasmSrs = undefined;
+      if (f === 'fp') wasmSrs = wasm.WasmFpSrs.deserialize(bytes);
+      else wasmSrs = wasm.WasmFqSrs.deserialize(bytes);
+      return wasm[`caml_${f}_srs_get_lagrange_basis`](wasmSrs, n);
     } catch (error) {
       console.error(`Error in SRS get lagrange basis for field ${f}`);
       throw error;
@@ -241,7 +267,9 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
               // TODO: this code path will throw on the web since `caml_${f}_srs_get_lagrange_basis` is not properly implemented
               // using a writable cache in the browser seems to be fairly uncommon though, so it's at least an 80/20 solution
               let wasmComms = getLagrangeBasis(srs, domainSize);
+              console.log('wasmComms', wasmComms);
               let mlComms = conversion[f].polyCommsFromRust(wasmComms);
+              console.log('mlComms', mlComms);
               let comms = polyCommsToJSON(mlComms);
               let bytes = new TextEncoder().encode(JSON.stringify(comms));
               writeCache(cache, header, bytes);