Merge pull request #2658 from o1-labs/querolita/napi-vindex

(`o1js`) Native Prover with Napi - Verifier Index

Author: querolita

src/bindings/crypto/bindings.ts

@@ -3,6 +3,7 @@
  * It is exposed to JSOO by populating a global variable with an object.
  * It gets imported as the first thing in ../../bindings.js so that the global variable is ready by the time JSOO code gets executed.
  */
+import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs';
 import type * as wasmNamespace from '../compiled/node_bindings/plonk_wasm.cjs';
 import { prefixHashes, prefixHashesLegacy } from '../crypto/constants.js';
 import { Bigint256Bindings } from './bindings/bigint256.js';
@@ -14,15 +15,15 @@ import { verifierIndexConversion } from './bindings/conversion-verifier-index.js
 import { PallasBindings, VestaBindings } from './bindings/curve.js';
 import { jsEnvironment } from './bindings/env.js';
 import { FpBindings, FqBindings } from './bindings/field.js';
-import { napiOraclesConversion } from './bindings/napi-conversion-oracles.js';
+import { FpVectorBindings, FqVectorBindings } from './bindings/vector.js';
 import { srs } from './bindings/srs.js';
 import { srs as napiSrs } from './napi-srs.js';
-import { FpVectorBindings, FqVectorBindings } from './bindings/vector.js';
 import { napiConversionCore } from './napi-conversion-core.js';
 import { napiProofConversion } from './napi-conversion-proof.js';
-import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs';
+import { napiVerifierIndexConversion } from './napi-conversion-verifier-index.js';
+import { napiOraclesConversion } from './bindings/napi-conversion-oracles.js';
 
-export { RustConversion, Wasm, Napi, createNativeRustConversion, getRustConversion };
+export { Napi, RustConversion, Wasm, createNativeRustConversion, getRustConversion };
 
 /* TODO: Uncomment in phase 2 of conversion layer 
 import { conversionCore as conversionCoreNative } from './native/conversion-core.js';
@@ -90,10 +91,11 @@ function buildWasmConversion(wasm: Wasm) {
 function createNativeRustConversion(napi: any) {
   let core = napiConversionCore(napi);
   let proof = napiProofConversion(napi, core);
+  let verif = napiVerifierIndexConversion(napi, core);
   let oracles = napiOraclesConversion(napi);
   return {
-    fp: { ...core.fp, ...proof.fp, ...oracles.fp },
-    fq: { ...core.fq, ...proof.fq, ...oracles.fq },
+    fp: { ...core.fp, ...proof.fp, ...verif.fp, ...oracles.fp },
+    fq: { ...core.fq, ...proof.fq, ...verif.fq, ...oracles.fq },
   };
 }
 

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

@@ -1,24 +1,24 @@
-import { Field } from './field.js';
-import { bigintToBytes32, bytesToBigint32 } from '../bigint-helpers.js';
+import type { MlArray } from '../../../lib/ml/base.js';
 import type {
   WasmGPallas,
   WasmGVesta,
   WasmPallasGProjective,
   WasmVestaGProjective,
 } from '../../compiled/node_bindings/plonk_wasm.cjs';
-import type { MlArray } from '../../../lib/ml/base.js';
-import { OrInfinity, Infinity } from './curve.js';
+import { bigintToBytes32, bytesToBigint32 } from '../bigint-helpers.js';
+import { Infinity, OrInfinity } from './curve.js';
+import { Field } from './field.js';
 
 export {
-  fieldToRust,
+  WasmAffine,
+  WasmProjective,
+  affineFromRust,
+  affineToRust,
   fieldFromRust,
-  fieldsToRustFlat,
+  fieldToRust,
   fieldsFromRustFlat,
+  fieldsToRustFlat,
   maybeFieldToRust,
-  affineToRust,
-  affineFromRust,
-  WasmAffine,
-  WasmProjective,
 };
 
 // TODO: Hardcoding this is a little brittle

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

@@ -116,9 +116,9 @@ function conversionCorePerField(
       return new PolyComm(rustUnshifted, rustShifted);
     },
     polyCommFromRust(polyComm: WasmPolyComm): PolyComm {
-      console.log('polyComm', polyComm);
+      console.log('polyComm old', polyComm);
       let rustUnshifted = polyComm.unshifted;
-      console.log('polyCommFromRust', rustUnshifted);
+      console.log('rustUnshifted', rustUnshifted);
       let mlUnshifted = mapFromUintArray(rustUnshifted, (ptr) => {
         return affineFromRust(wrap(ptr, CommitmentCurve));
       });

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

@@ -1,46 +1,46 @@
+import { MlArray, MlOption, MlTuple } from '../../../lib/ml/base.js';
+import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
 import type {
   WasmFpLookupCommitments,
-  WasmPastaFpLookupTable,
   WasmFpOpeningProof,
   WasmFpProverCommitments,
   WasmFpProverProof,
   WasmFpRuntimeTable,
-  WasmPastaFpRuntimeTableCfg,
   WasmFqLookupCommitments,
   WasmFqOpeningProof,
   WasmFqProverCommitments,
-  WasmPastaFqLookupTable,
   WasmFqProverProof,
   WasmFqRuntimeTable,
+  WasmPastaFpLookupTable,
+  WasmPastaFpRuntimeTableCfg,
+  WasmPastaFqLookupTable,
   WasmPastaFqRuntimeTableCfg,
   WasmVecVecFp,
   WasmVecVecFq,
 } from '../../compiled/node_bindings/plonk_wasm.cjs';
-import type * as wasmNamespace from '../../compiled/node_bindings/plonk_wasm.cjs';
+import {
+  fieldFromRust,
+  fieldToRust,
+  fieldsFromRustFlat,
+  fieldsToRustFlat,
+} from './conversion-base.js';
+import { ConversionCore, ConversionCores, mapToUint32Array, unwrap } from './conversion-core.js';
 import type {
+  Field,
+  LookupCommitments,
+  LookupTable,
+  OpeningProof,
   OrInfinity,
   PointEvaluations,
   PolyComm,
-  ProverProof,
-  ProofWithPublic,
   ProofEvaluations,
+  ProofWithPublic,
   ProverCommitments,
-  OpeningProof,
+  ProverProof,
   RecursionChallenge,
-  LookupCommitments,
   RuntimeTable,
   RuntimeTableCfg,
-  LookupTable,
-  Field,
 } from './kimchi-types.js';
-import { MlArray, MlOption, MlTuple } from '../../../lib/ml/base.js';
-import {
-  fieldToRust,
-  fieldFromRust,
-  fieldsToRustFlat,
-  fieldsFromRustFlat,
-} from './conversion-base.js';
-import { ConversionCore, ConversionCores, mapToUint32Array, unwrap } from './conversion-core.js';
 
 export { proofConversion };
 
@@ -178,6 +178,7 @@ function proofConversionPerField(
   }
 
   function runtimeTableToRust([, id, data]: RuntimeTable): WasmRuntimeTable {
+    console.log('old runtime table to rust!');
     return new RuntimeTable(id, core.vectorToRust(data));
   }
 

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

@@ -117,8 +117,6 @@ 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,7 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
   let maybeLagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
     try {
       console.log(3);
-      console.log('srs', srs);
+      console.log('srs wasm', srs);
       let bytes = (wasm as any)[`caml_${f}_srs_to_bytes_external`](srs);
       console.log('bytes', bytes);
       let wasmSrs = undefined;

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

@@ -6,7 +6,6 @@ import {
   fieldsFromRustFlat,
   fieldsToRustFlat,
 } from './bindings/conversion-base.js';
-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';
 
@@ -70,13 +69,11 @@ function napiConversionCore(napi: any) {
   };
 
   return {
-    fp: { ...fpCore },
+    fp: {
+      ...fpCore,
+    },
     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,
   };
@@ -156,9 +153,9 @@ function conversionCorePerField({ makeAffine, PolyComm }: NapiClasses) {
   };
   const affineFromRust = (pt: NapiAffine): OrInfinity => {
     if (pt.infinity) return 0;
-    console.log('pt', pt);
-    console.log('pt.x', pt.x);
-    console.log('pt.y', pt.y);
+    // console.log('pt', pt);
+    // console.log('pt.x', pt.x);
+    // console.log('pt.y', pt.y);
 
     const xField = fieldFromRust(pt.x);
     const yField = fieldFromRust(pt.y);
@@ -182,22 +179,13 @@ function conversionCorePerField({ makeAffine, PolyComm }: NapiClasses) {
     return new PolyCommClass(unshifted as unknown, undefined);
   };
 
-  /*   const polyCommFromRust = (polyComm: NapiPolyComm): PolyComm => {
-    console.log('polyComm', polyComm);
+  const polyCommFromRust = (polyComm: any): any => {
+    if (polyComm == null) return undefined;
+    // console.log('polyComm', polyComm);
     const rustUnshifted = asArrayLike<NapiAffine>(polyComm.unshifted, 'polyComm.unshifted');
-    console.log('rustUnshifted', rustUnshifted);
+    // console.log('rustUnshifted', rustUnshifted);
     const mlUnshifted = rustUnshifted.map(affineFromRust);
     return [0, [0, ...mlUnshifted]];
-  }; */
-  const polyCommFromRust = (polyComm: any): any => {
-    let rustUnshifted = polyComm.unshifted;
-    console.log('rustUnshifted', rustUnshifted);
-    let mlUnshifted = mapFromUintArray(rustUnshifted, (ptr) => {
-      console.log('ptr', ptr);
-      /*       return affineFromRust(wrap(ptr, CommitmentCurve));
-       */
-    });
-    return [0, [0, ...mlUnshifted]];
   };
 
   const polyCommsToRust = ([, ...comms]: MlArray<PolyComm>): NapiPolyComm[] =>

src/bindings/crypto/napi-conversion-proof.ts

@@ -1,54 +1,55 @@
+import { MlArray, MlOption, MlTuple } from '../../lib/ml/base.js';
+import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs';
 import type {
-  WasmPastaFpLookupTable,
+  WasmFpLookupCommitments,
+  WasmFpOpeningProof,
+  WasmFpProverCommitments,
+  WasmFpProverProof,
   WasmFpRuntimeTable,
+  WasmFqLookupCommitments,
+  WasmFqOpeningProof,
+  WasmFqProverCommitments,
+  WasmFqProverProof,
+  WasmFqRuntimeTable,
+  WasmPastaFpLookupTable,
   WasmPastaFpRuntimeTableCfg,
   WasmPastaFqLookupTable,
-  WasmFqRuntimeTable,
   WasmPastaFqRuntimeTableCfg,
   WasmVecVecFp,
   WasmVecVecFq,
-  WasmFpProverCommitments, 
-  WasmFqProverCommitments,
-  WasmFpOpeningProof,
-  WasmFqOpeningProof,
-  WasmFpProverProof,
-  WasmFqProverProof,
-  WasmFpLookupCommitments,
-  WasmFqLookupCommitments,
 } from '../compiled/node_bindings/plonk_wasm.cjs';
-import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs';
+import {
+  fieldFromRust,
+  fieldToRust,
+  fieldsFromRustFlat,
+  fieldsToRustFlat,
+} from './bindings/conversion-base.js';
+import type { Field } from './bindings/field.js';
 import type {
-  RuntimeTable,
-  RuntimeTableCfg,
+  LookupCommitments,
   LookupTable,
+  OpeningProof,
+  OrInfinity,
+  PointEvaluations,
+  PolyComm,
+  ProofEvaluations,
   ProofWithPublic,
+  ProverCommitments,
   ProverProof,
-  LookupCommitments,
-  PolyComm, PointEvaluations, ProofEvaluations,
   RecursionChallenge,
-  ProverCommitments,
-  OpeningProof,
-  OrInfinity,
+  RuntimeTable,
+  RuntimeTableCfg,
 } from './bindings/kimchi-types.js';
-import { MlArray, MlTuple, MlOption} from '../../lib/ml/base.js';
-import {
-  fieldsToRustFlat,
-  fieldToRust,
-  fieldsFromRustFlat,
-  fieldFromRust,
-} from './bindings/conversion-base.js';
 import { ConversionCore, ConversionCores } from './napi-conversion-core.js';
-import type { Field } from './bindings/field.js';
 
 export { napiProofConversion };
-  
+
 const fieldToRust_ = (x: Field) => fieldToRust(x);
 const proofEvaluationsToRust = mapProofEvaluations(fieldToRust_);
 const proofEvaluationsFromRust = mapProofEvaluations(fieldFromRust);
 const pointEvalsOptionToRust = mapPointEvalsOption(fieldToRust_);
 const pointEvalsOptionFromRust = mapPointEvalsOption(fieldFromRust);
 
-  
 type NapiProofEvaluations = [
   0,
   MlOption<PointEvaluations<Uint8Array>>,
@@ -129,7 +130,7 @@ function proofConversionPerField(
     commitments.free();
     return [0, wComm as MlTuple<PolyComm, 15>, zComm, tComm, lookup];
   }
-  
+
   function lookupCommitmentsToRust(lookup: LookupCommitments): NapiLookupCommitments {
     let sorted = core.polyCommsToRust(lookup[1]);
     let aggreg = core.polyCommToRust(lookup[2]);
@@ -143,7 +144,7 @@ function proofConversionPerField(
     lookup.free();
     return [0, sorted, aggreg, runtime];
   }
-  
+
   function openingProofToRust(proof: OpeningProof): NapiOpeningProof {
     let [_, [, ...lr], delta, z1, z2, sg] = proof;
     // We pass l and r as separate vectors over the FFI
@@ -175,8 +176,9 @@ function proofConversionPerField(
     proof.free();
     return [0, [0, ...lr], delta, z1, z2, sg];
   }
-  
+
   function runtimeTableToRust([, id, data]: RuntimeTable): NapiRuntimeTable {
+    console.log('runtime table');
     return new RuntimeTable(id, core.vectorToRust(data));
   }
 
@@ -192,8 +194,6 @@ function proofConversionPerField(
     }
     return new LookupTable(id, wasmData);
   }
-  
-  
 
   return {
     proofToRust([, public_evals, proof]: ProofWithPublic): NapiProverProof {
@@ -252,7 +252,7 @@ function proofConversionPerField(
       ];
       return [0, publicEvals, proof];
     },
-    
+
     runtimeTablesToRust([, ...tables]: MlArray<RuntimeTable>): NapiRuntimeTable[] {
       return tables.map(runtimeTableToRust);
     },