[WIP] (mina) Native Prover with Napi - Proof

src/lib/crypto/kimchi_bindings/js/bindings/oracles.js

@@ -1,69 +1,5 @@
 /* global plonk_wasm, tsRustConversion,*/
 
-// Provides: fp_oracles_create
-// Requires: plonk_wasm, tsRustConversion
-var fp_oracles_create = function (lgr_comm, verifier_index, proof) {
-  return tsRustConversion.fp.oraclesFromRust(
-    plonk_wasm.fp_oracles_create(
-      tsRustConversion.fp.polyCommsToRust(lgr_comm),
-      tsRustConversion.fp.verifierIndexToRust(verifier_index),
-      tsRustConversion.fp.proofToRust(proof)
-    )
-  );
-};
-
-// Provides: fp_oracles_create_no_public
-// Requires: fp_oracles_create
-var fp_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {
-  return fp_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);
-};
-
-// Provides: fp_oracles_dummy
-// Requires: plonk_wasm, tsRustConversion
-var fp_oracles_dummy = function () {
-  return tsRustConversion.fp.oraclesFromRust(plonk_wasm.fp_oracles_dummy());
-};
-
-// Provides: fp_oracles_deep_copy
-// Requires: plonk_wasm, tsRustConversion
-var fp_oracles_deep_copy = function (x) {
-  return tsRustConversion.fp.oraclesFromRust(
-    plonk_wasm.fp_oracles_deep_copy(tsRustConversion.fp.oraclesToRust(x))
-  );
-};
-
-// Provides: fq_oracles_create
-// Requires: plonk_wasm, tsRustConversion
-var fq_oracles_create = function (lgr_comm, verifier_index, proof) {
-  return tsRustConversion.fq.oraclesFromRust(
-    plonk_wasm.fq_oracles_create(
-      tsRustConversion.fq.polyCommsToRust(lgr_comm),
-      tsRustConversion.fq.verifierIndexToRust(verifier_index),
-      tsRustConversion.fq.proofToRust(proof)
-    )
-  );
-};
-
-// Provides: fq_oracles_create_no_public
-// Requires: fq_oracles_create
-var fq_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {
-  return fq_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);
-};
-
-// Provides: fq_oracles_dummy
-// Requires: plonk_wasm, tsRustConversion
-var fq_oracles_dummy = function () {
-  return tsRustConversion.fq.oraclesFromRust(plonk_wasm.fq_oracles_dummy());
-};
-
-// Provides: fq_oracles_deep_copy
-// Requires: plonk_wasm, tsRustConversion
-var fq_oracles_deep_copy = function (x) {
-  return tsRustConversion.fq.oraclesFromRust(
-    plonk_wasm.fq_oracles_deep_copy(tsRustConversion.fq.oraclesToRust(x))
-  );
-};
-
 // This is fake -- parameters are only needed on the Rust side, so no need to return something meaningful
 // Provides: caml_pasta_fp_poseidon_params_create
 function caml_pasta_fp_poseidon_params_create() {

src/lib/crypto/kimchi_bindings/js/bindings/proof.js

@@ -1,139 +0,0 @@
-/* global plonk_wasm, tsRustConversion
- */
-
-// Provides: caml_pasta_fp_plonk_proof_create
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fp_plonk_proof_create = function (
-  index,
-  witness_cols,
-  caml_runtime_tables,
-  prev_challenges,
-  prev_sgs
-) {
-  var w = new plonk_wasm.WasmVecVecFp(witness_cols.length - 1);
-  for (var i = 1; i < witness_cols.length; i++) {
-    w.push(tsRustConversion.fp.vectorToRust(witness_cols[i]));
-  }
-  witness_cols = w;
-  prev_challenges = tsRustConversion.fp.vectorToRust(prev_challenges);
-  var wasm_runtime_tables =
-    tsRustConversion.fp.runtimeTablesToRust(caml_runtime_tables);
-  prev_sgs = tsRustConversion.fp.pointsToRust(prev_sgs);
-  var proof = plonk_wasm.caml_pasta_fp_plonk_proof_create(
-    index,
-    witness_cols,
-    wasm_runtime_tables,
-    prev_challenges,
-    prev_sgs
-  );
-  return tsRustConversion.fp.proofFromRust(proof);
-};
-
-// Provides: caml_pasta_fp_plonk_proof_verify
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fp_plonk_proof_verify = function (index, proof) {
-  index = tsRustConversion.fp.verifierIndexToRust(index);
-  proof = tsRustConversion.fp.proofToRust(proof);
-  return plonk_wasm.caml_pasta_fp_plonk_proof_verify(index, proof);
-};
-
-// Provides: caml_pasta_fp_plonk_proof_batch_verify
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fp_plonk_proof_batch_verify = function (indexes, proofs) {
-  indexes = tsRustConversion.mapMlArrayToRustVector(
-    indexes,
-    tsRustConversion.fp.verifierIndexToRust
-  );
-  proofs = tsRustConversion.mapMlArrayToRustVector(
-    proofs,
-    tsRustConversion.fp.proofToRust
-  );
-  return plonk_wasm.caml_pasta_fp_plonk_proof_batch_verify(indexes, proofs);
-};
-
-// Provides: caml_pasta_fp_plonk_proof_dummy
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fp_plonk_proof_dummy = function () {
-  return tsRustConversion.fp.proofFromRust(
-    plonk_wasm.caml_pasta_fp_plonk_proof_dummy()
-  );
-};
-
-// Provides: caml_pasta_fp_plonk_proof_deep_copy
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fp_plonk_proof_deep_copy = function (proof) {
-  return tsRustConversion.fp.proofFromRust(
-    plonk_wasm.caml_pasta_fp_plonk_proof_deep_copy(
-      tsRustConversion.fp.proofToRust(proof)
-    )
-  );
-};
-
-// Provides: caml_pasta_fq_plonk_proof_create
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fq_plonk_proof_create = function (
-  index,
-  witness_cols,
-  caml_runtime_tables,
-  prev_challenges,
-  prev_sgs
-) {
-  var w = new plonk_wasm.WasmVecVecFq(witness_cols.length - 1);
-  for (var i = 1; i < witness_cols.length; i++) {
-    w.push(tsRustConversion.fq.vectorToRust(witness_cols[i]));
-  }
-  witness_cols = w;
-  prev_challenges = tsRustConversion.fq.vectorToRust(prev_challenges);
-  var wasm_runtime_tables =
-    tsRustConversion.fq.runtimeTablesToRust(caml_runtime_tables);
-  prev_sgs = tsRustConversion.fq.pointsToRust(prev_sgs);
-  var proof = plonk_wasm.caml_pasta_fq_plonk_proof_create(
-    index,
-    witness_cols,
-    wasm_runtime_tables,
-    prev_challenges,
-    prev_sgs
-  );
-  return tsRustConversion.fq.proofFromRust(proof);
-};
-
-// Provides: caml_pasta_fq_plonk_proof_verify
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fq_plonk_proof_verify = function (index, proof) {
-  index = tsRustConversion.fq.verifierIndexToRust(index);
-  proof = tsRustConversion.fq.proofToRust(proof);
-  return plonk_wasm.caml_pasta_fq_plonk_proof_verify(index, proof);
-};
-
-// Provides: caml_pasta_fq_plonk_proof_batch_verify
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fq_plonk_proof_batch_verify = function (indexes, proofs) {
-  indexes = tsRustConversion.mapMlArrayToRustVector(
-    indexes,
-    tsRustConversion.fq.verifierIndexToRust
-  );
-  proofs = tsRustConversion.mapMlArrayToRustVector(
-    proofs,
-    tsRustConversion.fq.proofToRust
-  );
-  return plonk_wasm.caml_pasta_fq_plonk_proof_batch_verify(indexes, proofs);
-};
-
-// Provides: caml_pasta_fq_plonk_proof_dummy
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fq_plonk_proof_dummy = function () {
-  return tsRustConversion.fq.proofFromRust(
-    plonk_wasm.caml_pasta_fq_plonk_proof_dummy()
-  );
-};
-
-// Provides: caml_pasta_fq_plonk_proof_deep_copy
-// Requires: plonk_wasm, tsRustConversion
-var caml_pasta_fq_plonk_proof_deep_copy = function (proof) {
-  return tsRustConversion.fq.proofFromRust(
-    plonk_wasm.caml_pasta_fq_plonk_proof_deep_copy(
-      tsRustConversion.fq.proofToRust(proof)
-    )
-  );
-};
-

src/lib/crypto/kimchi_bindings/js/bindings/verifier-index.js

@@ -24,8 +24,13 @@ var caml_opt_to_rust = function (caml_optional_value, to_rust) {
 // Provides: caml_pasta_fp_plonk_verifier_index_create
 // Requires: plonk_wasm, tsRustConversion
 var caml_pasta_fp_plonk_verifier_index_create = function (x) {
-  console.log("caml_pasta_fp_plonk_verifier_index_create")
-  var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(x);
+  console.log("caml_pasta_fp_plonk_verifier_index_create", x)
+  var bytes = plonk_wasm.prover_index_fp_to_bytes(x);
+  console.log("bytes", bytes)
+  var index = plonk_wasm.WasmPastaFpPlonkIndex.deserialize(bytes)
+  console.log("index", index)
+  var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(index);
+  console.log("vk", vk)
   return tsRustConversion.fp.verifierIndexFromRust(vk);
 };
 

src/lib/crypto/kimchi_bindings/js/dune

@@ -21,7 +21,8 @@
    native/native-overrides/prover-index.js
    native/native-overrides/srs.js
    native/native-overrides/util.js
-   native/native-overrides/proof.js))
+   native/native-overrides/proof.js
+   native/native-overrides/verifier-index.js))
  (instrumentation
   (backend bisect_ppx))
  (preprocess

src/lib/crypto/kimchi_bindings/js/native/header-d.ts

@@ -4,14 +4,20 @@
 // This file gets auto-included in the generated plonk-napi types to supplement
 // external pointer types.
 
+type WasmGVesta = {};
+type WasmGPallas = {};
+type WasmPastaFp = {};
+type WasmPastaFq = {};
+type WasmLookupInfo = {};
 type WasmPastaFpPlonkIndex = {};
-type NapiVector<T> = {};
-type NapiGVesta = {};
-type NapiGPallas = {};
-type NapiPastaFpPlonkIndex = {};
-type NapiPastaFqPlonkIndex = {};
-type NapiLookupInfo = {};
-type NapiPastaFp = {};
-type NapiPastaFq = {};
+type WasmPastaFqPlonkIndex = {};
+type Proof = {}
+type WasmVector<T> = {};
+type WasmFlatVector<T> = {};
+type WasmVecVecFp = {};
+type WasmVecVecFq = {};
+type WasmFpSrs = {};
+type WasmFqSrs = {};
+type Self = {};
 
 // Header section end

src/lib/crypto/kimchi_bindings/js/native/native-overrides/oracles.js

@@ -1,5 +1,68 @@
 /* global plonk_wasm, tsRustConversionNative,*/
 
+// Provides: fp_oracles_create
+// Requires: plonk_wasm, tsRustConversionNative
+var fp_oracles_create = function (lgr_comm, verifier_index, proof) {
+  return tsRustConversionNative.fp.oraclesFromRust(
+    plonk_wasm.fp_oracles_create(
+      tsRustConversionNative.fp.polyCommsToRust(lgr_comm),
+      tsRustConversionNative.fp.verifierIndexToRust(verifier_index),
+      tsRustConversionNative.fp.proofToRust(proof)
+    )
+  );
+};
+
+// Provides: fp_oracles_create_no_public
+// Requires: fp_oracles_create
+var fp_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {
+  return fp_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);
+};
+
+// Provides: fp_oracles_dummy
+// Requires: plonk_wasm, tsRustConversionNative
+var fp_oracles_dummy = function () {
+  return tsRustConversionNative.fp.oraclesFromRust(plonk_wasm.fp_oracles_dummy());
+};
+
+// Provides: fp_oracles_deep_copy
+// Requires: plonk_wasm, tsRustConversionNative
+var fp_oracles_deep_copy = function (x) {
+  return tsRustConversionNative.fp.oraclesFromRust(
+    plonk_wasm.fp_oracles_deep_copy(tsRustConversionNative.fp.oraclesToRust(x))
+  );
+};
+
+// Provides: fq_oracles_create
+// Requires: plonk_wasm, tsRustConversionNative
+var fq_oracles_create = function (lgr_comm, verifier_index, proof) {
+  return tsRustConversionNative.fq.oraclesFromRust(
+    plonk_wasm.fq_oracles_create(
+      tsRustConversionNative.fq.polyCommsToRust(lgr_comm),
+      tsRustConversionNative.fq.verifierIndexToRust(verifier_index),
+      tsRustConversionNative.fq.proofToRust(proof)
+    )
+  );
+};
+
+// Provides: fq_oracles_create_no_public
+// Requires: fq_oracles_create
+var fq_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {
+  return fq_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);
+};
+
+// Provides: fq_oracles_dummy
+// Requires: plonk_wasm, tsRustConversionNative
+var fq_oracles_dummy = function () {
+  return tsRustConversionNative.fq.oraclesFromRust(plonk_wasm.fq_oracles_dummy());
+};
+
+// Provides: fq_oracles_deep_copy
+// Requires: plonk_wasm, tsRustConversionNative
+var fq_oracles_deep_copy = function (x) {
+  return tsRustConversionNative.fq.oraclesFromRust(
+    plonk_wasm.fq_oracles_deep_copy(tsRustConversionNative.fq.oraclesToRust(x))
+  );
+};
 
 // Provides: caml_pasta_fq_poseidon_block_cipher
 // Requires: plonk_wasm, tsRustConversionNative