@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.21caa21

package/src/barretenberg_api/pedersen.test.ts

@@ -1,84 +0,0 @@
-import { newBarretenbergApiSync } from '../factory/index.js';
-import { Fr } from '../types/index.js';
-import { BarretenbergApiSync } from './index.js';
-
-describe('pedersen', () => {
-  let api: BarretenbergApiSync;
-
-  beforeAll(async () => {
-    api = await newBarretenbergApiSync();
-    api.pedersenHashInit();
-  });
-
-  afterAll(async () => {
-    await api.destroy();
-  });
-
-  it('pedersenCompressFields', () => {
-    const result = api.pedersenCompressFields(new Fr(4n), new Fr(8n));
-    expect(result).toEqual(new Fr(16672613430297770667465722499387909817686322516130512258122141976728892914370n));
-  });
-
-  it('pedersenPlookupCompressFields', () => {
-    const result = api.pedersenPlookupCompressFields(new Fr(4n), new Fr(8n));
-    expect(result).toEqual(new Fr(21568810706345846819294487214368613840251909831689369685420108292337497444070n));
-  });
-
-  it('pedersenCompress', () => {
-    const result = api.pedersenCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(20749503715308760529311051818180468653739005441229560405092292242074298877245n));
-  });
-
-  it('pedersenPlookupCompress', () => {
-    const result = api.pedersenPlookupCompress([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(4213911891650716450883144878301329379460622830501147795631256054071351353887n));
-  });
-
-  it('pedersenCompressWithHashIndex', () => {
-    const result = api.pedersenCompressWithHashIndex([new Fr(4n), new Fr(8n)], 7);
-    expect(result).toEqual(new Fr(12675961871866002745031098923411501942277744385859978302365013982702509949754n));
-  });
-
-  it('pedersenCommit', () => {
-    const result = api.pedersenCommit([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(20749503715308760529311051818180468653739005441229560405092292242074298877245n));
-  });
-
-  it('pedersenPlookupCommit', () => {
-    const result = api.pedersenPlookupCommit([new Fr(4n), new Fr(8n)]);
-    expect(result).toEqual(new Fr(21568810706345846819294487214368613840251909831689369685420108292337497444070n));
-  });
-
-  it('pedersenBufferToField', () => {
-    const result = api.pedersenBufferToField(Buffer.from('Hello world! I am a buffer to be converted to a field!'));
-    expect(result).toEqual(new Fr(4923399520610513632896240312051201308554838580477778325691012985962614653619n));
-  });
-
-  it('pedersenHashPair', () => {
-    const result = api.pedersenHashPair(new Fr(4n), new Fr(8n));
-    expect(result).toEqual(new Fr(7508407170365331152493586290597472346478280823936748458450026785528968221772n));
-  });
-
-  it('pedersenHashMultiple', () => {
-    const result = api.pedersenHashMultiple([new Fr(4n), new Fr(8n), new Fr(12n)]);
-    expect(result).toEqual(new Fr(641613987782189905475142047603559162464012327378197326488471789040703504911n));
-  });
-
-  it('pedersenHashMultipleWithHashIndex', () => {
-    const result = api.pedersenHashMultipleWithHashIndex([new Fr(4n), new Fr(8n)], 7);
-    expect(result).toEqual(new Fr(14181105996307540196932058280391669339364159586581375348016341320932872505408n));
-  });
-
-  it('pedersenHashToTree', () => {
-    const result = api.pedersenHashToTree([new Fr(4n), new Fr(8n), new Fr(12n), new Fr(16n)]);
-    expect(result).toEqual([
-      new Fr(4n),
-      new Fr(8n),
-      new Fr(12n),
-      new Fr(16n),
-      new Fr(7508407170365331152493586290597472346478280823936748458450026785528968221772n),
-      new Fr(61370238324203854110612958249832030753990119715269709182131929073387209477n),
-      new Fr(7696240979753031171651958947943309270095593128155855154123615677953596407768n),
-    ]);
-  });
-});

package/src/barretenberg_api/schnorr.test.ts

@@ -1,169 +0,0 @@
-import { TextEncoder } from 'util';
-import { Buffer128, Buffer32, Fr, Point } from '../types/index.js';
-import { BarretenbergApiSync } from './index.js';
-import { newBarretenbergApiSync } from '../factory/index.js';
-
-describe('schnorr', () => {
-  const msg = Buffer.from(new TextEncoder().encode('The quick brown dog jumped over the lazy fox.'));
-  let api: BarretenbergApiSync;
-
-  beforeAll(async () => {
-    api = await newBarretenbergApiSync();
-    api.pedersenInit();
-  });
-
-  afterAll(async () => {
-    await api.destroy();
-  });
-
-  it('should verify signature', () => {
-    const pk = Fr.fromBuffer(
-      new Uint8Array([
-        0x0b, 0x9b, 0x3a, 0xde, 0xe6, 0xb3, 0xd8, 0x1b, 0x28, 0xa0, 0x88, 0x6b, 0x2a, 0x84, 0x15, 0xc7, 0xda, 0x31,
-        0x29, 0x1a, 0x5e, 0x96, 0xbb, 0x7a, 0x56, 0x63, 0x9e, 0x17, 0x7d, 0x30, 0x1b, 0xeb,
-      ]),
-    );
-    const pubKey = api.schnorrComputePublicKey(pk);
-    const [s, e] = api.schnorrConstructSignature(msg, pk);
-    const verified = api.schnorrVerifySignature(msg, pubKey, s, e);
-
-    expect(verified).toBe(true);
-  });
-
-  it('public key negation should work', () => {
-    const publicKeyStr =
-      '0x164f01b1011a1b292217acf53eef4d74f625f6e9bd5edfdb74c56fd81aafeebb21912735f9266a3719f61c1eb747ddee0cac9917f5c807485d356709b529b62c';
-    const publicKey = Point.fromString(publicKeyStr);
-    // hardcoded expected negated public key
-    const expectedInvertedStr =
-      '0x164f01b1011a1b292217acf53eef4d74f625f6e9bd5edfdb74c56fd81aafeebb0ed3273ce80b35f29e5a2997ca397a6f1b874f3083f16948e6ac8e8a3ad649d5';
-    const expectedInverted = Point.fromString(expectedInvertedStr);
-
-    // negate - should match expected negated key
-    const negatedPublicKey = api.schnorrNegatePublicKey(publicKey);
-    expect(negatedPublicKey.equals(expectedInverted)).toEqual(true);
-    // negate again - should be original public key now
-    expect(api.schnorrNegatePublicKey(negatedPublicKey).equals(publicKey)).toEqual(true);
-  });
-
-  it('should create + verify multi signature', () => {
-    // set up multisig accounts
-    const numSigners = 7;
-    const pks = [...Array(numSigners)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
-
-    // round one
-    const roundOnePublicOutputs: Buffer128[] = [];
-    const roundOnePrivateOutputs: Buffer128[] = [];
-    for (let i = 0; i < numSigners; ++i) {
-      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
-      roundOnePublicOutputs.push(publicOutput);
-      roundOnePrivateOutputs.push(privateOutput);
-    }
-
-    // round two
-    const roundTwoOutputs = pks.map(
-      (pk, i) =>
-        api.schnorrMultisigConstructSignatureRound2(
-          msg,
-          pk,
-          roundOnePrivateOutputs[i],
-          pubKeys,
-          roundOnePublicOutputs,
-        )[0],
-    );
-
-    // generate signature
-    const [s, e] = api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, roundTwoOutputs)!;
-    const [combinedKey] = api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
-    expect(combinedKey).not.toEqual(Buffer.alloc(64));
-    const verified = api.schnorrVerifySignature(msg, combinedKey, s, e);
-    expect(verified).toBe(true);
-  });
-
-  it('should identify invalid multi signature', () => {
-    const pks = [...Array(3)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
-    const [combinedKey] = api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys);
-
-    const verified = api.schnorrVerifySignature(msg, combinedKey, Buffer32.random(), Buffer32.random());
-    expect(verified).toBe(false);
-  });
-
-  it('should not construct invalid multi signature', () => {
-    // set up multisig accounts
-    const numSigners = 7;
-    const pks = [...Array(numSigners)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
-
-    // round one
-    const roundOnePublicOutputs: Buffer128[] = [];
-    const roundOnePrivateOutputs: Buffer128[] = [];
-    for (let i = 0; i < numSigners; ++i) {
-      const [publicOutput, privateOutput] = api.schnorrMultisigConstructSignatureRound1();
-      roundOnePublicOutputs.push(publicOutput);
-      roundOnePrivateOutputs.push(privateOutput);
-    }
-
-    // round two
-    const roundTwoOutputs = pks.map(
-      (pk, i) =>
-        api.schnorrMultisigConstructSignatureRound2(
-          msg,
-          pk,
-          roundOnePrivateOutputs[i],
-          pubKeys,
-          roundOnePublicOutputs,
-        )[0],
-    );
-
-    // wrong number of data
-    {
-      expect(
-        api.schnorrMultisigCombineSignatures(
-          msg,
-          pubKeys.slice(0, -1),
-          roundOnePublicOutputs.slice(0, -1),
-          roundTwoOutputs.slice(0, -1),
-        )[2],
-      ).toBe(false);
-    }
-
-    // invalid round two output
-    {
-      const invalidOutputs = [...roundTwoOutputs];
-      invalidOutputs[1] = api.schnorrMultisigConstructSignatureRound2(
-        msg,
-        pks[2], // <- Wrong private key.
-        roundOnePrivateOutputs[1],
-        pubKeys,
-        roundOnePublicOutputs,
-      )[0];
-      expect(api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs)[2]).toBe(false);
-    }
-
-    // contains duplicates
-    {
-      const invalidOutputs = [...roundTwoOutputs];
-      invalidOutputs[1] = roundTwoOutputs[2];
-      expect(api.schnorrMultisigCombineSignatures(msg, pubKeys, roundOnePublicOutputs, invalidOutputs)[2]).toBe(false);
-    }
-  });
-
-  it('should not create combined key from public keys containing invalid key', () => {
-    const pks = [...Array(5)].map(() => Fr.random());
-    const pubKeys = pks.map(pk => api.schnorrMultisigCreateMultisigPublicKey(pk));
-
-    // not a valid point
-    {
-      pubKeys[1] = new Buffer128(Buffer.alloc(128));
-      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
-    }
-
-    // contains duplicates
-    {
-      pubKeys[1] = pubKeys[2];
-      expect(api.schnorrMultisigValidateAndCombineSignerPubkeys(pubKeys)[1]).toBe(false);
-    }
-  });
-});

package/src/barretenberg_binder/heap_allocator.ts

@@ -1,62 +0,0 @@
-import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
-import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
-import { asyncMap } from '../async_map/index.js';
-
-/**
- * Keeps track of heap allocations so they can be easily freed.
- * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
- * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
- * Heap allocations will be created for input/output args that don't fit into the scratch space.
- * Input and output args can use the same scratch space as it's assume all input reads will be performed before any
- * output writes are performed.
- */
-export class HeapAllocator {
-  private allocs: number[] = [];
-  private inScratchRemaining = 1024;
-  private outScratchRemaining = 1024;
-
-  constructor(private wasm: BarretenbergWasm | BarretenbergWasmWorker) {}
-
-  async copyToMemory(bufferable: Bufferable[]) {
-    return await asyncMap(bufferable.map(serializeBufferable), async buf => {
-      if (buf.length <= this.inScratchRemaining) {
-        const ptr = (this.inScratchRemaining -= buf.length);
-        await this.wasm.writeMemory(ptr, buf);
-        return ptr;
-      } else {
-        const ptr = await this.wasm.call('bbmalloc', buf.length);
-        await this.wasm.writeMemory(ptr, buf);
-        this.allocs.push(ptr);
-        return ptr;
-      }
-    });
-  }
-
-  async getOutputPtrs(objs: OutputType[]) {
-    return await asyncMap(objs, async obj => {
-      // If the obj is variable length, we need a 4 byte ptr to write the serialized data address to.
-      // WARNING: 4 only works with WASM as it has 32 bit memory.
-      const size = obj.SIZE_IN_BYTES || 4;
-
-      if (size <= this.outScratchRemaining) {
-        return (this.outScratchRemaining -= size);
-      } else {
-        const ptr = await this.wasm.call('bbmalloc', size);
-        this.allocs.push(ptr);
-        return ptr;
-      }
-    });
-  }
-
-  addOutputPtr(ptr: number) {
-    if (ptr >= 1024) {
-      this.allocs.push(ptr);
-    }
-  }
-
-  async freeAll() {
-    for (const ptr of this.allocs) {
-      await this.wasm.call('bbfree', ptr);
-    }
-  }
-}

package/src/barretenberg_binder/heap_allocator_sync.ts

@@ -1,61 +0,0 @@
-import { Bufferable, serializeBufferable, OutputType } from '../serialize/index.js';
-import { BarretenbergWasm } from '../barretenberg_wasm/barretenberg_wasm.js';
-
-/**
- * Keeps track of heap allocations so they can be easily freed.
- * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
- * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
- * Heap allocations will be created for input/output args that don't fit into the scratch space.
- * Input and output args can use the same scratch space as it's assume all input reads will be performed before any
- * output writes are performed.
- */
-export class HeapAllocatorSync {
-  private allocs: number[] = [];
-  private inScratchRemaining = 1024;
-  private outScratchRemaining = 1024;
-
-  constructor(private wasm: BarretenbergWasm) {}
-
-  copyToMemory(bufferable: Bufferable[]) {
-    return bufferable.map(serializeBufferable).map(buf => {
-      if (buf.length <= this.inScratchRemaining) {
-        const ptr = (this.inScratchRemaining -= buf.length);
-        this.wasm.writeMemory(ptr, buf);
-        return ptr;
-      } else {
-        const ptr = this.wasm.call('bbmalloc', buf.length);
-        this.wasm.writeMemory(ptr, buf);
-        this.allocs.push(ptr);
-        return ptr;
-      }
-    });
-  }
-
-  getOutputPtrs(objs: OutputType[]) {
-    return objs.map(obj => {
-      // If the obj is variable length, we need a 4 byte ptr to write the serialized data address to.
-      // WARNING: 4 only works with WASM as it has 32 bit memory.
-      const size = obj.SIZE_IN_BYTES || 4;
-
-      if (size <= this.outScratchRemaining) {
-        return (this.outScratchRemaining -= size);
-      } else {
-        const ptr = this.wasm.call('bbmalloc', size);
-        this.allocs.push(ptr);
-        return ptr;
-      }
-    });
-  }
-
-  addOutputPtr(ptr: number) {
-    if (ptr >= 1024) {
-      this.allocs.push(ptr);
-    }
-  }
-
-  freeAll() {
-    for (const ptr of this.allocs) {
-      this.wasm.call('bbfree', ptr);
-    }
-  }
-}

package/src/barretenberg_binder/index.ts

@@ -1,76 +0,0 @@
-import { BarretenbergWasm, BarretenbergWasmWorker } from '../barretenberg_wasm/barretenberg_wasm.js';
-import { HeapAllocator } from './heap_allocator.js';
-import { Bufferable, OutputType } from '../serialize/index.js';
-import { asyncMap } from '../async_map/index.js';
-import { HeapAllocatorSync } from './heap_allocator_sync.js';
-
-/**
- * Calls a WASM export function, handles allocating/freeing of memory, and serializing/deserializing to types.
- *
- * Notes on function binding ABI:
- * All functions can have an arbitrary number of input and output args.
- * All arguments must be pointers.
- * Input args are determined by being const or pointer to const.
- * Output args must come after input args.
- * All input data is big-endian.
- * All output data is big-endian, except output heap alloc pointers.
- * As integer types are converted to/from big-endian form, we shouldn't have to worry about memory alignment. (SURE?)
- * All functions should return void.
- * This binding function is responsible for allocating argument memory (including output memory).
- * Variable length output args are allocated on the heap, and the resulting pointer is written to the output arg ptr,
- * hence the above statement remains true.
- * Binding will free any variable length output args that were allocated on the heap.
- */
-export class BarretenbergBinder {
-  constructor(public wasm: BarretenbergWasm | BarretenbergWasmWorker) {}
-
-  async callWasmExport(funcName: string, inArgs: Bufferable[], outTypes: OutputType[]) {
-    const alloc = new HeapAllocator(this.wasm);
-    const inPtrs = await alloc.copyToMemory(inArgs);
-    const outPtrs = await alloc.getOutputPtrs(outTypes);
-    await this.wasm.call(funcName, ...inPtrs, ...outPtrs);
-    const outArgs = this.deserializeOutputArgs(outTypes, outPtrs, alloc);
-    await alloc.freeAll();
-    return outArgs;
-  }
-
-  private deserializeOutputArgs(outTypes: OutputType[], outPtrs: number[], alloc: HeapAllocator) {
-    return asyncMap(outTypes, async (t, i) => {
-      if (t.SIZE_IN_BYTES) {
-        const slice = await this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + t.SIZE_IN_BYTES);
-        return t.fromBuffer(slice);
-      }
-      const slice = await this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
-      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
-      alloc.addOutputPtr(ptr);
-      return t.fromBuffer(await this.wasm.getMemorySlice(ptr));
-    });
-  }
-}
-
-export class BarretenbergBinderSync {
-  constructor(public wasm: BarretenbergWasm) {}
-
-  callWasmExport(funcName: string, inArgs: Bufferable[], outTypes: OutputType[]) {
-    const alloc = new HeapAllocatorSync(this.wasm);
-    const inPtrs = alloc.copyToMemory(inArgs);
-    const outPtrs = alloc.getOutputPtrs(outTypes);
-    this.wasm.call(funcName, ...inPtrs, ...outPtrs);
-    const outArgs = this.deserializeOutputArgs(outTypes, outPtrs, alloc);
-    alloc.freeAll();
-    return outArgs;
-  }
-
-  private deserializeOutputArgs(outTypes: OutputType[], outPtrs: number[], alloc: HeapAllocatorSync) {
-    return outTypes.map((t, i) => {
-      if (t.SIZE_IN_BYTES) {
-        const slice = this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + t.SIZE_IN_BYTES);
-        return t.fromBuffer(slice);
-      }
-      const slice = this.wasm.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
-      const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
-      alloc.addOutputPtr(ptr);
-      return t.fromBuffer(this.wasm.getMemorySlice(ptr));
-    });
-  }
-}

