@aztec/foundation 0.7.10 → 0.8.4

package/src/fields/coordinate.test.ts

@@ -1,26 +0,0 @@
-import { toBufferBE } from '../bigint-buffer/index.js';
-import { Coordinate } from './coordinate.js';
-import { Fr } from './fields.js';
-
-const MAX_256_VALUE = 2n ** 256n - 1n;
-
-describe('coordinate', () => {
-  it('stores 256 bits in fields', () => {
-    const max256Value = toBufferBE(MAX_256_VALUE, 32);
-    const coordinate = Coordinate.fromBuffer(max256Value);
-    // this returns a buffer containing the bit pattern split across 2 fields
-    expect(coordinate.toFieldsBuffer()).toEqual(
-      Buffer.concat([Buffer.alloc(1, 0), Buffer.alloc(31, 0xff), Buffer.alloc(31, 0), Buffer.alloc(1, 0xff)]),
-    );
-    // this returns the value in a single 32 byte buffer
-    expect(coordinate.toBuffer()).toEqual(max256Value);
-    // this returns the value as a big int
-    expect(coordinate.toBigInt()).toBe(MAX_256_VALUE);
-  });
-
-  it('can be constructed from a field', () => {
-    const field = Fr.random();
-    const coordinate = Coordinate.fromField(field);
-    expect(coordinate.toBuffer()).toEqual(field.toBuffer());
-  });
-});

package/src/fields/grumpkin_scalar.test.ts

@@ -1,55 +0,0 @@
-import { GrumpkinScalar } from './grumpkin_scalar.js';
-
-describe('GrumpkinScalar Serialization', () => {
-  // Test case for GrumpkinScalar.fromHighLow
-  it('fromHighLow should serialize and deserialize correctly', () => {
-    const original = GrumpkinScalar.random();
-    const high = original.high;
-    const low = original.low;
-
-    const deserialized = GrumpkinScalar.fromHighLow(high, low);
-
-    // Check if the deserialized instance is equal to the original
-    expect(deserialized).toEqual(original);
-  });
-
-  // Test case for GrumpkinScalar.fromBuffer
-  it('fromBuffer should serialize and deserialize correctly', () => {
-    const original = GrumpkinScalar.random();
-    const buffer = original.toBuffer();
-    const deserialized = GrumpkinScalar.fromBuffer(buffer);
-
-    // Check if the deserialized instance is equal to the original
-    expect(deserialized).toEqual(original);
-  });
-
-  // Test case for GrumpkinScalar.fromString
-  it('fromString should serialize and deserialize correctly', () => {
-    const original = GrumpkinScalar.random();
-    const hexString = original.toString();
-    const deserialized = GrumpkinScalar.fromString(hexString);
-
-    // Check if the deserialized instance is equal to the original
-    expect(deserialized).toEqual(original);
-  });
-
-  // Test case for GrumpkinScalar.toBuffer
-  it('toBuffer should serialize and deserialize correctly', () => {
-    const original = GrumpkinScalar.random();
-    const buffer = original.toBuffer();
-    const deserialized = GrumpkinScalar.fromBuffer(buffer);
-
-    // Check if the deserialized instance is equal to the original
-    expect(deserialized).toEqual(original);
-  });
-
-  // Test case for GrumpkinScalar.toString
-  it('toString should serialize and deserialize correctly', () => {
-    const original = GrumpkinScalar.random();
-    const hexString = original.toString();
-    const deserialized = GrumpkinScalar.fromString(hexString);
-
-    // Check if the deserialized instance is equal to the original
-    expect(deserialized).toEqual(original);
-  });
-});

package/src/json-rpc/client/json_rpc_client.test.ts

