@aztec/bb.js 3.0.0-nightly.20251030 → 3.0.0-nightly.20251031

package/dest/node/bbapi_exception.js

@@ -0,0 +1,14 @@
+/**
+ * Exception thrown when barretenberg API operations fail
+ */
+export class BBApiException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BBApiException';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, BBApiException);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmJhcGlfZXhjZXB0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JiYXBpX2V4Y2VwdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sT0FBTyxjQUFlLFNBQVEsS0FBSztJQUN2QyxZQUFZLE9BQWU7UUFDekIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxnQkFBZ0IsQ0FBQztRQUM3QixxRkFBcUY7UUFDckYsSUFBSSxLQUFLLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUM1QixLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBQ2hELENBQUM7SUFDSCxDQUFDO0NBQ0YifQ==

package/dest/node/benchmark/index.d.ts

@@ -0,0 +1,3 @@
+export * from './timer.js';
+export declare function writeBenchmark<T>(name: string, value: T, labels?: Record<string, any>): void;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/benchmark/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/benchmark/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAW3B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,QAazF"}

package/dest/node/benchmark/index.js

@@ -0,0 +1,25 @@
+import * as fs from 'fs';
+export * from './timer.js';
+const bfd = (() => {
+    const bfdStr = process.env.BENCHMARK_FD;
+    const bfd = bfdStr ? parseInt(bfdStr) : -1;
+    if (bfd >= 0 && !fs.fstatSync(bfd)) {
+        throw new Error('fd is not open. Did you redirect in your shell?');
+    }
+    return bfd;
+})();
+export function writeBenchmark(name, value, labels = {}) {
+    if (bfd === -1) {
+        return;
+    }
+    const data = {
+        timestamp: new Date().toISOString(),
+        name,
+        type: typeof value,
+        value,
+        ...labels,
+    };
+    const jsonl = JSON.stringify(data) + '\n';
+    fs.writeSync(bfd, jsonl);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmVuY2htYXJrL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLGNBQWMsWUFBWSxDQUFDO0FBRTNCLE1BQU0sR0FBRyxHQUFHLENBQUMsR0FBRyxFQUFFO0lBQ2hCLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDO0lBQ3hDLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUMzQyxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDbkMsTUFBTSxJQUFJLEtBQUssQ0FBQyxpREFBaUQsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFDRCxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUMsQ0FBQyxFQUFFLENBQUM7QUFFTCxNQUFNLFVBQVUsY0FBYyxDQUFJLElBQVksRUFBRSxLQUFRLEVBQUUsU0FBOEIsRUFBRTtJQUN4RixJQUFJLEdBQUcsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ2YsT0FBTztJQUNULENBQUM7SUFDRCxNQUFNLElBQUksR0FBRztRQUNYLFNBQVMsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRTtRQUNuQyxJQUFJO1FBQ0osSUFBSSxFQUFFLE9BQU8sS0FBSztRQUNsQixLQUFLO1FBQ0wsR0FBRyxNQUFNO0tBQ1YsQ0FBQztJQUNGLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDO0lBQzFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO0FBQzNCLENBQUMifQ==

package/dest/node/benchmark/timer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export declare class Timer {
+    private start;
+    constructor();
+    us(): number;
+    /**
+     * Returns the elapsed time in milliseconds since the Timer instance was created.
+     * Provides a simple and convenient way to measure the time duration between two events
+     * or monitor performance of specific code sections.
+     *
+     * @returns The elapsed time in milliseconds.
+     */
+    ms(): number;
+    /**
+     * Returns the time elapsed since the Timer instance was created, in seconds.
+     * The value is calculated by subtracting the initial start time from the current time
+     * and dividing the result by 1000 to convert milliseconds to seconds.
+     *
+     * @returns The elapsed time in seconds.
+     */
+    s(): number;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dest/node/benchmark/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../../src/benchmark/timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAS;;IAMf,EAAE;IAIT;;;;;;OAMG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,CAAC;CAGT"}

package/dest/node/benchmark/timer.js

@@ -0,0 +1,41 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */
+export class Timer {
+    constructor() {
+        this.start = performance.now();
+    }
+    us() {
+        return this.ms() * 1000;
+    }
+    /**
+     * Returns the elapsed time in milliseconds since the Timer instance was created.
+     * Provides a simple and convenient way to measure the time duration between two events
+     * or monitor performance of specific code sections.
+     *
+     * @returns The elapsed time in milliseconds.
+     */
+    ms() {
+        return performance.now() - this.start;
+    }
+    /**
+     * Returns the time elapsed since the Timer instance was created, in seconds.
+     * The value is calculated by subtracting the initial start time from the current time
+     * and dividing the result by 1000 to convert milliseconds to seconds.
+     *
+     * @returns The elapsed time in seconds.
+     */
+    s() {
+        return this.ms() / 1000;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmVuY2htYXJrL3RpbWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsTUFBTSxPQUFPLEtBQUs7SUFHaEI7UUFDRSxJQUFJLENBQUMsS0FBSyxHQUFHLFdBQVcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUNqQyxDQUFDO0lBRU0sRUFBRTtRQUNQLE9BQU8sSUFBSSxDQUFDLEVBQUUsRUFBRSxHQUFHLElBQUksQ0FBQztJQUMxQixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksRUFBRTtRQUNQLE9BQU8sV0FBVyxDQUFDLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDeEMsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLENBQUM7UUFDTixPQUFPLElBQUksQ0FBQyxFQUFFLEVBQUUsR0FBRyxJQUFJLENBQUM7SUFDMUIsQ0FBQztDQUNGIn0=

package/dest/node/bigint-array/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Convert a 32-byte BE Buffer to a BigInt.
+ */
+export declare function buffer32BytesToBigIntBE(buf: Buffer): bigint;
+/**
+ * Convert a BE Uint8Array to a BigInt.
+ */
+export declare function uint8ArrayToBigIntBE(bytes: Uint8Array): bigint;
+/**
+ * Convert a BigInt to a 32-byte BE Buffer.
+ */
+export declare function bigIntToBufferBE(value: bigint, byteLength?: number): Buffer;
+/**
+ * Convert a BigInt to a 32-byte BE Uint8Array.
+ */
+export declare function bigIntToUint8ArrayBE(value: bigint, byteLength?: number): Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/bigint-array/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bigint-array/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAG9D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAYvE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,UAAU,CAE/E"}

package/dest/node/bigint-array/index.js

@@ -0,0 +1,37 @@
+/**
+ * Convert a 32-byte BE Buffer to a BigInt.
+ */
+export function buffer32BytesToBigIntBE(buf) {
+    return ((buf.readBigUInt64BE(0) << 192n) +
+        (buf.readBigUInt64BE(8) << 128n) +
+        (buf.readBigUInt64BE(16) << 64n) +
+        buf.readBigUInt64BE(24));
+}
+/**
+ * Convert a BE Uint8Array to a BigInt.
+ */
+export function uint8ArrayToBigIntBE(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer32BytesToBigIntBE(buffer);
+}
+/**
+ * Convert a BigInt to a 32-byte BE Buffer.
+ */
+export function bigIntToBufferBE(value, byteLength = 32) {
+    if (byteLength != 32) {
+        throw new Error(`Only 32 bytes supported for conversion from bigint to buffer, attempted byte length: ${byteLength}`);
+    }
+    const buf = Buffer.alloc(byteLength);
+    buf.writeBigUInt64BE(value >> 192n, 0);
+    buf.writeBigUInt64BE((value >> 128n) & 0xffffffffffffffffn, 8);
+    buf.writeBigUInt64BE((value >> 64n) & 0xffffffffffffffffn, 16);
+    buf.writeBigUInt64BE(value & 0xffffffffffffffffn, 24);
+    return buf;
+}
+/**
+ * Convert a BigInt to a 32-byte BE Uint8Array.
+ */
+export function bigIntToUint8ArrayBE(value, byteLength = 32) {
+    return new Uint8Array(bigIntToBufferBE(value, byteLength));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmlnaW50LWFycmF5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QixDQUFDLEdBQVc7SUFDakQsT0FBTyxDQUNMLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsSUFBSSxJQUFJLENBQUM7UUFDaEMsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQztRQUNoQyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDLElBQUksR0FBRyxDQUFDO1FBQ2hDLEdBQUcsQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDLENBQ3hCLENBQUM7QUFDSixDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsS0FBaUI7SUFDcEQsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsQyxPQUFPLHVCQUF1QixDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ3pDLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxLQUFhLEVBQUUsVUFBVSxHQUFHLEVBQUU7SUFDN0QsSUFBSSxVQUFVLElBQUksRUFBRSxFQUFFLENBQUM7UUFDckIsTUFBTSxJQUFJLEtBQUssQ0FDYix3RkFBd0YsVUFBVSxFQUFFLENBQ3JHLENBQUM7SUFDSixDQUFDO0lBQ0QsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNyQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxJQUFJLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztJQUN2QyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxLQUFLLElBQUksSUFBSSxDQUFDLEdBQUcsbUJBQW1CLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDL0QsR0FBRyxDQUFDLGdCQUFnQixDQUFDLENBQUMsS0FBSyxJQUFJLEdBQUcsQ0FBQyxHQUFHLG1CQUFtQixFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQy9ELEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLEdBQUcsbUJBQW1CLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDdEQsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsS0FBYSxFQUFFLFVBQVUsR0FBRyxFQUFFO0lBQ2pFLE9BQU8sSUFBSSxVQUFVLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUM7QUFDN0QsQ0FBQyJ9

package/dest/node/cbind/generate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate TypeScript bindings from msgpack schema
+ */
+export {};
+//# sourceMappingURL=generate.d.ts.map

package/dest/node/cbind/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/cbind/generate.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dest/node/cbind/generate.js

@@ -0,0 +1,151 @@
+/**
+ * Generate TypeScript bindings from msgpack schema
+ */
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { unpack } from 'msgpackr';
+import { createSharedTypesCompiler, createSyncApiCompiler, createAsyncApiCompiler, } from './schema_compiler.js';
+const execAsync = promisify(exec);
+const GENERATORS = [
+    {
+        name: 'Shared types',
+        outputFile: 'generated/api_types.ts',
+        createCompiler: createSharedTypesCompiler,
+    },
+    {
+        name: 'Sync API',
+        outputFile: 'generated/sync.ts',
+        createCompiler: createSyncApiCompiler,
+    },
+    {
+        name: 'Async API',
+        outputFile: 'generated/async.ts',
+        createCompiler: createAsyncApiCompiler,
+    },
+];
+// @ts-ignore
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function generate() {
+    const bbBuildPath = process.env.BB_BINARY_PATH || join(__dirname, '../../../cpp/build/bin/bb');
+    // Get schema from bb
+    console.log('Fetching msgpack schema from bb...');
+    const { stdout } = await execAsync(`${bbBuildPath} msgpack schema`);
+    const schema = JSON.parse(stdout.trim());
+    if (!schema.commands || !schema.responses) {
+        throw new Error('Invalid schema: missing commands or responses');
+    }
+    console.log('Generating TypeScript bindings...\n');
+    // Ensure output directory exists
+    const outputDir = join(__dirname, 'generated');
+    mkdirSync(outputDir, { recursive: true });
+    // Generate each output file
+    for (const config of GENERATORS) {
+        const compiler = config.createCompiler();
+        compiler.processApiSchema(schema.commands, schema.responses);
+        const outputPath = join(__dirname, config.outputFile);
+        const content = compiler.compile();
+        writeFileSync(outputPath, content);
+        console.log(`✓ ${config.name}: ${outputPath}`);
+    }
+    // Generate curve constants
+    console.log('\nGenerating curve constants...');
+    await generateCurveConstants(bbBuildPath, outputDir);
+    console.log('\nGeneration complete!');
+}
+async function generateCurveConstants(bbBuildPath, outputDir) {
+    // Get curve constants from bb as msgpack binary
+    const { stdout: constantsBuffer } = await execAsync(`${bbBuildPath} msgpack curve_constants`, {
+        encoding: 'buffer',
+        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+    });
+    // Decode msgpack
+    const constants = unpack(constantsBuffer);
+    // Helper to convert Uint8Array to hex string
+    const toHex = (bytes) => '0x' + Buffer.from(bytes).toString('hex');
+    // Helper to convert Uint8Array to bigint (big-endian)
+    const toBigInt = (bytes) => {
+        let result = 0n;
+        for (const byte of bytes) {
+            result = (result << 8n) | BigInt(byte);
+        }
+        return result;
+    };
+    // Helper to serialize point coordinate (handles both Uint8Array and array of Uint8Array for field2)
+    const serializeCoordinate = (coord) => {
+        if (Array.isArray(coord)) {
+            // For field2 (like BN254 G2), we have array of two Uint8Arrays
+            return `[${coord.map(c => `new Uint8Array([${Array.from(c).join(', ')}])`).join(', ')}]`;
+        }
+        else {
+            // For regular fields, single Uint8Array
+            return `new Uint8Array([${Array.from(coord).join(', ')}])`;
+        }
+    };
+    // Generate TypeScript file
+    const content = `/**
+ * Curve constants generated from barretenberg native binary.
+ * DO NOT EDIT - This file is auto-generated by generate.ts
+ */
+
+/**
+ * BN254 curve constants
+ */
+export const BN254_FR_MODULUS = ${toBigInt(constants.bn254_fr_modulus)}n;
+export const BN254_FQ_MODULUS = ${toBigInt(constants.bn254_fq_modulus)}n;
+
+export const BN254_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.bn254_g1_generator.x)},
+  y: ${serializeCoordinate(constants.bn254_g1_generator.y)},
+} as const;
+
+export const BN254_G2_GENERATOR = {
+  x: ${serializeCoordinate(constants.bn254_g2_generator.x)},
+  y: ${serializeCoordinate(constants.bn254_g2_generator.y)},
+} as const;
+
+/**
+ * Grumpkin curve constants
+ */
+export const GRUMPKIN_FR_MODULUS = ${toBigInt(constants.grumpkin_fr_modulus)}n;
+export const GRUMPKIN_FQ_MODULUS = ${toBigInt(constants.grumpkin_fq_modulus)}n;
+
+export const GRUMPKIN_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.grumpkin_g1_generator.x)},
+  y: ${serializeCoordinate(constants.grumpkin_g1_generator.y)},
+} as const;
+
+/**
+ * Secp256k1 curve constants
+ */
+export const SECP256K1_FR_MODULUS = ${toBigInt(constants.secp256k1_fr_modulus)}n;
+export const SECP256K1_FQ_MODULUS = ${toBigInt(constants.secp256k1_fq_modulus)}n;
+
+export const SECP256K1_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.secp256k1_g1_generator.x)},
+  y: ${serializeCoordinate(constants.secp256k1_g1_generator.y)},
+} as const;
+
+/**
+ * Secp256r1 curve constants
+ */
+export const SECP256R1_FR_MODULUS = ${toBigInt(constants.secp256r1_fr_modulus)}n;
+export const SECP256R1_FQ_MODULUS = ${toBigInt(constants.secp256r1_fq_modulus)}n;
+
+export const SECP256R1_G1_GENERATOR = {
+  x: ${serializeCoordinate(constants.secp256r1_g1_generator.x)},
+  y: ${serializeCoordinate(constants.secp256r1_g1_generator.y)},
+} as const;
+`;
+    const outputPath = join(outputDir, 'curve_constants.ts');
+    writeFileSync(outputPath, content);
+    console.log(`✓ Curve constants: ${outputPath}`);
+}
+// Run the generator
+generate().catch(error => {
+    console.error('Generation failed:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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