package/src/barretenberg_wasm/barretenberg_wasm.test.ts

@@ -1,52 +0,0 @@
-import { type Worker } from 'worker_threads';
-import { BarretenbergWasm, BarretenbergWasmWorker } from './barretenberg_wasm.js';
-
-describe('barretenberg wasm', () => {
-  let wasm!: BarretenbergWasm;
-
-  beforeAll(async () => {
-    wasm = await BarretenbergWasm.new();
-  });
-
-  afterAll(async () => {
-    await wasm.destroy();
-  });
-
-  it('should new malloc, transfer and slice mem', () => {
-    const length = 1024;
-    const ptr = wasm.call('bbmalloc', length);
-    const buf = Buffer.alloc(length, 128);
-    wasm.writeMemory(ptr, buf);
-    const result = Buffer.from(wasm.getMemorySlice(ptr, ptr + length));
-    wasm.call('bbfree', ptr);
-    expect(result).toStrictEqual(buf);
-  });
-
-  it('test abort', () => {
-    expect(() => wasm.call('test_abort')).toThrow();
-  });
-});
-
-describe('barretenberg wasm worker', () => {
-  let worker!: Worker;
-  let wasm!: BarretenbergWasmWorker;
-
-  beforeAll(async () => {
-    ({ wasm, worker } = await BarretenbergWasm.newWorker(2));
-  }, 20000);
-
-  afterAll(async () => {
-    await wasm.destroy();
-    await worker.terminate();
-  });
-
-  it('should new malloc, transfer and slice mem', async () => {
-    const length = 1024;
-    const ptr = await wasm.call('bbmalloc', length);
-    const buf = Buffer.alloc(length, 128);
-    await wasm.writeMemory(ptr, buf);
-    const result = Buffer.from(await wasm.getMemorySlice(ptr, ptr + length));
-    await wasm.call('bbfree', ptr);
-    expect(result).toStrictEqual(buf);
-  });
-});