bindings: silent compiler using any in napi proof conversion

Author: querolita

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

@@ -38,9 +38,17 @@ import {
   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>>,
@@ -111,7 +119,7 @@ function proofConversionPerField(
     let zComm = core.polyCommToRust(commitments[2]);
     let tComm = core.polyCommToRust(commitments[3]);
     let lookup = MlOption.mapFrom(commitments[4], lookupCommitmentsToRust);
-    return new ProverCommitments(wComm, zComm, tComm, lookup);
+    return new ProverCommitments(wComm as any, zComm as any, tComm as any, lookup as any);
   }
   function commitmentsFromRust(commitments: NapiProverCommitments): ProverCommitments {
     let wComm = core.polyCommsFromRust(commitments.w_comm);
@@ -126,7 +134,7 @@ function proofConversionPerField(
     let sorted = core.polyCommsToRust(lookup[1]);
     let aggreg = core.polyCommToRust(lookup[2]);
     let runtime = MlOption.mapFrom(lookup[3], core.polyCommToRust);
-    return new LookupCommitments(sorted, aggreg, runtime);
+    return new LookupCommitments(sorted as any, aggreg as any, runtime as any);
   }
   function lookupCommitmentsFromRust(lookup: NapiLookupCommitments): LookupCommitments {
     let sorted = core.polyCommsFromRust(lookup.sorted);
@@ -146,15 +154,15 @@ function proofConversionPerField(
       r.push(ri);
     }
     return new OpeningProof(
-      core.pointsToRust(l),
-      core.pointsToRust(r),
+      core.pointsToRust(l) as any,
+      core.pointsToRust(r) as any,
       core.pointToRust(delta),
       fieldToRust(z1),
       fieldToRust(z2),
       core.pointToRust(sg)
     );
   }
-  function openingProofFromRust(proof: NapiOpeningProof): OpeningProof {
+  function openingProofFromRust(proof: any): OpeningProof {
     let [, ...l] = core.pointsFromRust(proof.lr_0);
     let [, ...r] = core.pointsFromRust(proof.lr_1);
     let n = l.length;
@@ -214,7 +222,7 @@ function proofConversionPerField(
         ftEval1,
         public_,
         prevChallengeScalars,
-        prevChallengeComms
+        prevChallengeComms as any
       );
     },
     proofFromRust(wasmProof: NapiProverProof): ProofWithPublic {
@@ -260,6 +268,85 @@ function proofConversionPerField(
   };
 }
 
+function createMapPointEvals<Field1, Field2>(map: (x: Field1) => Field2) {
+  return (evals: PointEvaluations<Field1>): PointEvaluations<Field2> => {
+    let [, zeta, zeta_omega] = evals;
+    return [0, MlArray.map(zeta, map), MlArray.map(zeta_omega, map)];
+  };
+}
+
+function mapPointEvalsOption<Field1, Field2>(map: (x: Field1) => Field2) {
+  return (evals: MlOption<PointEvaluations<Field1>>) =>
+    MlOption.map(evals, createMapPointEvals(map));
+}
+
+function mapProofEvaluations<Field1, Field2>(map: (x: Field1) => Field2) {
+  const mapPointEvals = createMapPointEvals(map);
+
+  const mapPointEvalsOption = (
+    evals: MlOption<PointEvaluations<Field1>>
+  ): MlOption<PointEvaluations<Field2>> => MlOption.map(evals, mapPointEvals);
+
+  return function mapProofEvaluations(evals: ProofEvaluations<Field1>): ProofEvaluations<Field2> {
+    let [
+      ,
+      w,
+      z,
+      s,
+      coeffs,
+      genericSelector,
+      poseidonSelector,
+      completeAddSelector,
+      mulSelector,
+      emulSelector,
+      endomulScalarSelector,
+      rangeCheck0Selector,
+      rangeCheck1Selector,
+      foreignFieldAddSelector,
+      foreignFieldMulSelector,
+      xorSelector,
+      rotSelector,
+      lookupAggregation,
+      lookupTable,
+      lookupSorted,
+      runtimeLookupTable,
+      runtimeLookupTableSelector,
+      xorLookupSelector,
+      lookupGateLookupSelector,
+      rangeCheckLookupSelector,
+      foreignFieldMulLookupSelector,
+    ] = evals;
+    return [
+      0,
+      MlTuple.map(w, mapPointEvals),
+      mapPointEvals(z),
+      MlTuple.map(s, mapPointEvals),
+      MlTuple.map(coeffs, mapPointEvals),
+      mapPointEvals(genericSelector),
+      mapPointEvals(poseidonSelector),
+      mapPointEvals(completeAddSelector),
+      mapPointEvals(mulSelector),
+      mapPointEvals(emulSelector),
+      mapPointEvals(endomulScalarSelector),
+      mapPointEvalsOption(rangeCheck0Selector),
+      mapPointEvalsOption(rangeCheck1Selector),
+      mapPointEvalsOption(foreignFieldAddSelector),
+      mapPointEvalsOption(foreignFieldMulSelector),
+      mapPointEvalsOption(xorSelector),
+      mapPointEvalsOption(rotSelector),
+      mapPointEvalsOption(lookupAggregation),
+      mapPointEvalsOption(lookupTable),
+      MlArray.map(lookupSorted, mapPointEvalsOption),
+      mapPointEvalsOption(runtimeLookupTable),
+      mapPointEvalsOption(runtimeLookupTableSelector),
+      mapPointEvalsOption(xorLookupSelector),
+      mapPointEvalsOption(lookupGateLookupSelector),
+      mapPointEvalsOption(rangeCheckLookupSelector),
+      mapPointEvalsOption(foreignFieldMulLookupSelector),
+    ];
+  };
+}
+
 // helper
 
 type RemoveLeadingZero<T extends [0, ...any]> = T extends [0, ...infer U] ? U : never;