@@ -1,21 +0,0 @@
-import request from 'supertest';
-
-import { TestNote, TestState } from '../fixtures/test_state.js';
-import { JsonRpcServer } from '../server/index.js';
-import { createJsonRpcClient } from './json_rpc_client.js';
-
-test('test an RPC function over client', async () => {
-  const mockFetch = async (host: string, method: string, body: any) => {
-    const server = new JsonRpcServer(new TestState([new TestNote('a'), new TestNote('b')]), { TestNote }, {}, true);
-    const result = await request(server.getApp().callback()).post(`/${method}`).send(body);
-    return JSON.parse(result.text);
-  };
-  const client = createJsonRpcClient<TestState>('', { TestNote }, {}, true, mockFetch);
-  const result = await client.addNotes([new TestNote('c')]);
-  expect(result[0]).toBeInstanceOf(TestNote);
-  expect(result[1]).toBeInstanceOf(TestNote);
-  expect(result[2]).toBeInstanceOf(TestNote);
-  expect(result[0].toString()).toBe('a');
-  expect(result[1].toString()).toBe('b');
-  expect(result[2].toString()).toBe('c');
-});

package/src/json-rpc/convert.test.ts

@@ -1,77 +0,0 @@
-import { Buffer } from 'buffer';
-
-import { ClassConverter } from './class_converter.js';
-import { convertBigintsInObj, convertFromJsonObj, convertToJsonObj } from './convert.js';
-import { ToStringClass as ToStringClassA } from './fixtures/class_a.js';
-import { ToStringClass as ToStringClassB } from './fixtures/class_b.js';
-import { TestNote } from './fixtures/test_state.js';
-
-const TEST_BASE64 = 'YmFzZTY0IGRlY29kZXI=';
-test('test an RPC function over client', () => {
-  const cc = new ClassConverter({ TestNote });
-  const buffer = Buffer.from(TEST_BASE64, 'base64');
-  expect(convertFromJsonObj(cc, convertToJsonObj(cc, buffer)).toString('base64')).toBe(TEST_BASE64);
-  const note = new TestNote('1');
-  expect(convertFromJsonObj(cc, convertToJsonObj(cc, note))).toBeInstanceOf(TestNote);
-  expect(convertFromJsonObj(cc, convertToJsonObj(cc, note)).toString()).toBe('1');
-});
-
-test('converts a bigint', () => {
-  expect(convertBigintsInObj(10n)).toEqual({ type: 'bigint', data: '10' });
-  expect(convertBigintsInObj({ value: 10n })).toEqual({ value: { type: 'bigint', data: '10' } });
-  expect(convertBigintsInObj([10n])).toEqual([{ type: 'bigint', data: '10' }]);
-});
-
-test('does not convert a string', () => {
-  expect(convertBigintsInObj('hello')).toEqual('hello');
-  expect(convertBigintsInObj({ msg: 'hello' })).toEqual({ msg: 'hello' });
-});
-
-test('converts a registered class', () => {
-  const cc = new ClassConverter({ ToStringClass: ToStringClassA });
-  const obj = { content: new ToStringClassA('a', 'b') };
-  const serialised = convertToJsonObj(cc, obj);
-  const deserialised = convertFromJsonObj(cc, serialised) as { content: ToStringClassA };
-  expect(deserialised.content).toBeInstanceOf(ToStringClassA);
-  expect(deserialised.content.x).toEqual('a');
-  expect(deserialised.content.y).toEqual('b');
-});
-
-test('converts a class by name in the event of duplicate modules being loaded', () => {
-  expect(ToStringClassA.prototype.constructor.name).toEqual('ToStringClass');
-  expect(ToStringClassB.prototype.constructor.name).toEqual('ToStringClass');
-  const cc = new ClassConverter({ ToStringClass: ToStringClassA });
-  const obj = { content: new ToStringClassB('a', 'b') };
-  const serialised = convertToJsonObj(cc, obj);
-  const deserialised = convertFromJsonObj(cc, serialised) as { content: ToStringClassA };
-  expect(deserialised.content).toBeInstanceOf(ToStringClassA);
-  expect(deserialised.content.x).toEqual('a');
-  expect(deserialised.content.y).toEqual('b');
-});
-
-test('converts a class by constructor instead of name in the event of minified bundle', () => {
-  const cc = new ClassConverter({ NotMinifiedToStringClassName: ToStringClassA });
-  const obj = { content: new ToStringClassA('a', 'b') };
-  const serialised = convertToJsonObj(cc, obj);
-  const deserialised = convertFromJsonObj(cc, serialised) as { content: ToStringClassA };
-  expect(deserialised.content).toBeInstanceOf(ToStringClassA);
-  expect(deserialised.content.x).toEqual('a');
-  expect(deserialised.content.y).toEqual('b');
-});
-
-test('converts a plain object', () => {
-  const obj = { a: 10, b: [20, 30], c: 'foo' };
-  const cc = new ClassConverter();
-  expect(convertFromJsonObj(cc, convertToJsonObj(cc, obj))).toEqual(obj);
-});
-
-test('refuses to convert to json an unknown class', () => {
-  const cc = new ClassConverter();
-  expect(() => convertToJsonObj(cc, { content: new ToStringClassA('a', 'b') })).toThrowError(/not registered/);
-});
-
-test('refuses to convert from json an unknown class', () => {
-  const cc = new ClassConverter({ ToStringClass: ToStringClassA });
-  const serialised = convertToJsonObj(cc, { content: new ToStringClassA('a', 'b') });
-  expect(() => convertFromJsonObj(new ClassConverter(), serialised)).toThrowError(/not registered/);
-});

package/src/json-rpc/server/json_rpc_server.test.ts

@@ -1,24 +0,0 @@
-import request from 'supertest';
-
-import { TestNote, TestState } from '../fixtures/test_state.js';
-import { JsonRpcServer } from './json_rpc_server.js';
-
-test('test an RPC function with a primitive parameter', async () => {
-  const server = new JsonRpcServer(new TestState([new TestNote('a'), new TestNote('b')]), { TestNote }, {}, true);
-  const response = await request(server.getApp().callback())
-    .post('/getNote')
-    .send({ params: [0] });
-  expect(response.status).toBe(200);
-  expect(response.text).toBe(JSON.stringify({ result: { type: 'TestNote', data: 'a' } }));
-});
-
-test('test an RPC function with an array of classes', async () => {
-  const server = new JsonRpcServer(new TestState([]), { TestNote }, {}, true);
-  const response = await request(server.getApp().callback())
-    .post('/addNotes')
-    .send({
-      params: [[{ data: 'a' }, { data: 'b' }, { data: 'c' }]],
-    });
-  expect(response.status).toBe(200);
-  expect(response.text).toBe(JSON.stringify({ result: [{ data: 'a' }, { data: 'b' }, { data: 'c' }] }));
-});

package/src/log/log_history.test.ts

@@ -1,88 +0,0 @@
-import { jest } from '@jest/globals';
-
-import { createDebugOnlyLogger, enableLogs } from './debug.js';
-import { LogHistory } from './log_history.js';
-
-jest.useFakeTimers({ doNotFake: ['performance'] });
-
-describe('log history', () => {
-  let debug: (...any: any) => void;
-  let logHistory: LogHistory;
-  const timestemp = new Date().toISOString();
-  const name = 'test:a';
-
-  beforeEach(() => {
-    debug = createDebugOnlyLogger(name);
-    enableLogs(name);
-    logHistory = new LogHistory();
-  });
-
-  it('keeps debug logs', () => {
-    logHistory.enable();
-    expect(logHistory.getLogs()).toEqual([]);
-    debug('0');
-    debug('1', 2);
-    debug('2', { key: ['value'] }, Buffer.alloc(2));
-    expect(logHistory.getLogs()).toEqual([
-      [timestemp, name, '0'],
-      [timestemp, name, '1', 2],
-      [timestemp, name, '2', { key: ['value'] }, Buffer.alloc(2)],
-    ]);
-  });
-
-  it('does not keep logs if not enabled', () => {
-    debug('0');
-    debug('1', 2);
-    expect(logHistory.getLogs()).toEqual([]);
-  });
-
-  it('returns last n logs', () => {
-    logHistory.enable();
-    expect(logHistory.getLogs()).toEqual([]);
-    debug('0');
-    debug('1');
-    debug('2');
-    debug('3');
-    debug('4');
-    expect(logHistory.getLogs(2)).toEqual([
-      [timestemp, name, '3'],
-      [timestemp, name, '4'],
-    ]);
-  });
-
-  it('only keeps logs with enabled namespace', () => {
-    logHistory.enable();
-    const name2 = 'test:b';
-    const debug2 = createDebugOnlyLogger(name2);
-    debug('0');
-    debug2('zero');
-    expect(logHistory.getLogs()).toEqual([[timestemp, name, '0']]);
-
-    enableLogs(`${name},${name2}`);
-    debug('1', 2);
-    debug2('one', 3);
-    expect(logHistory.getLogs()).toEqual([
-      [timestemp, name, '0'],
-      [timestemp, name, '1', 2],
-      [timestemp, name2, 'one', 3],
-    ]);
-  });
-
-  it('clears all logs', () => {
-    logHistory.enable();
-    debug('0');
-    debug('1');
-    debug('2');
-    logHistory.clear();
-    expect(logHistory.getLogs()).toEqual([]);
-  });
-
-  it('clears first n logs', () => {
-    logHistory.enable();
-    debug('0');
-    debug('1');
-    debug('2');
-    logHistory.clear(2);
-    expect(logHistory.getLogs()).toEqual([[timestemp, name, '2']]);
-  });
-});

package/src/mutex/mutex.test.ts

@@ -1,76 +0,0 @@
-import { jest } from '@jest/globals';
-
-import { Mutex } from './index.js';
-import { MutexDatabase } from './mutex_database.js';
-
-/**
- * Sleep function for introducing a delay in the execution of code.
- * Returns a Promise that resolves after the specified number of milliseconds.
- *
- * @param ms - The number of milliseconds to pause the execution.
- * @returns A Promise that resolves after the specified delay.
- */
-export function sleep(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Type that transforms the properties of an object into jest.Mock instances,
- * allowing for easy mocking and testing of functions and methods.
- */
-type Mockify<T> = {
-  [P in keyof T]: jest.Mock;
-};
-
-describe('mutex', () => {
-  let db: Mockify<MutexDatabase>;
-  let mutex: Mutex;
-  const mutexName = 'test-mutex';
-  const timeout = 500;
-  const tryLockInterval = 100;
-  const pingInterval = 200;
-
-  beforeEach(() => {
-    db = {
-      acquireLock: jest.fn().mockImplementation(() => false),
-      extendLock: jest.fn().mockImplementation(() => {
-        (db.acquireLock.mockResolvedValueOnce as any)(false);
-      }),
-      releaseLock: jest.fn().mockImplementation(() => {
-        (db.acquireLock.mockResolvedValueOnce as any)(true);
-      }),
-    } as any;
-    (db.acquireLock.mockResolvedValueOnce as any)(true);
-
-    mutex = new Mutex(db as MutexDatabase, mutexName, timeout, tryLockInterval, pingInterval);
-  });
-
-  it('cannot lock if locked', async () => {
-    const result: string[] = [];
-    const fn1 = async (runAfterLocked: () => Promise<void>) => {
-      await mutex.lock();
-      const pm = runAfterLocked();
-      await sleep(500);
-      result.push('fn1');
-      await mutex.unlock();
-      return pm;
-    };
-
-    const fn2 = async () => {
-      await mutex.lock();
-      result.push('fn2');
-      await mutex.unlock();
-    };
-
-    await fn1(fn2);
-    expect(result).toEqual(['fn1', 'fn2']);
-  });
-
-  it('automatically extend the expiry time of the lock', async () => {
-    await mutex.lock();
-    await sleep(1000);
-    await mutex.unlock();
-
-    expect(db.extendLock).toHaveBeenCalledWith(mutexName, timeout);
-  });
-});

package/src/serialize/buffer_reader.test.ts

@@ -1,176 +0,0 @@
-import { jest } from '@jest/globals';
-
-import { randomBytes } from '../crypto/index.js';
-import { Fq, Fr } from '../fields/fields.js';
-import { BufferReader } from './buffer_reader.js';
-import { serializeBufferArrayToVector } from './free_funcs.js';
-
-const ARRAY = Array.from(Array(32)).map((_, idx) => (idx % 2 === 0 ? 0 : 1));
-const BUFFER = Buffer.from(ARRAY);
-const NUMBER = 65537;
-const sizes = [16, 48, 32];
-
-describe('buffer reader', () => {
-  let bufferReader: BufferReader;
-
-  beforeEach(() => {
-    bufferReader = new BufferReader(BUFFER);
-  });
-
-  describe('readNumber', () => {
-    it('should return number', () => {
-      expect(bufferReader.readNumber()).toBe(NUMBER);
-    });
-  });
-
-  describe('readBoolean', () => {
-    it('should read true when 1 and false when 0', () => {
-      ARRAY.forEach(element => {
-        if (element !== 0) {
-          expect(bufferReader.readBoolean()).toBe(true);
-        } else {
-          expect(bufferReader.readBoolean()).toBe(false);
-        }
-      });
-    });
-  });
-
-  describe('readBytes', () => {
-    it('should read buffer by slices', () => {
-      expect(bufferReader.readBytes(2)).toEqual(Buffer.from(ARRAY.slice(0, 2)));
-      expect(bufferReader.readBytes(3)).toEqual(Buffer.from(ARRAY.slice(2, 5)));
-    });
-  });
-
-  describe('readFr', () => {
-    it('should get Fr from buffer', () => {
-      expect(bufferReader.readFr()).toEqual(Fr.fromBuffer(BUFFER));
-    });
-  });
-
-  describe('readFq', () => {
-    it('should get Fq from buffer', () => {
-      expect(bufferReader.readFq()).toEqual(Fq.fromBuffer(BUFFER));
-    });
-  });
-
-  describe('readNumberVector', () => {
-    let vectorBufferReader: BufferReader;
-
-    beforeEach(() => {
-      const uintArr = [7, 13, 16];
-      const uintBufArr = uintArr.map(num => {
-        const uintBuf = Buffer.alloc(4);
-        uintBuf.writeUInt32BE(num, 0);
-        return uintBuf;
-      });
-      const uintArrVec = serializeBufferArrayToVector(uintBufArr);
-      vectorBufferReader = new BufferReader(uintArrVec);
-    });
-
-    it('should read number vector', () => {
-      expect(vectorBufferReader.readNumberVector()).toEqual([7, 13, 16]);
-    });
-  });
-
-  describe('readVector', () => {
-    it('should read vector and generate result array', () => {
-      const fn = jest.fn();
-      let i = -1;
-      const result = bufferReader.readVector({
-        fromBuffer: () => {
-          fn();
-          i++;
-          return i;
-        },
-      });
-      expect(result.length).toBe(NUMBER);
-      expect(result).toEqual(Array.from(Array(NUMBER).keys()));
-      expect(fn).toHaveBeenCalledTimes(NUMBER);
-    });
-  });
-
-  describe('readArray', () => {
-    it('should read array from buffer', () => {
-      const fn = jest.fn();
-      let i = -1;
-      expect(
-        bufferReader.readArray(10, {
-          fromBuffer: () => {
-            fn();
-            i++;
-            return i;
-          },
-        }),
-      ).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-    });
-  });
-
-  describe('readBufferArray', () => {
-    it('should read variable length array from buffer', () => {
-      // Testing `readBufferArray` with a buffer that ONLY contains the data that will be read.
-      // No `size` variable is passed in this case.
-      const bufferArray: Buffer[] = [];
-      let buf = Buffer.alloc(0);
-      for (const size of sizes) {
-        const sizeBuf = Buffer.alloc(4);
-        sizeBuf.writeUInt32BE(size);
-        const bytes = randomBytes(size);
-        const ranBuf = Buffer.concat([sizeBuf, bytes]);
-        bufferArray.push(bytes);
-        buf = Buffer.concat([buf, ranBuf]);
-      }
-      const reader = BufferReader.asReader(buf);
-      const res = reader.readBufferArray();
-      expect(res).toEqual(bufferArray);
-    });
-
-    it('should read variable length array from buffer with other contents', () => {
-      // testing `readBufferArray` with a buffer that includes some other data before and after the data that will be read.
-      // The `size` variable needs to be passed in this case.
-      const bufferArray: Buffer[] = [];
-      const prefixBytes = randomBytes(32);
-      const postfixBytes = randomBytes(16);
-      let bufLen = 0;
-      let buf = Buffer.alloc(32, prefixBytes);
-      for (const size of sizes) {
-        const sizeBuf = Buffer.alloc(4);
-        sizeBuf.writeUInt32BE(size);
-
-        const bytes = randomBytes(size);
-        const ranBuf = Buffer.concat([sizeBuf, bytes]);
-        buf = Buffer.concat([buf, ranBuf]);
-
-        bufferArray.push(bytes);
-        bufLen += ranBuf.length;
-      }
-      buf = Buffer.concat([buf, postfixBytes]);
-      const reader = BufferReader.asReader(buf);
-      const preRes = reader.readBytes(prefixBytes.length);
-      expect(preRes).toEqual(prefixBytes);
-      expect(reader.readBufferArray(bufLen)).toEqual(bufferArray);
-      expect(reader.readBytes(postfixBytes.length)).toEqual(postfixBytes);
-    });
-  });
-
-  describe('readObject', () => {
-    it('should read object from buffer', () => {
-      const fn = jest.fn();
-      const object = bufferReader.readObject({
-        fromBuffer: (reader: BufferReader) => {
-          fn();
-          return { value: 'test-string', buffer: reader };
-        },
-      });
-      expect(object.value).toEqual('test-string');
-      expect(object.buffer).toEqual(bufferReader);
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('peekBytes', () => {
-    it('should return bytes from buffer', () => {
-      expect(bufferReader.peekBytes(10)).toEqual(Buffer.from(ARRAY.slice(0, 10)));
-    });
-  });
-});

package/src/serialize/serialize.test.ts

@@ -1,89 +0,0 @@
-import { randomBytes } from '../crypto/index.js';
-import { Fr } from '../fields/fields.js';
-import {
-  deserializeArrayFromVector,
-  deserializeBufferFromVector,
-  deserializeField,
-  deserializeUInt32,
-  serializeBufferArrayToVector,
-  serializeBufferToVector,
-} from './index.js';
-
-describe('serialize', () => {
-  it('serialize buffer to vector and deserialize it back', () => {
-    const data = randomBytes(32);
-    const vector = serializeBufferToVector(data);
-    expect(vector.length).toBe(36);
-
-    const recovered = deserializeBufferFromVector(vector);
-    expect(recovered.elem).toEqual(data);
-    expect(recovered.adv).toEqual(4 + 32);
-
-    const paddedVector = Buffer.concat([randomBytes(10), vector, randomBytes(20)]);
-    const recovered2 = deserializeBufferFromVector(paddedVector, 10);
-    expect(recovered2.elem).toEqual(data);
-    expect(recovered2.adv).toEqual(4 + 32);
-  });
-
-  it('deserialize uint32', () => {
-    const uintBuf = Buffer.alloc(4);
-    uintBuf.writeUInt32BE(19, 0);
-
-    const recovered = deserializeUInt32(uintBuf);
-    expect(recovered.elem).toBe(19);
-    expect(recovered.adv).toBe(4);
-
-    const paddedBuf = Buffer.concat([randomBytes(10), uintBuf, randomBytes(20)]);
-    const recovered2 = deserializeUInt32(paddedBuf, 10);
-    expect(recovered2.elem).toBe(19);
-    expect(recovered2.adv).toBe(4);
-  });
-
-  it('deserialize field', () => {
-    const field = Fr.random();
-
-    const recovered = deserializeField(field.toBuffer());
-    expect(recovered.elem).toEqual(field);
-    expect(recovered.adv).toBe(32);
-
-    const paddedBuf = Buffer.concat([randomBytes(10), field.toBuffer(), randomBytes(20)]);
-    const recovered2 = deserializeField(paddedBuf, 10);
-    expect(recovered2.elem).toEqual(field);
-    expect(recovered2.adv).toBe(32);
-  });
-
-  it('serialize buffer array to vector and deserialize it back', () => {
-    // Array of uint32
-    const uintArr = [7, 13, 16];
-    const uintBufArr = uintArr.map(num => {
-      const uintBuf = Buffer.alloc(4);
-      uintBuf.writeUInt32BE(num, 0);
-      return uintBuf;
-    });
-    const uintArrVec = serializeBufferArrayToVector(uintBufArr);
-    expect(uintArrVec.length).toBe(4 + 4 * 3);
-
-    const recoveredUintArr = deserializeArrayFromVector(deserializeUInt32, uintArrVec);
-    expect(recoveredUintArr.elem).toEqual(uintArr);
-    expect(recoveredUintArr.adv).toEqual(4 + 4 * 3);
-
-    const paddedUintArrVec = Buffer.concat([randomBytes(10), uintArrVec, randomBytes(20)]);
-    const recoveredUintArr2 = deserializeArrayFromVector(deserializeUInt32, paddedUintArrVec, 10);
-    expect(recoveredUintArr2.elem).toEqual(uintArr);
-    expect(recoveredUintArr2.adv).toEqual(4 + 4 * 3);
-
-    // Array of field
-    const fieldArr = [Fr.random(), Fr.random(), Fr.random()];
-    const fieldArrVec = serializeBufferArrayToVector(fieldArr.map(fr => fr.toBuffer()));
-    expect(fieldArrVec.length).toBe(4 + 32 * 3);
-
-    const recoveredFieldArr = deserializeArrayFromVector(deserializeField, fieldArrVec);
-    expect(recoveredFieldArr.elem).toEqual(fieldArr);
-    expect(recoveredFieldArr.adv).toEqual(4 + 32 * 3);
-
-    const paddedFieldVec = Buffer.concat([randomBytes(10), fieldArrVec, randomBytes(20)]);
-    const recoveredFieldArr2 = deserializeArrayFromVector(deserializeField, paddedFieldVec, 10);
-    expect(recoveredFieldArr2.elem).toEqual(fieldArr);
-    expect(recoveredFieldArr2.adv).toEqual(4 + 32 * 3);
-  });
-});

package/src/wasm/wasm_module.test.ts

@@ -1,28 +0,0 @@
-import { readFile } from 'fs/promises';
-import { dirname } from 'path';
-
-import { fileURLToPath } from '../url/index.js';
-import { WasmModule } from './wasm_module.js';
-
-/**
- * Fetch a simple WASM.
- */
-async function fetchCode() {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  return await readFile(`${__dirname}/fixtures/gcd.wasm`);
-}
-
-describe('simple wasm', () => {
-  let wasm!: WasmModule;
-
-  beforeAll(async () => {
-    wasm = new WasmModule(await fetchCode(), () => ({
-      /*no imports*/
-    }));
-    await wasm.init(1, 1, /* No init method */ null);
-  });
-
-  it('should call gcd with correct result', () => {
-    expect(wasm.call('gcd', 12312, 12123)).toBe(27);
-  });
-});

package/tsconfig.dest.json

@@ -1,5 +0,0 @@
-{
-  "extends": ".",
-  "references": [],
-  "exclude": ["src/**/*.test.ts"]
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "..",
-  "compilerOptions": {
-    "outDir": "dest",
-    "rootDir": "src",
-    "tsBuildInfoFile": ".tsbuildinfo"
-  },
-  "include": ["src"],
-  "references": []
-}