Skip to content

Commit 0380ac1

Browse files
Trivo25Trivo25
committed
temp
1 parent bd17944 commit 0380ac1

File tree

3 files changed

+121
-19
lines changed

3 files changed

+121
-19
lines changed

‎src/bindings/crypto/bindings.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,7 @@ const tsBindings = {
4949
return bundle.srsFactory(wasm, bundle.conversion);
5050
},*/
5151
srs: (wasm: Wasm) => srs(wasm, getRustConversion(wasm)),
52+
srsNative: (napi: Wasm) => srs(napi, createNativeRustConversion(napi) as any),
5253
};
5354

5455
// this is put in a global variable so that mina/src/lib/crypto/kimchi_bindings/js/bindings.js finds it

‎src/bindings/crypto/bindings/srs.ts‎

Lines changed: 109 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -71,20 +71,91 @@ function srs(wasm: Wasm, conversion: RustConversion) {
7171

7272
function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
7373
// note: these functions are properly typed, thanks to TS template literal types
74-
let createSrs = (s: number) => wasm[`caml_${f}_srs_create_parallel`](s);
75-
let getSrs = wasm[`caml_${f}_srs_get`];
76-
let setSrs = wasm[`caml_${f}_srs_set`];
74+
let createSrs = (size: number) => {
75+
try {
76+
console.log(0);
77+
return wasm[`caml_${f}_srs_create_parallel`](size);
78+
} catch (error) {
79+
console.error(`Error in SRS get for field ${f}`);
80+
throw error;
81+
}
82+
};
83+
let getSrs = (srs: WasmSrs) => {
84+
try {
85+
console.log(1);
86+
let v = wasm[`caml_${f}_srs_get`](srs);
87+
console.log(2);
88+
return v;
89+
} catch (error) {
90+
console.error(`Error in SRS get for field ${f}`);
91+
throw error;
92+
}
93+
};
94+
let setSrs = (bytes: any) => {
95+
try {
96+
console.log(2);
97+
return wasm[`caml_${f}_srs_set`](bytes);
98+
} catch (error) {
99+
console.error(`Error in SRS set for field ${f} args ${bytes}`);
100+
throw error;
101+
}
102+
};
103+
104+
let maybeLagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
105+
try {
106+
console.log(3);
107+
return wasm[`caml_${f}_srs_maybe_lagrange_commitment`](srs, domain_size, i);
108+
} catch (error) {
109+
console.error(`Error in SRS maybe lagrange commitment for field ${f}`);
110+
throw error;
111+
}
112+
};
113+
let lagrangeCommitment = (srs: WasmSrs, domain_size: number, i: number) => {
114+
try {
115+
console.log(4);
116+
return wasm[`caml_${f}_srs_lagrange_commitment`](srs, domain_size, i);
117+
} catch (error) {
118+
console.error(`Error in SRS lagrange commitment for field ${f}`);
119+
throw error;
120+
}
121+
};
122+
let lagrangeCommitmentsWholeDomainPtr = (srs: WasmSrs, domain_size: number) => {
123+
try {
124+
console.log(5);
125+
return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](srs, domain_size);
126+
} catch (error) {
127+
console.error(`Error in SRS lagrange commitments whole domain ptr for field ${f}`);
128+
throw error;
129+
}
130+
};
131+
let setLagrangeBasis = (srs: WasmSrs, domain_size: number, input: any) => {
132+
try {
133+
console.log(6);
134+
return wasm[`caml_${f}_srs_set_lagrange_basis`](srs, domain_size, input);
135+
} catch (error) {
136+
console.error(`Error in SRS set lagrange basis for field ${f}`);
137+
throw error;
138+
}
139+
};
140+
let getLagrangeBasis = (srs: WasmSrs, n: number) => {
141+
try {
142+
console.log(7);
143+
return wasm[`caml_${f}_srs_get_lagrange_basis`](srs, n);
144+
} catch (error) {
145+
console.error(`Error in SRS get lagrange basis for field ${f}`);
146+
throw error;
147+
}
148+
};
149+
let getCommitmentsWholeDomainByPtr = (ptr: number) => {
150+
try {
151+
console.log(8);
152+
return wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_read_from_ptr`](ptr);
153+
} catch (error) {
154+
console.error(`Error in SRS get commitments whole domain by ptr for field ${f}`);
155+
throw error;
156+
}
157+
};
77158

78-
let maybeLagrangeCommitment = wasm[`caml_${f}_srs_maybe_lagrange_commitment`];
79-
let lagrangeCommitment = (srs: WasmFpSrs, domain_size: number, i: number) =>
80-
wasm[`caml_${f}_srs_lagrange_commitment`](srs, domain_size, i);
81-
let lagrangeCommitmentsWholeDomainPtr = (srs: WasmSrs, domain_size: number) =>
82-
wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_ptr`](srs, domain_size);
83-
let setLagrangeBasis = wasm[`caml_${f}_srs_set_lagrange_basis`];
84-
let getLagrangeBasis = (srs: WasmSrs, n: number) =>
85-
wasm[`caml_${f}_srs_get_lagrange_basis`](srs, n);
86-
let getCommitmentsWholeDomainByPtr =
87-
wasm[`caml_${f}_srs_lagrange_commitments_whole_domain_read_from_ptr`];
88159
return {
89160
/**
90161
* 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) {
95166
if (srs === undefined) {
96167
if (cache === undefined) {
97168
// if there is no cache, create SRS in memory
169+
console.log('Creating SRS without cache');
98170
srs = createSrs(size);
171+
console.log('SRS created without cache:', srs);
99172
} else {
100173
let header = cacheHeaderSrs(f, size);
101174

102175
// try to read SRS from cache / recompute and write if not found
176+
console.log('Reading SRS from cache');
103177
srs = readCache(cache, header, (bytes) => {
104178
// TODO: this takes a bit too long, about 300ms for 2^16
105179
// `pointsToRust` is the clear bottleneck
@@ -108,13 +182,17 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
108182
let wasmSrs = conversion[f].pointsToRust(mlSrs);
109183
return setSrs(wasmSrs);
110184
});
111-
185+
console.log('SRS read from cache:', srs);
112186
if (srs === undefined) {
113187
// not in cache
188+
console.log(1);
114189
srs = createSrs(size);
190+
console.log('Writing SRS to cache', srs);
115191

116192
if (cache.canWrite) {
193+
console.log(2);
117194
let wasmSrs = getSrs(srs);
195+
console.log(3);
118196
let mlSrs = conversion[f].pointsFromRust(wasmSrs);
119197
let jsonSrs = MlArray.mapFrom(mlSrs, OrInfinity.toJSON);
120198
let bytes = new TextEncoder().encode(JSON.stringify(jsonSrs));
@@ -123,18 +201,21 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
123201
}
124202
}
125203
}
126-
204+
console.log('Storing SRS in memory');
127205
srsStore[f][size] = srs;
206+
console.log('SRS stored in memory:', srs);
128207
}
129208

130209
// TODO should we call freeOnFinalize() and expose a function to clean the SRS cache?
210+
console.trace('Returning SRS:', srs);
131211
return srsStore[f][size];
132212
},
133213

134214
/**
135215
* returns ith Lagrange basis commitment for a given domain size
136216
*/
137217
lagrangeCommitment(srs: WasmSrs, domainSize: number, i: number): PolyComm {
218+
console.log('lagrangeCommitment');
138219
// happy, fast case: if basis is already stored on the srs, return the ith commitment
139220
let commitment = maybeLagrangeCommitment(srs, domainSize, i);
140221

@@ -208,6 +289,8 @@ function srsPerField(f: 'fp' | 'fq', wasm: Wasm, conversion: RustConversion) {
208289
* Returns the Lagrange basis commitments for the whole domain
209290
*/
210291
lagrangeCommitmentsWholeDomain(srs: WasmSrs, domainSize: number) {
292+
console.log('lagrangeCommitmentsWholeDomain');
293+
211294
// instead of getting the entire commitment directly (which works for nodejs/servers), we get a pointer to the commitment
212295
// and then read the commitment from the pointer
213296
// 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) {
224307
* adds Lagrange basis for a given domain size
225308
*/
226309
addLagrangeBasis(srs: WasmSrs, logSize: number) {
310+
console.log('addLagrangeBasis');
227311
// this ensures that basis is stored on the srs, no need to duplicate caching logic
228312
this.lagrangeCommitment(srs, 1 << logSize, 0);
229313
},
@@ -270,3 +354,13 @@ function readCacheLazy(
270354
return true;
271355
});
272356
}
357+
function runInTryCatch<T extends (...args: any[]) => any>(fn: T): T {
358+
return function (...args: Parameters<T>): ReturnType<T> {
359+
try {
360+
return fn(...args);
361+
} catch (e) {
362+
console.error(`Error in SRS function ${fn.name} with args:`, args);
363+
throw e;
364+
}
365+
} as T;
366+
}

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

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,11 @@ import { mapFromUintArray } from './bindings/conversion-core.js';
1010
import { Field, Gate, LookupTable, OrInfinity, PolyComm, Wire } from './bindings/kimchi-types.js';
1111
import { mapTuple } from './bindings/util.js';
1212

13-
export { napiConversionCore, ConversionCore, ConversionCores };
13+
export { ConversionCore, ConversionCores, napiConversionCore };
1414

1515
type ConversionCore = ReturnType<typeof conversionCorePerField>;
1616
type ConversionCores = ReturnType<typeof napiConversionCore>;
17-
17+
1818
type NapiAffine = napiNamespace.WasmGVesta | napiNamespace.WasmGPallas;
1919
type NapiPolyComm = { unshifted: unknown; shifted?: NapiAffine | undefined };
2020
type PolyCommCtor = new (unshifted: unknown, shifted?: NapiAffine | undefined) => NapiPolyComm;
@@ -71,7 +71,13 @@ function napiConversionCore(napi: any) {
7171

7272
return {
7373
fp: { ...fpCore },
74-
fq: { ...fqCore },
74+
fq: {
75+
...fqCore,
76+
shiftsFromRust: (s: any) => {
77+
let shifts = [s.s0, s.s1, s.s2, s.s3, s.s4, s.s5, s.s6];
78+
return [0, ...shifts.map(fieldFromRust)];
79+
},
80+
},
7581
...shared,
7682
};
7783
}
@@ -126,7 +132,8 @@ function conversionCorePerField({ makeAffine, PolyComm }: NapiClasses) {
126132
wireFromRust(w5),
127133
wireFromRust(w6),
128134
];
129-
const coeffBytes = gate.coeffs instanceof Uint8Array ? gate.coeffs : Uint8Array.from(gate.coeffs);
135+
const coeffBytes =
136+
gate.coeffs instanceof Uint8Array ? gate.coeffs : Uint8Array.from(gate.coeffs);
130137
const coeffs = fieldsFromRustFlat(coeffBytes);
131138
return [0, gate.typ, wiresTuple, coeffs];
132139
};

0 commit comments

Comments
 (0)