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

package/README.md

@@ -85,7 +85,7 @@ You can enable these headers for specific pages that perform proof generation, b
 Got an unhelpful stack trace in wasm? Run:
 
 ```
-NO_STRIP=1 ./script/build_wasm.sh
+BUILD_CPP=1 NO_STRIP=1 ./script/copy_wasm.sh
 ```
 
 This will drop unstripped wasms into the dest folder. Run your test again to get a trace.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aztec/bb.js",
   "packageManager": "yarn@4.5.2",
-  "version": "3.0.0-nightly.20251025",
+  "version": "3.0.0-nightly.20251030",
   "homepage": "https://github.com/AztecProtocol/aztec-packages/tree/master/barretenberg/ts",
   "license": "MIT",
   "type": "module",
@@ -22,8 +22,9 @@
   ],
   "scripts": {
     "clean": "rm -rf ./dest .tsbuildinfo .tsbuildinfo.cjs ./src/cbind/generated",
-    "build": "yarn clean && yarn generate && yarn build:wasm && yarn build:esm && yarn build:cjs && yarn build:browser",
-    "build:wasm": "./scripts/build_wasm.sh",
+    "build": "yarn clean && yarn generate && yarn build:wasm && yarn build:native && yarn build:esm && yarn build:cjs && yarn build:browser",
+    "build:wasm": "./scripts/copy_wasm.sh",
+    "build:native": "./scripts/copy_native.sh",
     "build:esm": "tsc -b tsconfig.esm.json",
     "build:cjs": "tsc -b tsconfig.cjs.json && ./scripts/cjs_postprocess.sh",
     "build:browser": "tsc -b tsconfig.browser.json && ./scripts/browser_postprocess.sh",

package/src/barretenberg/backend.ts

@@ -1,6 +1,6 @@
 import { BackendOptions, Barretenberg, CircuitOptions } from './index.js';
 import { ProofData, uint8ArrayToHex, hexToUint8Array } from '../proof/index.js';
-import { fromClientIVCProof, toClientIVCProof } from '../cbind/generated/api_types.js';
+import { fromChonkProof, toChonkProof } from '../cbind/generated/api_types.js';
 import { ungzip } from 'pako';
 import { Buffer } from 'buffer';
 import { Decoder, Encoder } from 'msgpackr';
@@ -268,7 +268,7 @@ export class AztecClientBackend {
   private async instantiate(): Promise<void> {
     if (!this.api) {
       const api = await Barretenberg.new(this.options);
-      await api.initSRSClientIVC();
+      await api.initSRSChonk();
       this.api = api;
     }
   }
@@ -284,7 +284,7 @@ export class AztecClientBackend {
     await this.instantiate();
 
     // Queue IVC start with the number of circuits
-    this.api.clientIvcStart({ numCircuits: this.acirBuf.length });
+    this.api.chonkStart({ numCircuits: this.acirBuf.length });
 
     // Queue load and accumulate for each circuit
     for (let i = 0; i < this.acirBuf.length; i++) {
@@ -294,7 +294,7 @@ export class AztecClientBackend {
       const functionName = `unknown_wasm_${i}`;
 
       // Load the circuit
-      this.api.clientIvcLoad({
+      this.api.chonkLoad({
         circuit: {
           name: functionName,
           bytecode: Buffer.from(bytecode),
@@ -303,17 +303,17 @@ export class AztecClientBackend {
       });
 
       // Accumulate with witness
-      this.api.clientIvcAccumulate({
+      this.api.chonkAccumulate({
         witness: Buffer.from(witness),
       });
     }
 
     // Generate the proof (and wait for all previous steps to finish)
-    const proveResult = await this.api.clientIvcProve({});
+    const proveResult = await this.api.chonkProve({});
     // The API currently expects a msgpack-encoded API.
-    const proof = new Encoder({ useRecords: false }).encode(fromClientIVCProof(proveResult.proof));
+    const proof = new Encoder({ useRecords: false }).encode(fromChonkProof(proveResult.proof));
     // Generate the VK
-    const vkResult = await this.api.clientIvcComputeIvcVk({
+    const vkResult = await this.api.chonkComputeIvcVk({
       circuit: {
         name: 'hiding',
         bytecode: this.acirBuf[this.acirBuf.length - 1],
@@ -330,15 +330,15 @@ export class AztecClientBackend {
 
     // Note: Verification may not work correctly until we properly serialize the proof
     if (!(await this.verify(proof, vkResult.bytes))) {
-      throw new AztecClientBackendError('Failed to verify the private (ClientIVC) transaction proof!');
+      throw new AztecClientBackendError('Failed to verify the private (Chonk) transaction proof!');
     }
     return [proofFields, proof, vkResult.bytes];
   }
 
   async verify(proof: Uint8Array, vk: Uint8Array): Promise<boolean> {
     await this.instantiate();
-    const result = await this.api.clientIvcVerify({
-      proof: toClientIVCProof(new Decoder({ useRecords: false }).decode(proof)),
+    const result = await this.api.chonkVerify({
+      proof: toChonkProof(new Decoder({ useRecords: false }).decode(proof)),
       vk: Buffer.from(vk),
     });
     return result.valid;
@@ -348,7 +348,7 @@ export class AztecClientBackend {
     await this.instantiate();
     const circuitSizes: number[] = [];
     for (const buf of this.acirBuf) {
-      const gates = await this.api.clientIvcStats({
+      const gates = await this.api.chonkStats({
         circuit: {
           name: 'circuit',
           bytecode: buf,

package/src/barretenberg/index.ts

@@ -68,7 +68,7 @@ export class Barretenberg extends AsyncApi {
     await this.srsInitSrs({ pointsBuf: crs.getG1Data(), numPoints: crs.numPoints, g2Point: crs.getG2Data() });
   }
 
-  async initSRSClientIVC(srsSize = this.getDefaultSrsSize()): Promise<void> {
+  async initSRSChonk(srsSize = this.getDefaultSrsSize()): Promise<void> {
     // crsPath can be undefined
     const crs = await Crs.new(srsSize + 1, this.options.crsPath, this.options.logger);
     const grumpkinCrs = await GrumpkinCrs.new(2 ** 16 + 1, this.options.crsPath, this.options.logger);

package/src/barretenberg/poseidon.bench.test.ts

@@ -1,4 +1,5 @@
-import { Barretenberg, BarretenbergSync, Fr } from '../index.js';
+import { Barretenberg, BarretenbergSync } from '../index.js';
+import { Fr } from '../types/fields.js';
 import { serializeBufferable } from '../serialize/index.js';
 import { BarretenbergWasmMain } from '../barretenberg_wasm/barretenberg_wasm_main/index.js';
 import { fetchModuleAndThreads } from '../barretenberg_wasm/index.js';

package/src/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.ts

@@ -10,8 +10,8 @@ import { type BarretenbergWasmMain } from './index.js';
  */
 export class HeapAllocator {
   private allocs: number[] = [];
-  private inScratchPtr = 0;      // Next input starts here, grows UP
-  private outScratchPtr = 1024;  // Next output ends here, grows DOWN
+  private inScratchPtr = 0; // Next input starts here, grows UP
+  private outScratchPtr = 1024; // Next output ends here, grows DOWN
 
   constructor(private wasm: BarretenbergWasmMain) {}
 
@@ -22,7 +22,7 @@ export class HeapAllocator {
         // Check if there's room in scratch space (inputs grow up, outputs grow down)
         if (this.inScratchPtr + size <= this.outScratchPtr) {
           const ptr = this.inScratchPtr;
-          this.inScratchPtr += size;  // Grow UP
+          this.inScratchPtr += size; // Grow UP
           this.wasm.writeMemory(ptr, bufOrNum);
           return ptr;
         } else {
@@ -46,7 +46,7 @@ export class HeapAllocator {
 
       // Check if there's room in scratch space (inputs grow up, outputs grow down)
       if (this.inScratchPtr + size <= this.outScratchPtr) {
-        this.outScratchPtr -= size;  // Grow DOWN
+        this.outScratchPtr -= size; // Grow DOWN
         return this.outScratchPtr;
       } else {
         // Fall back to heap allocation

package/src/bb_backends/wasm.ts

@@ -39,15 +39,8 @@ export class BarretenbergWasmSyncBackend implements IMsgpackBackendSync {
 /**
  * Asynchronous WASM backend that supports both direct WASM and worker-based modes.
  *
- * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread.
- *   - Browser-safe: Won't block UI during long operations
- *   - Overhead: ~3-4x slower due to serialize/deserialize for each call
- *   - Use for: Browser environments, long-running operations
- *
- * Direct mode (useWorker: false): Runs WASM directly on the calling thread.
- *   - Performance: ~3-4x faster (no serialize/deserialize overhead)
- *   - Warning: Will block the thread during operations
- *   - Use for: Node.js, benchmarks, tight loops where performance is critical
+ * Worker mode (default): Runs WASM on a worker thread to avoid blocking the main thread. Used in browsers.
+ * Direct mode: Runs WASM directly on the calling thread. Used by node.js for better performance.
  */
 export class BarretenbergWasmAsyncBackend implements IMsgpackBackendAsync {
   private constructor(

package/src/bbapi_exception.ts

@@ -0,0 +1,13 @@
+/**
+ * Exception thrown when barretenberg API operations fail
+ */
+export class BBApiException extends Error {
+  constructor(message: string) {
+    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);
+    }
+  }
+}

package/src/cbind/generate.ts

@@ -7,6 +7,7 @@ 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,
@@ -73,9 +74,107 @@ async function generate() {
     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: string, outputDir: string) {
+  // 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 as Buffer);
+
+  // Helper to convert Uint8Array to hex string
+  const toHex = (bytes: Uint8Array) => '0x' + Buffer.from(bytes).toString('hex');
+
+  // Helper to convert Uint8Array to bigint (big-endian)
+  const toBigInt = (bytes: Uint8Array) => {
+    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: Uint8Array | Uint8Array[]) => {
+    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);

package/src/cbind/schema_compiler.ts

@@ -84,9 +84,16 @@ export class SchemaCompiler {
     const commands = commandsSchema[1] as Array<[string, Schema]>;
     const responses = responsesSchema[1] as Array<[string, Schema]>;
 
+    // Filter out ErrorResponse - it's a special error variant, not a command response
+    const normalResponses = responses.filter(([name]) => name !== 'ErrorResponse');
+
+    if (commands.length !== normalResponses.length) {
+      throw new Error(`Command count (${commands.length}) does not match response count (${normalResponses.length})`);
+    }
+
     for (let i = 0; i < commands.length; i++) {
       const [commandName] = commands[i];
-      const [responseName] = responses[i];
+      const [responseName] = normalResponses[i];
 
       this.functionMetadata.push({
         name: camelCase(commandName),
@@ -399,6 +406,13 @@ export class SchemaCompiler {
         return { typeName: 'string' };
       case 'bin32':
         return { typeName: 'Uint8Array' };
+      case 'field2':
+        // field2 is an extension field type (fq2) represented as a tuple of two Uint8Arrays
+        return {
+          typeName: 'Field2',
+          msgpackTypeName: '[Uint8Array, Uint8Array]',
+          declaration: 'export type Field2 = [Uint8Array, Uint8Array];',
+        };
       default:
         return { typeName: pascalCase(schema) };
     }
@@ -674,8 +688,11 @@ ${destroyMethod}
       return `  ${name}(command: ${commandType}): Promise<${responseType}> {
     const msgpackCommand = from${commandType}(command);
     return msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+      if (variantName === 'ErrorResponse') {
+        throw new BBApiException(result.message || 'Unknown error from barretenberg');
+      }
       if (variantName !== '${responseType}') {
-        throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+        throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
       }
       return to${responseType}(result);
     });
@@ -686,8 +703,11 @@ ${destroyMethod}
     return `  ${name}(command: ${commandType}): ${responseType} {
     const msgpackCommand = from${commandType}(command);
     const [variantName, result] = msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]);
+    if (variantName === 'ErrorResponse') {
+      throw new BBApiException(result.message || 'Unknown error from barretenberg');
+    }
     if (variantName !== '${responseType}') {
-      throw new Error(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+      throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
     }
     return to${responseType}(result);
   }`;
@@ -708,6 +728,7 @@ export function createSyncApiCompiler(): SchemaCompiler {
     imports: [
       `import { IMsgpackBackendSync } from '../../bb_backends/interface.js';`,
       `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
     ],
   });
 }
@@ -718,6 +739,7 @@ export function createAsyncApiCompiler(): SchemaCompiler {
     imports: [
       `import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';`,
       `import { Decoder, Encoder } from 'msgpackr';`,
+      `import { BBApiException } from '../../bbapi_exception.js';`,
     ],
   });
 }

package/src/index.ts

@@ -10,5 +10,32 @@ export {
 } from './barretenberg/index.js';
 
 export { randomBytes } from './random/index.js';
-export { Fr } from './types/index.js';
 export { splitHonkProof, reconstructHonkProof, deflattenFields, type ProofData } from './proof/index.js';
+export { BBApiException } from './bbapi_exception.js';
+
+// Export Point types for use in foundation and other packages
+export type {
+  Bn254G1Point,
+  Bn254G2Point,
+  GrumpkinPoint,
+  Secp256k1Point,
+  Secp256r1Point,
+  Field2,
+} from './cbind/generated/api_types.js';
+
+// Export curve constants for use in foundation
+export {
+  BN254_FQ_MODULUS,
+  BN254_FR_MODULUS,
+  BN254_G1_GENERATOR,
+  BN254_G2_GENERATOR,
+  GRUMPKIN_FR_MODULUS,
+  GRUMPKIN_FQ_MODULUS,
+  GRUMPKIN_G1_GENERATOR,
+  SECP256K1_FR_MODULUS,
+  SECP256K1_FQ_MODULUS,
+  SECP256K1_G1_GENERATOR,
+  SECP256R1_FR_MODULUS,
+  SECP256R1_FQ_MODULUS,
+  SECP256R1_G1_GENERATOR,
+} from './cbind/generated/curve_constants.js';

package/src/serialize/index.ts

@@ -1,2 +1 @@
-export * from './buffer_reader.js';
 export * from './serialize.js';

package/src/types/fields.ts

@@ -5,13 +5,12 @@ import {
   bigIntToBufferBE,
   bigIntToUint8ArrayBE,
 } from '../bigint-array/index.js';
-import { BufferReader } from '../serialize/index.js';
 
-// TODO(#4189): Replace with implementation in yarn-project/foundation/src/fields/fields.ts
 /**
- * Fr field class.
- * @dev This class is used to represent elements of BN254 scalar field or elements in the base field of Grumpkin.
- * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
+ * Internal Fr field class for tests.
+ * @dev This minimal implementation is provided for testing barretenberg directly.
+ * Projects using bb.js should create their own field abstraction using the curve constants
+ * exported from the barretenberg binary (see CurveConstants generation).
  */
 export class Fr {
   static ZERO = new Fr(0n);
@@ -42,14 +41,18 @@ export class Fr {
     return new this(r);
   }
 
-  static fromBuffer(buffer: Uint8Array | Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(reader.readBytes(this.SIZE_IN_BYTES));
+  static fromBuffer(buffer: Uint8Array | Buffer) {
+    if (buffer.length !== this.SIZE_IN_BYTES) {
+      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
+    }
+    return new this(buffer);
   }
 
-  static fromBufferReduce(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
+  static fromBufferReduce(buffer: Uint8Array | Buffer) {
+    if (buffer.length !== this.SIZE_IN_BYTES) {
+      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
+    }
+    return new this(uint8ArrayToBigIntBE(buffer instanceof Buffer ? new Uint8Array(buffer) : buffer) % Fr.MODULUS);
   }
 
   static fromString(str: string) {
@@ -72,55 +75,3 @@ export class Fr {
     return this.value.every(v => v === 0);
   }
 }
-
-/**
- * Fq field class.
- * @dev This class is used to represent elements of BN254 base field or elements in the scalar field of Grumpkin.
- * (Grumpkin's scalar field corresponds to BN254's base field and vice versa.)
- */
-export class Fq {
-  static MODULUS = 0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47n;
-  static MAX_VALUE = this.MODULUS - 1n;
-  static SIZE_IN_BYTES = 32;
-
-  constructor(public readonly value: bigint) {
-    if (value > Fq.MAX_VALUE) {
-      throw new Error(`Fq out of range ${value}.`);
-    }
-  }
-
-  static random() {
-    const r = uint8ArrayToBigIntBE(randomBytes(64)) % Fq.MODULUS;
-    return new this(r);
-  }
-
-  static fromBuffer(buffer: Uint8Array | Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)));
-  }
-
-  static fromBufferReduce(buffer: Uint8Array | Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(uint8ArrayToBigIntBE(reader.readBytes(this.SIZE_IN_BYTES)) % Fr.MODULUS);
-  }
-
-  static fromString(str: string) {
-    return this.fromBuffer(Buffer.from(str.replace(/^0x/i, ''), 'hex'));
-  }
-
-  toBuffer() {
-    return bigIntToBufferBE(this.value, Fq.SIZE_IN_BYTES);
-  }
-
-  toString() {
-    return '0x' + this.value.toString(16);
-  }
-
-  equals(rhs: Fq) {
-    return this.value === rhs.value;
-  }
-
-  isZero() {
-    return this.value === 0n;
-  }
-}

package/src/types/point.ts

@@ -1,6 +1,11 @@
-import { Fr } from './index.js';
-import { BufferReader } from '../serialize/buffer_reader.js';
-
+import { Fr } from './fields.js';
+
+/**
+ * Internal Point class for tests.
+ * @dev This minimal implementation is provided for testing barretenberg directly.
+ * Projects using bb.js should create their own point abstraction using the curve point
+ * types and operations exported from the barretenberg API.
+ */
 export class Point {
   static SIZE_IN_BYTES = 64;
   static EMPTY = new Point(Fr.ZERO, Fr.ZERO);
@@ -10,28 +15,17 @@ export class Point {
     public readonly y: Fr,
   ) {}
 
-  static random() {
-    // TODO: This is not a point on the curve!
-    return new Point(Fr.random(), Fr.random());
-  }
-
-  static fromBuffer(buffer: Uint8Array | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
-  }
-
-  static fromString(address: string) {
-    return Point.fromBuffer(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+  static fromBuffer(buffer: Uint8Array) {
+    if (buffer.length !== this.SIZE_IN_BYTES) {
+      throw new Error(`Expected ${this.SIZE_IN_BYTES} bytes, got ${buffer.length}`);
+    }
+    return new this(Fr.fromBuffer(buffer.subarray(0, 32)), Fr.fromBuffer(buffer.subarray(32, 64)));
   }
 
   toBuffer() {
     return Buffer.concat([this.x.toBuffer(), this.y.toBuffer()]);
   }
 
-  toString() {
-    return '0x' + this.toBuffer().toString('hex');
-  }
-
   equals(rhs: Point) {
     return this.x.equals(rhs.x) && this.y.equals(rhs.y);
   }

package/dest/browser/async_map/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Much the same as Array.map, only it takes an async fn as an element handler, and ensures that each element handler
- * is executed sequentially.
- * The pattern of `await Promise.all(arr.map(async e => { ... }))` only works if one's happy with each element handler
- * being run concurrently.
- * If one required sequential execution of async fn's, the only alternative was regular loops with mutable state vars.
- * The equivalent with asyncMap: `await asyncMap(arr, async e => { ... })`.
- */
-export declare function asyncMap<T, U>(arr: T[], fn: (e: T, i: number) => Promise<U>): Promise<U[]>;
-//# sourceMappingURL=index.d.ts.map

package/dest/browser/async_map/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/async_map/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAMhG"}

package/dest/browser/async_map/index.js

@@ -1,16 +0,0 @@
-/**
- * Much the same as Array.map, only it takes an async fn as an element handler, and ensures that each element handler
- * is executed sequentially.
- * The pattern of `await Promise.all(arr.map(async e => { ... }))` only works if one's happy with each element handler
- * being run concurrently.
- * If one required sequential execution of async fn's, the only alternative was regular loops with mutable state vars.
- * The equivalent with asyncMap: `await asyncMap(arr, async e => { ... })`.
- */
-export async function asyncMap(arr, fn) {
-    const results = [];
-    for (let i = 0; i < arr.length; ++i) {
-        results.push(await fn(arr[i], i));
-    }
-    return results;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXN5bmNfbWFwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFFBQVEsQ0FBTyxHQUFRLEVBQUUsRUFBbUM7SUFDaEYsTUFBTSxPQUFPLEdBQVEsRUFBRSxDQUFDO0lBQ3hCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFDcEMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBQ0QsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQyJ9