From c5a5da4be17d320abe840ec8e96928fcd6687063 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 26 Nov 2025 17:09:30 +0100 Subject: [PATCH 1/7] bindings: first version of verifier index conversion --- src/bindings/crypto/bindings.ts | 6 +- src/bindings/crypto/napi-conversion-core.ts | 12 +- src/bindings/crypto/napi-conversion-proof.ts | 2 - .../crypto/napi-conversion-verifier-index.ts | 284 ++++++++++++++++++ 4 files changed, 293 insertions(+), 11 deletions(-) create mode 100644 src/bindings/crypto/napi-conversion-verifier-index.ts diff --git a/src/bindings/crypto/bindings.ts b/src/bindings/crypto/bindings.ts index f3d4817c2..645abf9b3 100644 --- a/src/bindings/crypto/bindings.ts +++ b/src/bindings/crypto/bindings.ts @@ -20,6 +20,7 @@ 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 { napiVerifierIndexConversion } from './napi-conversion-verifier-index.js'; import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs'; export { RustConversion, Wasm, Napi, createNativeRustConversion, getRustConversion }; @@ -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 }, }; } diff --git a/src/bindings/crypto/napi-conversion-core.ts b/src/bindings/crypto/napi-conversion-core.ts index 7409d1693..5c1a403ce 100644 --- a/src/bindings/crypto/napi-conversion-core.ts +++ b/src/bindings/crypto/napi-conversion-core.ts @@ -70,15 +70,13 @@ 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, + }, + ...shared, }; } diff --git a/src/bindings/crypto/napi-conversion-proof.ts b/src/bindings/crypto/napi-conversion-proof.ts index 690b41678..5df1610ca 100644 --- a/src/bindings/crypto/napi-conversion-proof.ts +++ b/src/bindings/crypto/napi-conversion-proof.ts @@ -192,8 +192,6 @@ function proofConversionPerField( } return new LookupTable(id, wasmData); } - - return { proofToRust([, public_evals, proof]: ProofWithPublic): NapiProverProof { diff --git a/src/bindings/crypto/napi-conversion-verifier-index.ts b/src/bindings/crypto/napi-conversion-verifier-index.ts new file mode 100644 index 000000000..23705bb80 --- /dev/null +++ b/src/bindings/crypto/napi-conversion-verifier-index.ts @@ -0,0 +1,284 @@ +import { MlArray, MlBool, MlOption } from '../../lib/ml/base.js'; +import type * as wasmNamespace from '../compiled/node_bindings/plonk_wasm.cjs'; +import type { + WasmFpDomain, + WasmFpLookupSelectors, + WasmFpLookupVerifierIndex, + WasmFpPlonkVerificationEvals, + WasmFpPlonkVerifierIndex, + WasmFpShifts, + WasmFqDomain, + WasmFqLookupSelectors, + WasmFqLookupVerifierIndex, + WasmFqPlonkVerificationEvals, + WasmFqPlonkVerifierIndex, + WasmFqShifts, + LookupInfo as WasmLookupInfo, +} from '../compiled/node_bindings/plonk_wasm.cjs'; +import { fieldFromRust, fieldToRust } from './bindings/conversion-base.js'; +import { ConversionCore, ConversionCores } from './napi-conversion-core.js'; +import { Domain, Field, PolyComm, VerificationEvals, VerifierIndex } from './bindings/kimchi-types.js'; +import { Lookup, LookupInfo, LookupSelectors } from './bindings/lookup.js'; + +export { napiVerifierIndexConversion }; + +type wasm = typeof wasmNamespace; + +type WasmDomain = WasmFpDomain | WasmFqDomain; +type WasmVerificationEvals = WasmFpPlonkVerificationEvals | WasmFqPlonkVerificationEvals; +type WasmShifts = WasmFpShifts | WasmFqShifts; +type WasmVerifierIndex = WasmFpPlonkVerifierIndex | WasmFqPlonkVerifierIndex; + +type WasmLookupVerifierIndex = WasmFpLookupVerifierIndex | WasmFqLookupVerifierIndex; +type WasmLookupSelector = WasmFpLookupSelectors | WasmFqLookupSelectors; + +type WasmClasses = { + Domain: typeof WasmFpDomain | typeof WasmFqDomain; + VerificationEvals: typeof WasmFpPlonkVerificationEvals | typeof WasmFqPlonkVerificationEvals; + Shifts: typeof WasmFpShifts | typeof WasmFqShifts; + VerifierIndex: typeof WasmFpPlonkVerifierIndex | typeof WasmFqPlonkVerifierIndex; + LookupVerifierIndex: typeof WasmFpLookupVerifierIndex | typeof WasmFqLookupVerifierIndex; + LookupSelector: typeof WasmFpLookupSelectors | typeof WasmFqLookupSelectors; +}; + +function napiVerifierIndexConversion(napi: any, core: ConversionCores) { + return { + fp: verifierIndexConversionPerField(napi, core.fp, { + Domain: napi.WasmFpDomain, + VerificationEvals: napi.WasmFpPlonkVerificationEvals, + Shifts: napi.WasmFpShifts, + VerifierIndex: napi.WasmFpPlonkVerifierIndex, + LookupVerifierIndex: napi.WasmFpLookupVerifierIndex, + LookupSelector: napi.WasmFpLookupSelectors, + }), + fq: verifierIndexConversionPerField(napi, core.fq, { + Domain: napi.WasmFqDomain, + VerificationEvals: napi.WasmFqPlonkVerificationEvals, + Shifts: napi.WasmFqShifts, + VerifierIndex: napi.WasmFqPlonkVerifierIndex, + LookupVerifierIndex: napi.WasmFqLookupVerifierIndex, + LookupSelector: napi.WasmFqLookupSelectors, + }), + }; +} + +function verifierIndexConversionPerField( + wasm: wasm, + core: ConversionCore, + { + Domain, + VerificationEvals, + Shifts, + VerifierIndex, + LookupVerifierIndex, + LookupSelector, + }: WasmClasses +) { + function domainToRust([, logSizeOfGroup, groupGen]: Domain): WasmDomain { + return new Domain(logSizeOfGroup, fieldToRust(groupGen)); + } + function domainFromRust(domain: WasmDomain): Domain { + let logSizeOfGroup = domain.log_size_of_group; + let groupGen = fieldFromRust(domain.group_gen); + return [0, logSizeOfGroup, groupGen]; + } + + function verificationEvalsToRust(evals: VerificationEvals): WasmVerificationEvals { + let sigmaComm = core.polyCommsToRust(evals[1]); + let coefficientsComm = core.polyCommsToRust(evals[2]); + let genericComm = core.polyCommToRust(evals[3]); + let psmComm = core.polyCommToRust(evals[4]); + let completeAddComm = core.polyCommToRust(evals[5]); + let mulComm = core.polyCommToRust(evals[6]); + let emulComm = core.polyCommToRust(evals[7]); + let endomulScalarComm = core.polyCommToRust(evals[8]); + let xorComm = MlOption.mapFrom(evals[9], core.polyCommToRust); + let rangeCheck0Comm = MlOption.mapFrom(evals[10], core.polyCommToRust); + let rangeCheck1Comm = MlOption.mapFrom(evals[11], core.polyCommToRust); + let foreignFieldAddComm = MlOption.mapFrom(evals[12], core.polyCommToRust); + let foreignFieldMulComm = MlOption.mapFrom(evals[13], core.polyCommToRust); + let rotComm = MlOption.mapFrom(evals[14], core.polyCommToRust); + return new VerificationEvals( + sigmaComm as any, + coefficientsComm as any, + genericComm as any, + psmComm as any, + completeAddComm as any, + mulComm as any, + emulComm as any, + endomulScalarComm as any, + xorComm as any, + rangeCheck0Comm as any, + rangeCheck1Comm as any, + foreignFieldAddComm as any, + foreignFieldMulComm as any, + rotComm as any + ); + } + function verificationEvalsFromRust(evals: WasmVerificationEvals): VerificationEvals { + console.log('evals', evals.coefficients_comm); + + let mlEvals: VerificationEvals = [ + 0, + core.polyCommsFromRust(evals.sigma_comm), + core.polyCommsFromRust(evals.coefficients_comm), + core.polyCommFromRust(evals.generic_comm), + core.polyCommFromRust(evals.psm_comm), + core.polyCommFromRust(evals.complete_add_comm), + core.polyCommFromRust(evals.mul_comm), + core.polyCommFromRust(evals.emul_comm), + core.polyCommFromRust(evals.endomul_scalar_comm), + MlOption.mapTo(evals.xor_comm, core.polyCommFromRust), + MlOption.mapTo(evals.range_check0_comm, core.polyCommFromRust), + MlOption.mapTo(evals.range_check1_comm, core.polyCommFromRust), + MlOption.mapTo(evals.foreign_field_add_comm, core.polyCommFromRust), + MlOption.mapTo(evals.foreign_field_mul_comm, core.polyCommFromRust), + MlOption.mapTo(evals.rot_comm, core.polyCommFromRust), + ]; + return mlEvals; + } + + function lookupVerifierIndexToRust(lookup: Lookup): WasmLookupVerifierIndex { + let [ + , + joint_lookup_used, + lookup_table, + selectors, + table_ids, + lookup_info, + runtime_tables_selector, + ] = lookup; + return new LookupVerifierIndex( + MlBool.from(joint_lookup_used), + core.polyCommsToRust(lookup_table) as any, + lookupSelectorsToRust(selectors), + MlOption.mapFrom(table_ids, core.polyCommToRust) as any, + lookupInfoToRust(lookup_info), + MlOption.mapFrom(runtime_tables_selector, core.polyCommToRust) as any + ); + } + function lookupVerifierIndexFromRust(lookup: WasmLookupVerifierIndex): Lookup { + let mlLookup: Lookup = [ + 0, + MlBool(lookup.joint_lookup_used), + core.polyCommsFromRust(lookup.lookup_table), + lookupSelectorsFromRust(lookup.lookup_selectors), + MlOption.mapTo(lookup.table_ids, core.polyCommFromRust), + lookupInfoFromRust(lookup.lookup_info), + MlOption.mapTo(lookup.runtime_tables_selector, core.polyCommFromRust), + ]; + return mlLookup; + } + + function lookupSelectorsToRust([ + , + lookup, + xor, + range_check, + ffmul, + ]: LookupSelectors): WasmLookupSelector { + return new LookupSelector( + MlOption.mapFrom(xor, core.polyCommToRust) as any, + MlOption.mapFrom(lookup, core.polyCommToRust) as any, + MlOption.mapFrom(range_check, core.polyCommToRust) as any, + MlOption.mapFrom(ffmul, core.polyCommToRust) as any + ); + } + function lookupSelectorsFromRust(selector: WasmLookupSelector): LookupSelectors { + let lookup = MlOption.mapTo(selector.lookup, core.polyCommFromRust); + let xor = MlOption.mapTo(selector.xor, core.polyCommFromRust); + let range_check = MlOption.mapTo(selector.range_check, core.polyCommFromRust); + let ffmul = MlOption.mapTo(selector.ffmul, core.polyCommFromRust); + return [0, lookup, xor, range_check, ffmul]; + } + + function lookupInfoToRust([, maxPerRow, maxJointSize, features]: LookupInfo): WasmLookupInfo { + let [, patterns, joint_lookup_used, uses_runtime_tables] = features; + let [, xor, lookup, range_check, foreign_field_mul] = patterns; + let wasmPatterns = new wasm.LookupPatterns( + MlBool.from(xor), + MlBool.from(lookup), + MlBool.from(range_check), + MlBool.from(foreign_field_mul) + ); + let wasmFeatures = new wasm.LookupFeatures( + wasmPatterns, + MlBool.from(joint_lookup_used), + MlBool.from(uses_runtime_tables) + ); + return new wasm.LookupInfo(maxPerRow, maxJointSize, wasmFeatures); + } + function lookupInfoFromRust(info: WasmLookupInfo): LookupInfo { + let features = info.features; + let patterns = features.patterns; + let mlInfo: LookupInfo = [ + 0, + info.max_per_row, + info.max_joint_size, + [ + 0, + [ + 0, + MlBool(patterns.xor), + MlBool(patterns.lookup), + MlBool(patterns.range_check), + MlBool(patterns.foreign_field_mul), + ], + MlBool(features.joint_lookup_used), + MlBool(features.uses_runtime_tables), + ], + ]; + return mlInfo; + } + + let self = { + shiftsToRust([, ...shifts]: MlArray): WasmShifts { + let s = shifts.map((s) => fieldToRust(s)); + return new Shifts(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); + }, + shiftsFromRust(s: WasmShifts): MlArray { + let shifts = [s.s0, s.s1, s.s2, s.s3, s.s4, s.s5, s.s6]; + return [0, ...shifts.map(fieldFromRust)]; + }, + + verifierIndexToRust(vk: VerifierIndex): WasmVerifierIndex { + let domain = domainToRust(vk[1]); + let maxPolySize = vk[2]; + let nPublic = vk[3]; + let prevChallenges = vk[4]; + let srs = vk[5]; + let evals = verificationEvalsToRust(vk[6]); + let shifts = self.shiftsToRust(vk[7]); + let lookupIndex = MlOption.mapFrom(vk[8], lookupVerifierIndexToRust); + let zkRows = vk[9]; + return new VerifierIndex( + domain, + maxPolySize, + nPublic, + prevChallenges, + srs, + evals, + shifts, + lookupIndex, + zkRows + ); + }, + verifierIndexFromRust(vk: WasmVerifierIndex): VerifierIndex { + let mlVk: VerifierIndex = [ + 0, + domainFromRust(vk.domain), + vk.max_poly_size, + vk.public_, + vk.prev_challenges, + vk.srs, + verificationEvalsFromRust(vk.evals), + self.shiftsFromRust(vk.shifts), + MlOption.mapTo(vk.lookup_index, lookupVerifierIndexFromRust), + vk.zk_rows, + ]; + return mlVk; + }, + }; + + return self; +} From e25896e195be4fe9b72a817f6f5d2b83da91122e Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 26 Nov 2025 17:12:59 +0100 Subject: [PATCH 2/7] submodule: update mina --- src/mina | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mina b/src/mina index 3116ffcdb..8437493a8 160000 --- a/src/mina +++ b/src/mina @@ -1 +1 @@ -Subproject commit 3116ffcdb35038a04624112305d9ab618990c7d2 +Subproject commit 8437493a87dcc0db0065a19b8d74d34c567b4c53 From 550855a547184e227fe78898461766731ae95169 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 3 Dec 2025 20:09:41 +0100 Subject: [PATCH 3/7] bindings: use native conversion for prover keys --- src/bindings/crypto/bindings.ts | 2 +- src/lib/proof-system/prover-keys.ts | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/bindings/crypto/bindings.ts b/src/bindings/crypto/bindings.ts index 645abf9b3..8e1b7923d 100644 --- a/src/bindings/crypto/bindings.ts +++ b/src/bindings/crypto/bindings.ts @@ -14,12 +14,12 @@ 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 { 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 { napiOraclesConversion } from './bindings/napi-conversion-oracles.js'; import { napiVerifierIndexConversion } from './napi-conversion-verifier-index.js'; import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs'; diff --git a/src/lib/proof-system/prover-keys.ts b/src/lib/proof-system/prover-keys.ts index e9fd8de7d..69055df1c 100644 --- a/src/lib/proof-system/prover-keys.ts +++ b/src/lib/proof-system/prover-keys.ts @@ -10,7 +10,8 @@ import { WasmPastaFpPlonkIndex, WasmPastaFqPlonkIndex, } from '../../bindings/compiled/node_bindings/plonk_wasm.cjs'; -import { getRustConversion } from '../../bindings/crypto/bindings.js'; +// TODO: include conversion bundle to decide between wasm and napi conversion +import { createNativeRustConversion, getRustConversion } from '../../bindings/crypto/bindings.js'; import { VerifierIndex } from '../../bindings/crypto/bindings/kimchi-types.js'; import { MlString } from '../ml/base.js'; import { CacheHeader, cacheHeaderVersion } from './cache.js'; @@ -95,13 +96,13 @@ function encodeProverKey(value: SnarkKey): Uint8Array { case KeyType.StepProvingKey: { let index = value[1][1]; let encoded = wasm.caml_pasta_fp_plonk_index_encode( - (wasm as any).prover_index_fp_from_bytes(index.serialize()) + (wasm as any).prover_index_fp_deserialize((wasm as any).prover_index_fp_serialize(index)) ); return encoded; } case KeyType.StepVerificationKey: { let vkMl = value[1]; - const rustConversion = getRustConversion(wasm); + const rustConversion = createNativeRustConversion(wasm); let vkWasm = rustConversion.fp.verifierIndexToRust(vkMl); let string = wasm.caml_pasta_fp_plonk_verifier_index_serialize(vkWasm); return new TextEncoder().encode(string); @@ -109,7 +110,7 @@ function encodeProverKey(value: SnarkKey): Uint8Array { case KeyType.WrapProvingKey: { let index = value[1][1]; let encoded = wasm.caml_pasta_fq_plonk_index_encode( - (wasm as any).prover_index_fq_from_bytes(index.serialize()) + (wasm as any).prover_index_fq_deserialize((wasm as any).prover_index_fq_serialize(index)) ); return encoded; } @@ -139,7 +140,7 @@ function decodeProverKey(header: SnarkKeyHeader, bytes: Uint8Array): SnarkKey { let srs = Pickles.loadSrsFp(); let string = new TextDecoder().decode(bytes); let vkWasm = wasm.caml_pasta_fp_plonk_verifier_index_deserialize(srs, string); - const rustConversion = getRustConversion(wasm); + const rustConversion = createNativeRustConversion(wasm); let vkMl = rustConversion.fp.verifierIndexFromRust(vkWasm); return [KeyType.StepVerificationKey, vkMl]; } From 199e872affe06f11da37847baad69b9ee82e9a80 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 3 Dec 2025 20:11:49 +0100 Subject: [PATCH 4/7] bindings: logs for srs functions for debugging --- src/bindings/crypto/bindings/srs.ts | 2 +- src/bindings/crypto/napi-srs.ts | 17 +++++++++++++++-- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/bindings/crypto/bindings/srs.ts b/src/bindings/crypto/bindings/srs.ts index cc3d440ba..3c8e9fef4 100644 --- a/src/bindings/crypto/bindings/srs.ts +++ b/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; diff --git a/src/bindings/crypto/napi-srs.ts b/src/bindings/crypto/napi-srs.ts index fe61e75b4..c12047c45 100644 --- a/src/bindings/crypto/napi-srs.ts +++ b/src/bindings/crypto/napi-srs.ts @@ -103,7 +103,18 @@ function srsPerField(f: 'fp' | 'fq', napi: Napi, conversion: RustConversion) { let maybeLagrangeCommitment = (srs: NapiSrs, domain_size: number, i: number) => { try { - return napi[`caml_${f}_srs_maybe_lagrange_commitment`](srs, domain_size, i); + console.log(3); + console.log('srs napi', srs); + + /*let bytes = (napi as any)[`caml_${f}_srs_to_bytes`](srs); + console.log('bytes', bytes); + let wasmSrs = undefined; + if (f === 'fp') wasmSrs = (napi as any)[`caml_${f}_srs_from_bytes`](bytes); + else wasmSrs = (napi as any)[`caml_fq_srs_from_bytes`](bytes); + */ + let s = napi[`caml_${f}_srs_maybe_lagrange_commitment`](srs, domain_size, i); + console.log('S', s); + return s; } catch (error) { console.error(`Error in SRS maybe lagrange commitment for field ${f}`); throw error; @@ -197,7 +208,8 @@ function srsPerField(f: 'fp' | 'fq', napi: Napi, conversion: RustConversion) { // happy, fast case: if basis is already stored on the srs, return the ith commitment let commitment = maybeLagrangeCommitment(srs, domainSize, i); - if (commitment === undefined) { + if (commitment === undefined || commitment === null) { + console.log("comm was undefined"); if (cache === undefined) { // if there is no cache, recompute and store basis in memory commitment = lagrangeCommitment(srs, domainSize, i); @@ -235,6 +247,7 @@ function srsPerField(f: 'fp' | 'fq', napi: Napi, conversion: RustConversion) { commitment = c; } } + console.log("commitment was not undefined"); // edge case for when we have a writeable cache and the basis was already stored on the srs // but we didn't store it in the cache separately yet From a987a9c2ef3ab8c2d83ce05b576daeb6d477bbf5 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 3 Dec 2025 20:12:10 +0100 Subject: [PATCH 5/7] bindings: update polyCommFromRust --- src/bindings/crypto/napi-conversion-core.ts | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/src/bindings/crypto/napi-conversion-core.ts b/src/bindings/crypto/napi-conversion-core.ts index 5c1a403ce..3c849d7f0 100644 --- a/src/bindings/crypto/napi-conversion-core.ts +++ b/src/bindings/crypto/napi-conversion-core.ts @@ -180,22 +180,13 @@ function conversionCorePerField({ makeAffine, PolyComm }: NapiClasses) { return new PolyCommClass(unshifted as unknown, undefined); }; - /* const polyCommFromRust = (polyComm: NapiPolyComm): PolyComm => { + const polyCommFromRust = (polyComm: any): any => { + if (polyComm == null) return undefined; console.log('polyComm', polyComm); const rustUnshifted = asArrayLike(polyComm.unshifted, 'polyComm.unshifted'); 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): NapiPolyComm[] => From aeefc4d74d43fac0bb31316a39c3544c98fbfe74 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 3 Dec 2025 20:13:04 +0100 Subject: [PATCH 6/7] bindings: refactor verifier index --- .../crypto/napi-conversion-verifier-index.ts | 62 +++++++++---------- 1 file changed, 29 insertions(+), 33 deletions(-) diff --git a/src/bindings/crypto/napi-conversion-verifier-index.ts b/src/bindings/crypto/napi-conversion-verifier-index.ts index 23705bb80..60c5cf4a5 100644 --- a/src/bindings/crypto/napi-conversion-verifier-index.ts +++ b/src/bindings/crypto/napi-conversion-verifier-index.ts @@ -1,5 +1,5 @@ import { MlArray, MlBool, MlOption } from '../../lib/ml/base.js'; -import type * as wasmNamespace from '../compiled/node_bindings/plonk_wasm.cjs'; +import type * as napiNamespace from '../compiled/node_bindings/plonk_wasm.cjs'; import type { WasmFpDomain, WasmFpLookupSelectors, @@ -22,17 +22,16 @@ import { Lookup, LookupInfo, LookupSelectors } from './bindings/lookup.js'; export { napiVerifierIndexConversion }; -type wasm = typeof wasmNamespace; +type napi = typeof napiNamespace; -type WasmDomain = WasmFpDomain | WasmFqDomain; -type WasmVerificationEvals = WasmFpPlonkVerificationEvals | WasmFqPlonkVerificationEvals; -type WasmShifts = WasmFpShifts | WasmFqShifts; -type WasmVerifierIndex = WasmFpPlonkVerifierIndex | WasmFqPlonkVerifierIndex; +type NapiDomain = WasmFpDomain | WasmFqDomain; +type NapiVerificationEvals = WasmFpPlonkVerificationEvals | WasmFqPlonkVerificationEvals; +type NapiShifts = WasmFpShifts | WasmFqShifts; +type NapiVerifierIndex = WasmFpPlonkVerifierIndex | WasmFqPlonkVerifierIndex; +type NapiLookupVerifierIndex = WasmFpLookupVerifierIndex | WasmFqLookupVerifierIndex; +type NapiLookupSelector = WasmFpLookupSelectors | WasmFqLookupSelectors; -type WasmLookupVerifierIndex = WasmFpLookupVerifierIndex | WasmFqLookupVerifierIndex; -type WasmLookupSelector = WasmFpLookupSelectors | WasmFqLookupSelectors; - -type WasmClasses = { +type NapiClasses = { Domain: typeof WasmFpDomain | typeof WasmFqDomain; VerificationEvals: typeof WasmFpPlonkVerificationEvals | typeof WasmFqPlonkVerificationEvals; Shifts: typeof WasmFpShifts | typeof WasmFqShifts; @@ -63,7 +62,7 @@ function napiVerifierIndexConversion(napi: any, core: ConversionCores) { } function verifierIndexConversionPerField( - wasm: wasm, + napi: any, core: ConversionCore, { Domain, @@ -72,18 +71,16 @@ function verifierIndexConversionPerField( VerifierIndex, LookupVerifierIndex, LookupSelector, - }: WasmClasses + }: NapiClasses ) { - function domainToRust([, logSizeOfGroup, groupGen]: Domain): WasmDomain { + function domainToRust([, logSizeOfGroup, groupGen]: Domain): NapiDomain { return new Domain(logSizeOfGroup, fieldToRust(groupGen)); } - function domainFromRust(domain: WasmDomain): Domain { - let logSizeOfGroup = domain.log_size_of_group; - let groupGen = fieldFromRust(domain.group_gen); - return [0, logSizeOfGroup, groupGen]; + function domainFromRust(domain: NapiDomain): Domain { + return [0, domain.log_size_of_group, fieldFromRust(domain.group_gen)]; } - function verificationEvalsToRust(evals: VerificationEvals): WasmVerificationEvals { + function verificationEvalsToRust(evals: VerificationEvals): NapiVerificationEvals { let sigmaComm = core.polyCommsToRust(evals[1]); let coefficientsComm = core.polyCommsToRust(evals[2]); let genericComm = core.polyCommToRust(evals[3]); @@ -115,9 +112,7 @@ function verifierIndexConversionPerField( rotComm as any ); } - function verificationEvalsFromRust(evals: WasmVerificationEvals): VerificationEvals { - console.log('evals', evals.coefficients_comm); - + function verificationEvalsFromRust(evals: NapiVerificationEvals): VerificationEvals { let mlEvals: VerificationEvals = [ 0, core.polyCommsFromRust(evals.sigma_comm), @@ -138,7 +133,7 @@ function verifierIndexConversionPerField( return mlEvals; } - function lookupVerifierIndexToRust(lookup: Lookup): WasmLookupVerifierIndex { + function lookupVerifierIndexToRust(lookup: Lookup): NapiLookupVerifierIndex { let [ , joint_lookup_used, @@ -157,7 +152,7 @@ function verifierIndexConversionPerField( MlOption.mapFrom(runtime_tables_selector, core.polyCommToRust) as any ); } - function lookupVerifierIndexFromRust(lookup: WasmLookupVerifierIndex): Lookup { + function lookupVerifierIndexFromRust(lookup: NapiLookupVerifierIndex): Lookup { let mlLookup: Lookup = [ 0, MlBool(lookup.joint_lookup_used), @@ -176,7 +171,7 @@ function verifierIndexConversionPerField( xor, range_check, ffmul, - ]: LookupSelectors): WasmLookupSelector { + ]: LookupSelectors): NapiLookupSelector { return new LookupSelector( MlOption.mapFrom(xor, core.polyCommToRust) as any, MlOption.mapFrom(lookup, core.polyCommToRust) as any, @@ -184,7 +179,7 @@ function verifierIndexConversionPerField( MlOption.mapFrom(ffmul, core.polyCommToRust) as any ); } - function lookupSelectorsFromRust(selector: WasmLookupSelector): LookupSelectors { + function lookupSelectorsFromRust(selector: NapiLookupSelector): LookupSelectors { let lookup = MlOption.mapTo(selector.lookup, core.polyCommFromRust); let xor = MlOption.mapTo(selector.xor, core.polyCommFromRust); let range_check = MlOption.mapTo(selector.range_check, core.polyCommFromRust); @@ -195,18 +190,18 @@ function verifierIndexConversionPerField( function lookupInfoToRust([, maxPerRow, maxJointSize, features]: LookupInfo): WasmLookupInfo { let [, patterns, joint_lookup_used, uses_runtime_tables] = features; let [, xor, lookup, range_check, foreign_field_mul] = patterns; - let wasmPatterns = new wasm.LookupPatterns( + let napiPatterns = new napi.LookupPatterns( MlBool.from(xor), MlBool.from(lookup), MlBool.from(range_check), MlBool.from(foreign_field_mul) ); - let wasmFeatures = new wasm.LookupFeatures( - wasmPatterns, + let napiFeatures = new napi.LookupFeatures( + napiPatterns, MlBool.from(joint_lookup_used), MlBool.from(uses_runtime_tables) ); - return new wasm.LookupInfo(maxPerRow, maxJointSize, wasmFeatures); + return new napi.LookupInfo(maxPerRow, maxJointSize, napiFeatures); } function lookupInfoFromRust(info: WasmLookupInfo): LookupInfo { let features = info.features; @@ -232,16 +227,16 @@ function verifierIndexConversionPerField( } let self = { - shiftsToRust([, ...shifts]: MlArray): WasmShifts { + shiftsToRust([, ...shifts]: MlArray): NapiShifts { let s = shifts.map((s) => fieldToRust(s)); return new Shifts(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); }, - shiftsFromRust(s: WasmShifts): MlArray { + shiftsFromRust(s: NapiShifts): MlArray { let shifts = [s.s0, s.s1, s.s2, s.s3, s.s4, s.s5, s.s6]; return [0, ...shifts.map(fieldFromRust)]; }, - verifierIndexToRust(vk: VerifierIndex): WasmVerifierIndex { + verifierIndexToRust(vk: VerifierIndex): NapiVerifierIndex { let domain = domainToRust(vk[1]); let maxPolySize = vk[2]; let nPublic = vk[3]; @@ -263,7 +258,8 @@ function verifierIndexConversionPerField( zkRows ); }, - verifierIndexFromRust(vk: WasmVerifierIndex): VerifierIndex { + verifierIndexFromRust(vk: NapiVerifierIndex): VerifierIndex { + console.log('vk from rust', vk); let mlVk: VerifierIndex = [ 0, domainFromRust(vk.domain), From c8cbc548b12feaadc80ec4bd2ef1f2e36fa88ad5 Mon Sep 17 00:00:00 2001 From: querolita Date: Wed, 3 Dec 2025 20:13:14 +0100 Subject: [PATCH 7/7] submodule: update mina --- src/mina | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mina b/src/mina index 8437493a8..6f15cb8b8 160000 --- a/src/mina +++ b/src/mina @@ -1 +1 @@ -Subproject commit 8437493a87dcc0db0065a19b8d74d34c567b4c53 +Subproject commit 6f15cb8b8ef76a1c7c1d57d04da02836a0d6f36e