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

querolita · querolita · commit 64b3727fa333 · 2025-11-15T00:06:23.000+01:00
diff --git a/src/bindings/crypto/bindings.ts b/src/bindings/crypto/bindings.ts
@@ -49,6 +49,7 @@ const tsBindings = {
     return bundle.srsFactory(wasm, bundle.conversion);
   },*/
   srs: (wasm: Wasm) => srs(wasm, getRustConversion(wasm)),
+  srsNative: (napi: Wasm) => srs(napi, createNativeRustConversion(napi) as any),
 };
 
 // this is put in a global variable so that mina/src/lib/crypto/kimchi_bindings/js/bindings.js finds it
diff --git a/src/bindings/crypto/bindings/srs.ts b/src/bindings/crypto/bindings/srs.ts
@@ -71,20 +71,91 @@ function srs(wasm: Wasm, conversion: RustConversion) {
 
 function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   // note: these functions are properly typed, thanks to TS template literal types
-  let createSrs = (s: number) => wasm[`caml_${f}_srs_create_parallel`](s);
-  let getSrs = wasm[`caml_${f}_srs_get`];
-  let setSrs = wasm[`caml_${f}_srs_set`];
+  let createSrs = (size: number) => {
+    try {
+      console.log(0);
+      return wasm[`caml_${f}_srs_create_parallel`](size);
+    } catch (error) {
+      console.error(`Error in SRS get for field ${f}`);
+      throw error;
+    }
+  };
+  let getSrs = (srs: WasmSrs) => {
+    try {
+      console.log(1);
+      let v = wasm[`caml_${f}_srs_get`](srs);
+      console.log(2);
+      return v;
+    } catch (error) {
+      console.error(`Error in SRS get for field ${f}`);
+      throw error;
+    }
+  };
+  let setSrs = (bytes: any) => {
+    try {
+      console.log(2);
+      return wasm[`caml_${f}_srs_set`](bytes);
+    } catch (error) {
+      console.error(`Error in SRS set for field ${f} args ${bytes}`);
+      throw error;
+    }
+  };
+
+  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);
+    } catch (error) {
+      console.error(`Error in SRS maybe lagrange commitment for field ${f}`);
+      throw error;
+    }
+  };
+  let lagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
+    try {
+      console.log(4);
+      return wasm[`caml_${f}_srs_lagrange_commitment`](srs, domain_size, i);
+    } catch (error) {
+      console.error(`Error in SRS lagrange commitment for field ${f}`);
+      throw error;
+    }
+  };
+  let lagrangeCommitmentsWholeDomainPtr = (srs: WasmSrs, domain_size: number) => {
+    try {
+      console.log(5);
+      return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](srs, domain_size);
+    } catch (error) {
+      console.error(`Error in SRS lagrange commitments whole domain ptr for field ${f}`);
+      throw error;
+    }
+  };
+  let setLagrangeBasis = (srs: WasmSrs, domain_size: number, input: any) => {
+    try {
+      console.log(6);
+      return wasm[`caml_${f}_srs_set_lagrange_basis`](srs, domain_size, input);
+    } catch (error) {
+      console.error(`Error in SRS set lagrange basis for field ${f}`);
+      throw error;
+    }
+  };
+  let getLagrangeBasis = (srs: WasmSrs, n: number) => {
+    try {
+      console.log(7);
+      return wasm[`caml_${f}_srs_get_lagrange_basis`](srs, n);
+    } catch (error) {
+      console.error(`Error in SRS get lagrange basis for field ${f}`);
+      throw error;
+    }
+  };
+  let getCommitmentsWholeDomainByPtr = (ptr: number) => {
+    try {
+      console.log(8);
+      return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_read_from_ptr`](ptr);
+    } catch (error) {
+      console.error(`Error in SRS get commitments whole domain by ptr for field ${f}`);
+      throw error;
+    }
+  };
 
-  let maybeLagrangeCommitment = wasm[`caml_${f}_srs_maybe_lagrange_commitment`];
-  let lagrangeCommitment = (srs: WasmFpSrs, domain_size: number, i: number) =>
-    wasm[`caml_${f}_srs_lagrange_commitment`](srs, domain_size, i);
-  let lagrangeCommitmentsWholeDomainPtr = (srs: WasmSrs, domain_size: number) =>
-    wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](srs, domain_size);
-  let setLagrangeBasis = wasm[`caml_${f}_srs_set_lagrange_basis`];
-  let getLagrangeBasis = (srs: WasmSrs, n: number) =>
-    wasm[`caml_${f}_srs_get_lagrange_basis`](srs, n);
-  let getCommitmentsWholeDomainByPtr =
-    wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_read_from_ptr`];
   return {
     /**
      * returns existing stored SRS or falls back to creating a new one
@@ -95,11 +166,14 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
       if (srs === undefined) {
         if (cache === undefined) {
           // if there is no cache, create SRS in memory
+          console.log('Creating SRS without cache');
           srs = createSrs(size);
+          console.log('SRS created without cache:', srs);
         } else {
           let header = cacheHeaderSrs(f, size);
 
           // try to read SRS from cache / recompute and write if not found
+          console.log('Reading SRS from cache');
           srs = readCache(cache, header, (bytes) => {
             // TODO: this takes a bit too long, about 300ms for 2^16
             // `pointsToRust` is the clear bottleneck
@@ -108,13 +182,17 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
             let wasmSrs = conversion[f].pointsToRust(mlSrs);
             return setSrs(wasmSrs);
           });
-
+          console.log('SRS read from cache:', srs);
           if (srs === undefined) {
             // not in cache
+            console.log(1);
             srs = createSrs(size);
+            console.log('Writing SRS to cache', srs);
 
             if (cache.canWrite) {
+              console.log(2);
               let wasmSrs = getSrs(srs);
+              console.log(3);
               let mlSrs = conversion[f].pointsFromRust(wasmSrs);
               let jsonSrs = MlArray.mapFrom(mlSrs, OrInfinity.toJSON);
               let bytes = new TextEncoder().encode(JSON.stringify(jsonSrs));
@@ -123,18 +201,21 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
             }
           }
         }
-
+        console.log('Storing SRS in memory');
         srsStore[f][size] = srs;
+        console.log('SRS stored in memory:', srs);
       }
 
       // TODO should we call freeOnFinalize() and expose a function to clean the SRS cache?
+      console.trace('Returning SRS:', srs);
       return srsStore[f][size];
     },
 
     /**
      * returns ith Lagrange basis commitment for a given domain size
      */
     lagrangeCommitment(srs: WasmSrs, domainSize: number, i: number): PolyComm {
+      console.log('lagrangeCommitment');
       // happy, fast case: if basis is already stored on the srs, return the ith commitment
       let commitment = maybeLagrangeCommitment(srs, domainSize, i);
 
@@ -208,6 +289,8 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
      * Returns the Lagrange basis commitments for the whole domain
      */
     lagrangeCommitmentsWholeDomain(srs: WasmSrs, domainSize: number) {
+      console.log('lagrangeCommitmentsWholeDomain');
+
       // instead of getting the entire commitment directly (which works for nodejs/servers), we get a pointer to the commitment
       // and then read the commitment from the pointer
       // this is because the web worker implementation currently does not support returning UintXArray's directly
@@ -224,6 +307,7 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
      * adds Lagrange basis for a given domain size
      */
     addLagrangeBasis(srs: WasmSrs, logSize: number) {
+      console.log('addLagrangeBasis');
       // this ensures that basis is stored on the srs, no need to duplicate caching logic
       this.lagrangeCommitment(srs, 1 << logSize, 0);
     },
@@ -270,3 +354,13 @@ function readCacheLazy(
     return true;
   });
 }
+function runInTryCatch<T extends (...args: any[]) => any>(fn: T): T {
+  return function (...args: Parameters<T>): ReturnType<T> {
+    try {
+      return fn(...args);
+    } catch (e) {
+      console.error(`Error in SRS function ${fn.name} with args:`, args);
+      throw e;
+    }
+  } as T;
+}
diff --git a/src/bindings/crypto/napi-conversion-core.ts b/src/bindings/crypto/napi-conversion-core.ts
@@ -10,11 +10,11 @@ import { mapFromUintArray } from './bindings/conversion-core.js';
 import { Field, Gate, LookupTable, OrInfinity, PolyComm, Wire } from './bindings/kimchi-types.js';
 import { mapTuple } from './bindings/util.js';
 
-export { napiConversionCore, ConversionCore, ConversionCores };
+export { ConversionCore, ConversionCores, napiConversionCore };
 
 type ConversionCore = ReturnType<typeof conversionCorePerField>;
 type ConversionCores = ReturnType<typeof napiConversionCore>;
-  
+
 type NapiAffine = napiNamespace.WasmGVesta | napiNamespace.WasmGPallas;
 type NapiPolyComm = { unshifted: unknown; shifted?: NapiAffine | undefined };
 type PolyCommCtor = new (unshifted: unknown, shifted?: NapiAffine | undefined) => NapiPolyComm;
@@ -71,7 +71,13 @@ function napiConversionCore(napi: any) {
 
   return {
     fp: { ...fpCore },
-    fq: { ...fqCore },
+    fq: {
+      ...fqCore,
+      shiftsFromRust: (s: any) => {
+        let shifts = [s.s0, s.s1, s.s2, s.s3, s.s4, s.s5, s.s6];
+        return [0, ...shifts.map(fieldFromRust)];
+      },
+    },
     ...shared,
   };
 }
@@ -126,7 +132,8 @@ function conversionCorePerField({ makeAffine, PolyComm }: NapiClasses) {
       wireFromRust(w5),
       wireFromRust(w6),
     ];
-    const coeffBytes = gate.coeffs instanceof Uint8Array ? gate.coeffs : Uint8Array.from(gate.coeffs);
+    const coeffBytes =
+      gate.coeffs instanceof Uint8Array ? gate.coeffs : Uint8Array.from(gate.coeffs);
     const coeffs = fieldsFromRustFlat(coeffBytes);
     return [0, gate.typ, wiresTuple, coeffs];
   };
diff --git a/src/mina b/src/mina
@@ -1 +1 @@
-Subproject commit ef9d64fbce56e86c6a8b000813324cee3d646fbc
+Subproject commit 9d34fc49b8b12a202bb2d61fbf7e39970f9aef3f
