@aztec/foundation 0.0.0-test.0

package/dest/serialize/free_funcs.js

@@ -0,0 +1,189 @@
+import { Fr } from '../fields/fields.js';
+/**
+ * Convert a boolean value to its corresponding byte representation in a Buffer of size 1.
+ * The function takes a boolean value and writes it into a new buffer as either 1 (true) or 0 (false).
+ * This method is useful for converting a boolean value into a binary format that can be stored or transmitted easily.
+ *
+ * @param b - The boolean value to be converted.
+ * @returns A Buffer containing the byte representation of the input boolean value.
+ */ export function boolToByte(b) {
+    const buf = Buffer.alloc(1);
+    buf.writeUInt8(b ? 1 : 0);
+    return buf;
+}
+/**
+ * @param n - The input number to be converted to a big-endian unsigned 16-bit integer Buffer.
+ * @param bufferSize - Optional, the size of the output Buffer (default is 2).
+ * @returns A Buffer containing the big-endian unsigned 16-bit integer representation of the input number.
+ */ export function numToUInt16BE(n, bufferSize = 2) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt16BE(n, bufferSize - 2);
+    return buf;
+}
+/**
+ * Convert a number into a 4-byte little-endian unsigned integer buffer.
+ * The input number is serialized as an unsigned 32-bit integer in little-endian byte order,
+ * and returned as a Buffer of specified size (defaults to 4).
+ * If the provided bufferSize is greater than 4, the additional bytes will be padded with zeros.
+ *
+ * @param n - The number to be converted into a little-endian unsigned integer buffer.
+ * @param bufferSize - Optional, the size of the output buffer (default value is 4).
+ * @returns A Buffer containing the serialized little-endian unsigned integer representation of the input number.
+ */ export function numToUInt32LE(n, bufferSize = 4) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt32LE(n, bufferSize - 4);
+    return buf;
+}
+/**
+ * Convert a number to a big-endian unsigned 32-bit integer Buffer.
+ * This function takes a number and an optional buffer size as input and creates a Buffer with the specified size (defaults to 4) containing the big-endian representation of the input number as an unsigned 32-bit integer. Note that the bufferSize should be greater than or equal to 4, otherwise the output Buffer might truncate the serialized value.
+ *
+ * @param n - The input number to be converted to a big-endian unsigned 32-bit integer Buffer.
+ * @param bufferSize - Optional, the size of the output Buffer (default is 4).
+ * @returns A Buffer containing the big-endian unsigned 32-bit integer representation of the input number.
+ */ export function numToUInt32BE(n, bufferSize = 4) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt32BE(n, bufferSize - 4);
+    return buf;
+}
+/**
+ * Serialize a number into a big-endian signed 32-bit integer Buffer with the specified buffer size.
+ * This function converts the input number into its binary representation and stores it in a Buffer
+ * with the provided buffer size. By default, the buffer size is set to 4 bytes which represents a 32-bit integer.
+ * The function will use the last 4 bytes of the buffer to store the serialized number. If the input number
+ * is outside the range of a 32-bit signed integer, the resulting serialization may be incorrect due to truncation.
+ *
+ * @param n - The number to be serialized as a signed 32-bit integer.
+ * @param bufferSize - Optional, the size of the output Buffer (default is 4 bytes).
+ * @returns A Buffer containing the serialized big-endian signed 32-bit integer.
+ */ export function numToInt32BE(n, bufferSize = 4) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeInt32BE(n, bufferSize - 4);
+    return buf;
+}
+/**
+ * Convert a number to an 8-bit unsigned integer and return it as a Buffer of length 1.
+ * The input number is written as an 8-bit unsigned integer into the buffer. This function
+ * is useful for converting small numeric values to a standardized binary format that can be
+ * easily stored or transmitted.
+ *
+ * @param n - The number to be converted to an 8-bit unsigned integer.
+ * @returns A Buffer containing the 8-bit unsigned integer representation of the input number.
+ */ export function numToUInt8(n) {
+    const bufferSize = 1;
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt8(n, 0);
+    return buf;
+}
+/**
+ * Adds a 4-byte byte-length prefix to a buffer.
+ * @param buf - The input Buffer to be prefixed
+ * @returns A Buffer with 4-byte byte-length prefix.
+ */ export function prefixBufferWithLength(buf) {
+    const lengthBuf = Buffer.alloc(4);
+    lengthBuf.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([
+        lengthBuf,
+        buf
+    ]);
+}
+/**
+ * Parse a buffer as a big integer.
+ */ export function toBigInt(buf) {
+    const hex = buf.toString('hex');
+    if (hex.length === 0) {
+        return BigInt(0);
+    }
+    return BigInt(`0x${hex}`);
+}
+/**
+ * Stores full 256 bits of information in 2 fields.
+ * @param buf - 32 bytes of data
+ * @returns 2 field elements
+ */ export function to2Fields(buf) {
+    if (buf.length !== 32) {
+        throw new Error('Buffer must be 32 bytes');
+    }
+    // Split the hash into two fields, a high and a low
+    const buf1 = Buffer.concat([
+        Buffer.alloc(16),
+        buf.subarray(0, 16)
+    ]);
+    const buf2 = Buffer.concat([
+        Buffer.alloc(16),
+        buf.subarray(16, 32)
+    ]);
+    return [
+        Fr.fromBuffer(buf1),
+        Fr.fromBuffer(buf2)
+    ];
+}
+/**
+ * Reconstructs the original 32 bytes of data from 2 field elements.
+ * @param field1 - First field element
+ * @param field2 - Second field element
+ * @returns 32 bytes of data as a Buffer
+ */ export function from2Fields(field1, field2) {
+    // Convert the field elements back to buffers
+    const buf1 = field1.toBuffer();
+    const buf2 = field2.toBuffer();
+    // Remove the padding (first 16 bytes) from each buffer
+    const originalPart1 = buf1.subarray(Fr.SIZE_IN_BYTES / 2, Fr.SIZE_IN_BYTES);
+    const originalPart2 = buf2.subarray(Fr.SIZE_IN_BYTES / 2, Fr.SIZE_IN_BYTES);
+    // Concatenate the two parts to form the original buffer
+    return Buffer.concat([
+        originalPart1,
+        originalPart2
+    ]);
+}
+/**
+ * Truncates SHA hashes to match Noir's truncated version
+ * @param buf - 32 bytes of data
+ * @returns 31 bytes of data padded to 32
+ */ export function truncateAndPad(buf) {
+    // Note that we always truncate here, to match solidity's sha256ToField()
+    if (buf.length !== 32) {
+        throw new Error('Buffer to truncate must be 32 bytes');
+    }
+    return Buffer.concat([
+        Buffer.alloc(1),
+        buf.subarray(0, 31)
+    ]);
+}
+/**
+ * Stores 248 bits of information in 1 field.
+ * @param buf - 32 or 31 bytes of data
+ * @returns 1 field element
+ */ export function toTruncField(buf) {
+    if (buf.length !== 32 && buf.length !== 31) {
+        throw new Error('Buffer must be 31 or 32 bytes');
+    }
+    if (buf.length == 32 && buf[0] == 0 || buf.length == 31) {
+        return Fr.fromBuffer(buf);
+    } else {
+        // Note: safer to NOT truncate here, all inputs are expected to be truncated
+        // from Noir or L1 Contracts or Class.hash() methods
+        throw new Error(`Number ${toBigInt(buf)} does not fit in 31 byte truncated buffer`);
+    }
+}
+/**
+ * Reconstructs the original 31 bytes of data from 1 truncated field element.
+ * @param field - field element
+ * @returns 31 bytes of data as a Buffer
+ */ export function fromTruncField(field) {
+    const buffer = field.toBuffer();
+    if (buffer[0] != 0) {
+        throw new Error(`Number ${field} does not fit in 31 byte truncated buffer`);
+    }
+    return buffer;
+}
+export function fromFieldsTuple(fields) {
+    return from2Fields(fields[0], fields[1]);
+}
+export function toHumanReadable(buf, maxLen) {
+    const result = buf.every((byte)=>byte >= 32 && byte <= 126) ? buf.toString('ascii') : `0x${buf.toString('hex')}`;
+    if (maxLen && result.length > maxLen) {
+        return result.slice(0, maxLen) + '...';
+    }
+    return result;
+}

package/dest/serialize/index.d.ts

@@ -0,0 +1,7 @@
+export * from './free_funcs.js';
+export * from './buffer_reader.js';
+export * from './field_reader.js';
+export * from './types.js';
+export * from './serialize.js';
+export * from './type_registry.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/serialize/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialize/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dest/serialize/index.js

@@ -0,0 +1,6 @@
+export * from './free_funcs.js';
+export * from './buffer_reader.js';
+export * from './field_reader.js';
+export * from './types.js';
+export * from './serialize.js';
+export * from './type_registry.js';

package/dest/serialize/serialize.d.ts

@@ -0,0 +1,182 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../fields/fields.js';
+/**
+ * For serializing an array of fixed length buffers.
+ * @param arr - Array of bufferable.
+ * @param prefixLength - The length of the prefix (denominated in bytes).
+ * @returns The serialized buffers.
+ */
+export declare function serializeArrayOfBufferableToVector(objs: Bufferable[], prefixLength?: number): Buffer;
+/**
+ * Helper function for deserializeArrayFromVector.
+ */
+type DeserializeFn<T> = (buf: Buffer, offset: number) => {
+    /**
+     * The deserialized type.
+     */
+    elem: T;
+    /**
+     * How many bytes to advance by.
+     */
+    adv: number;
+};
+/**
+ * Deserializes an array from a vector on an element-by-element basis.
+ * @param deserialize - A function used to deserialize each element of the vector.
+ * @param vector - The vector to deserialize.
+ * @param offset - The position in the vector to start deserializing from.
+ * @returns Deserialized array and how many bytes we advanced by.
+ */
+export declare function deserializeArrayFromVector<T>(deserialize: DeserializeFn<T>, vector: Buffer, offset?: number): {
+    /**
+     * The deserialized array.
+     */
+    elem: T[];
+    /**
+     * How many bytes we advanced by.
+     */
+    adv: number;
+};
+/**
+ * Cast a uint8 array to a number.
+ * @param array - The uint8 array.
+ * @returns The number.
+ */
+export declare function uint8ArrayToNum(array: Uint8Array): number;
+/**
+ * Serializes a boolean to a buffer.
+ * @param value - Value to serialize.
+ * @returns The serialized boolean.
+ */
+export declare function boolToBuffer(value: boolean, bufferSize?: number): Buffer;
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The deserialized 256-bit field.
+ */
+export declare function deserializeField(buf: Buffer, offset?: number): {
+    elem: Buffer;
+    adv: number;
+};
+/** A type that can be written to a buffer. */
+export type Bufferable = boolean | Buffer | Uint8Array | number | bigint | string | {
+    /**
+     * Serialize to a buffer.
+     */
+    toBuffer: () => Buffer;
+} | Bufferable[];
+/** A type that can be converted to a Field or a Field array. */
+export type Fieldable = Fr | boolean | number | bigint | Buffer | {
+    /**
+     * Serialize to a field.
+     * @dev Duplicate to `toField` but left as is as it is used in AVM codebase.
+     */
+    toFr: () => Fr;
+} | {
+    /** Serialize to a field. */
+    toField: () => Fr;
+} | {
+    /** Serialize to an array of fields. */
+    toFields: () => Fr[];
+} | Fieldable[];
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A buffer list with the concatenation of all fields.
+ */
+export declare function serializeToBufferArray(...objs: Bufferable[]): Buffer[];
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns An array of fields with the concatenation of all fields.
+ */
+export declare function serializeToFields(...objs: Fieldable[]): Fr[];
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A single buffer with the concatenation of all fields.
+ */
+export declare function serializeToBuffer(...objs: Bufferable[]): Buffer;
+/**
+ * Returns a user-friendly JSON representation of an object, showing buffers as hex strings.
+ * @param obj - Object to json-stringify.
+ * @returns A JSON string.
+ */
+export declare function toFriendlyJSON(obj: object): string;
+/**
+ * Serialize a BigInt value into a Buffer of specified width.
+ * The function converts the input BigInt into its big-endian representation and stores it in a Buffer of the given width.
+ * If the width is not provided, a default value of 32 bytes will be used. It is important to provide an appropriate width
+ * to avoid truncation or incorrect serialization of large BigInt values.
+ *
+ * @param n - The BigInt value to be serialized.
+ * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
+ * @returns A Buffer containing the serialized BigInt value in big-endian format.
+ */
+export declare function serializeBigInt(n: bigint, width?: number): Buffer;
+/**
+ * Deserialize a big integer from a buffer, given an offset and width.
+ * Reads the specified number of bytes from the buffer starting at the offset, converts it to a big integer, and returns the deserialized result along with the number of bytes read (advanced).
+ *
+ * @param buf - The buffer containing the big integer to be deserialized.
+ * @param offset - The position in the buffer where the big integer starts. Defaults to 0.
+ * @param width - The number of bytes to read from the buffer for the big integer. Defaults to 32.
+ * @returns An object containing the deserialized big integer value ('elem') and the number of bytes advanced ('adv').
+ */
+export declare function deserializeBigInt(buf: Buffer, offset?: number, width?: number): {
+    elem: bigint;
+    adv: number;
+};
+/**
+ * Serializes a Date object into a Buffer containing its timestamp as a big integer value.
+ * The resulting Buffer has a fixed width of 8 bytes, representing a 64-bit big-endian integer.
+ * This function is useful for converting date values into a binary format that can be stored or transmitted easily.
+ *
+ * @param date - The Date object to be serialized.
+ * @returns A Buffer containing the serialized timestamp of the input Date object.
+ */
+export declare function serializeDate(date: Date): Buffer;
+/**
+ * Deserialize a boolean value from a given buffer at the specified offset.
+ * Reads a single byte at the provided offset in the buffer and returns
+ * the deserialized boolean value along with the number of bytes read (adv).
+ *
+ * @param buf - The buffer containing the serialized boolean value.
+ * @param offset - The position in the buffer to start reading the boolean value.
+ * @returns An object containing the deserialized boolean value (elem) and the number of bytes read (adv).
+ */
+export declare function deserializeBool(buf: Buffer, offset?: number): {
+    elem: number;
+    adv: number;
+};
+/**
+ * Deserialize a 4-byte unsigned integer from a buffer, starting at the specified offset.
+ * The deserialization reads 4 bytes from the given buffer and converts it into a number.
+ * Returns an object containing the deserialized unsigned integer and the number of bytes advanced (4).
+ *
+ * @param buf - The buffer containing the serialized unsigned integer.
+ * @param offset - The starting position in the buffer to deserialize from (default is 0).
+ * @returns An object with the deserialized unsigned integer as 'elem' and the number of bytes advanced ('adv') as 4.
+ */
+export declare function deserializeUInt32(buf: Buffer, offset?: number): {
+    elem: number;
+    adv: number;
+};
+/**
+ * Deserialize a signed 32-bit integer from a buffer at the given offset.
+ * The input 'buf' should be a Buffer containing binary data, and 'offset' should be the position in the buffer
+ * where the signed 32-bit integer starts. Returns an object with both the deserialized integer (elem) and the
+ * number of bytes advanced in the buffer (adv, always equal to 4).
+ *
+ * @param buf - The buffer containing the binary data.
+ * @param offset - Optional, the position in the buffer where the signed 32-bit integer starts (default is 0).
+ * @returns An object with the deserialized integer as 'elem' and the number of bytes advanced as 'adv'.
+ */
+export declare function deserializeInt32(buf: Buffer, offset?: number): {
+    elem: number;
+    adv: number;
+};
+export {};
+//# sourceMappingURL=serialize.d.ts.map

package/dest/serialize/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/serialize/serialize.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,qBAAqB,CAAC;AAGzC;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,YAAY,SAAI,GAAG,MAAM,CAa/F;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,KACX;IACH;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IACR;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACT;IACD;;OAEG;IACH,IAAI,EAAE,CAAC,EAAE,CAAC;IACV;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAWA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAGzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,SAAI,GAAG,MAAM,CAInE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD;AAED,8CAA8C;AAC9C,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,GACN,MAAM,GACN;IACE;;OAEG;IACH,QAAQ,EAAE,MAAM,MAAM,CAAC;CACxB,GACD,UAAU,EAAE,CAAC;AAEjB,gEAAgE;AAChE,MAAM,MAAM,SAAS,GACjB,EAAE,GACF,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN;IACE;;;OAGG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,GACD;IACE,4BAA4B;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GACD;IACE,uCAAuC;IACvC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;CACtB,GACD,SAAS,EAAE,CAAC;AAEhB;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CA4BtE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,CAsB5D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4BlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,SAAK,UAEpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI,EAAE,KAAK,SAAK;;;EAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,UAEvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD"}

package/dest/serialize/serialize.js

@@ -0,0 +1,248 @@
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../fields/fields.js';
+import { numToUInt32BE } from './free_funcs.js';
+/**
+ * For serializing an array of fixed length buffers.
+ * @param arr - Array of bufferable.
+ * @param prefixLength - The length of the prefix (denominated in bytes).
+ * @returns The serialized buffers.
+ */ export function serializeArrayOfBufferableToVector(objs, prefixLength = 4) {
+    const arr = serializeToBufferArray(objs);
+    let lengthBuf;
+    if (prefixLength === 1) {
+        lengthBuf = Buffer.alloc(1);
+        lengthBuf.writeUInt8(arr.length, 0);
+    } else if (prefixLength === 4) {
+        lengthBuf = Buffer.alloc(4);
+        lengthBuf.writeUInt32BE(arr.length, 0);
+    } else {
+        throw new Error(`Unsupported prefix length. Got ${prefixLength}, expected 1 or 4`);
+    }
+    return Buffer.concat([
+        lengthBuf,
+        ...arr
+    ]);
+}
+/**
+ * Deserializes an array from a vector on an element-by-element basis.
+ * @param deserialize - A function used to deserialize each element of the vector.
+ * @param vector - The vector to deserialize.
+ * @param offset - The position in the vector to start deserializing from.
+ * @returns Deserialized array and how many bytes we advanced by.
+ */ export function deserializeArrayFromVector(deserialize, vector, offset = 0) {
+    let pos = offset;
+    const size = vector.readUInt32BE(pos);
+    pos += 4;
+    const arr = new Array(size);
+    for(let i = 0; i < size; ++i){
+        const { elem, adv } = deserialize(vector, pos);
+        pos += adv;
+        arr[i] = elem;
+    }
+    return {
+        elem: arr,
+        adv: pos - offset
+    };
+}
+/**
+ * Cast a uint8 array to a number.
+ * @param array - The uint8 array.
+ * @returns The number.
+ */ export function uint8ArrayToNum(array) {
+    const buf = Buffer.from(array);
+    return buf.readUint32LE();
+}
+/**
+ * Serializes a boolean to a buffer.
+ * @param value - Value to serialize.
+ * @returns The serialized boolean.
+ */ export function boolToBuffer(value, bufferSize = 1) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt8(value ? 1 : 0, bufferSize - 1);
+    return buf;
+}
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The deserialized 256-bit field.
+ */ export function deserializeField(buf, offset = 0) {
+    const adv = 32;
+    return {
+        elem: buf.slice(offset, offset + adv),
+        adv
+    };
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A buffer list with the concatenation of all fields.
+ */ export function serializeToBufferArray(...objs) {
+    const ret = [];
+    for (const obj of objs){
+        if (Array.isArray(obj)) {
+            ret.push(...serializeToBufferArray(...obj));
+        } else if (Buffer.isBuffer(obj)) {
+            ret.push(obj);
+        } else if (typeof obj === 'boolean') {
+            ret.push(boolToBuffer(obj));
+        } else if (typeof obj === 'bigint') {
+            // Throw if bigint does not fit into 32 bytes
+            if (obj > BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
+                throw new Error(`BigInt ${obj} does not fit into 32 bytes`);
+            }
+            ret.push(serializeBigInt(obj));
+        } else if (typeof obj === 'number') {
+            // Note: barretenberg assumes everything is big-endian
+            ret.push(numToUInt32BE(obj)); // TODO: Are we always passing numbers as UInt32?
+        } else if (typeof obj === 'string') {
+            ret.push(numToUInt32BE(obj.length));
+            ret.push(Buffer.from(obj));
+        } else if ('toBuffer' in obj) {
+            ret.push(obj.toBuffer());
+        } else {
+            throw new Error(`Cannot serialize input to buffer: ${typeof obj} ${obj.constructor?.name}`);
+        }
+    }
+    return ret;
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns An array of fields with the concatenation of all fields.
+ */ export function serializeToFields(...objs) {
+    const ret = [];
+    for (const obj of objs){
+        if (Array.isArray(obj)) {
+            ret.push(...serializeToFields(...obj));
+        } else if (obj instanceof Fr) {
+            ret.push(obj);
+        } else if (typeof obj === 'boolean' || typeof obj === 'number' || typeof obj === 'bigint') {
+            ret.push(new Fr(obj));
+        } else if ('toFields' in obj) {
+            ret.push(...obj.toFields());
+        } else if ('toFr' in obj) {
+            ret.push(obj.toFr());
+        } else if ('toField' in obj) {
+            ret.push(obj.toField());
+        } else if (Buffer.isBuffer(obj)) {
+            ret.push(Fr.fromBuffer(obj));
+        } else {
+            throw new Error(`Cannot serialize input to field: ${typeof obj} ${obj.constructor?.name}`);
+        }
+    }
+    return ret;
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A single buffer with the concatenation of all fields.
+ */ export function serializeToBuffer(...objs) {
+    return Buffer.concat(serializeToBufferArray(...objs));
+}
+/**
+ * Returns a user-friendly JSON representation of an object, showing buffers as hex strings.
+ * @param obj - Object to json-stringify.
+ * @returns A JSON string.
+ */ export function toFriendlyJSON(obj) {
+    return JSON.stringify(obj, (key, value)=>{
+        if (value !== null && typeof value === 'object' && value.type === 'Buffer' && Array.isArray(value.data)) {
+            return '0x' + Buffer.from(value.data).toString('hex');
+        } else if (typeof value === 'bigint') {
+            return value.toString();
+        } else if (value && value.toFriendlyJSON) {
+            return value.toFriendlyJSON();
+        } else if (value && value.type && [
+            'Fr',
+            'Fq',
+            'AztecAddress',
+            'EthAddress'
+        ].includes(value.type)) {
+            return value.value;
+        } else {
+            return value;
+        }
+    }, 2);
+}
+/**
+ * Serialize a BigInt value into a Buffer of specified width.
+ * The function converts the input BigInt into its big-endian representation and stores it in a Buffer of the given width.
+ * If the width is not provided, a default value of 32 bytes will be used. It is important to provide an appropriate width
+ * to avoid truncation or incorrect serialization of large BigInt values.
+ *
+ * @param n - The BigInt value to be serialized.
+ * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
+ * @returns A Buffer containing the serialized BigInt value in big-endian format.
+ */ export function serializeBigInt(n, width = 32) {
+    return toBufferBE(n, width);
+}
+/**
+ * Deserialize a big integer from a buffer, given an offset and width.
+ * Reads the specified number of bytes from the buffer starting at the offset, converts it to a big integer, and returns the deserialized result along with the number of bytes read (advanced).
+ *
+ * @param buf - The buffer containing the big integer to be deserialized.
+ * @param offset - The position in the buffer where the big integer starts. Defaults to 0.
+ * @param width - The number of bytes to read from the buffer for the big integer. Defaults to 32.
+ * @returns An object containing the deserialized big integer value ('elem') and the number of bytes advanced ('adv').
+ */ export function deserializeBigInt(buf, offset = 0, width = 32) {
+    return {
+        elem: toBigIntBE(buf.subarray(offset, offset + width)),
+        adv: width
+    };
+}
+/**
+ * Serializes a Date object into a Buffer containing its timestamp as a big integer value.
+ * The resulting Buffer has a fixed width of 8 bytes, representing a 64-bit big-endian integer.
+ * This function is useful for converting date values into a binary format that can be stored or transmitted easily.
+ *
+ * @param date - The Date object to be serialized.
+ * @returns A Buffer containing the serialized timestamp of the input Date object.
+ */ export function serializeDate(date) {
+    return serializeBigInt(BigInt(date.getTime()), 8);
+}
+/**
+ * Deserialize a boolean value from a given buffer at the specified offset.
+ * Reads a single byte at the provided offset in the buffer and returns
+ * the deserialized boolean value along with the number of bytes read (adv).
+ *
+ * @param buf - The buffer containing the serialized boolean value.
+ * @param offset - The position in the buffer to start reading the boolean value.
+ * @returns An object containing the deserialized boolean value (elem) and the number of bytes read (adv).
+ */ export function deserializeBool(buf, offset = 0) {
+    const adv = 1;
+    return {
+        elem: buf.readUInt8(offset),
+        adv
+    };
+}
+/**
+ * Deserialize a 4-byte unsigned integer from a buffer, starting at the specified offset.
+ * The deserialization reads 4 bytes from the given buffer and converts it into a number.
+ * Returns an object containing the deserialized unsigned integer and the number of bytes advanced (4).
+ *
+ * @param buf - The buffer containing the serialized unsigned integer.
+ * @param offset - The starting position in the buffer to deserialize from (default is 0).
+ * @returns An object with the deserialized unsigned integer as 'elem' and the number of bytes advanced ('adv') as 4.
+ */ export function deserializeUInt32(buf, offset = 0) {
+    const adv = 4;
+    return {
+        elem: buf.readUInt32BE(offset),
+        adv
+    };
+}
+/**
+ * Deserialize a signed 32-bit integer from a buffer at the given offset.
+ * The input 'buf' should be a Buffer containing binary data, and 'offset' should be the position in the buffer
+ * where the signed 32-bit integer starts. Returns an object with both the deserialized integer (elem) and the
+ * number of bytes advanced in the buffer (adv, always equal to 4).
+ *
+ * @param buf - The buffer containing the binary data.
+ * @param offset - Optional, the position in the buffer where the signed 32-bit integer starts (default is 0).
+ * @returns An object with the deserialized integer as 'elem' and the number of bytes advanced as 'adv'.
+ */ export function deserializeInt32(buf, offset = 0) {
+    const adv = 4;
+    return {
+        elem: buf.readInt32BE(offset),
+        adv
+    };
+}

package/dest/serialize/type_registry.d.ts

@@ -0,0 +1,23 @@
+type Deserializable = {
+    fromString(str: string): object;
+};
+/**
+ * Register a class here that has a toJSON method that returns:
+ * ```
+ * {
+ *   "type": "ExampleClassName",
+ *   "value": <result of ExampleClassName.toString()>
+ * }
+ * ```
+ * and has an e.g. ExampleClassName.fromString(string) method.
+ * This means you can then easily serialize/deserialize the type using JSON.stringify and JSON.parse.
+ */
+export declare class TypeRegistry {
+    private static registry;
+    static register(typeName: string, constructor: Deserializable): void;
+    static getConstructor(typeName: string): Deserializable | undefined;
+}
+export declare function resolver(_: any, value: any): any;
+export declare function reviver(key: string, value: any): any;
+export {};
+//# sourceMappingURL=type_registry.d.ts.map

package/dest/serialize/type_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_registry.d.ts","sourceRoot":"","sources":["../../src/serialize/type_registry.ts"],"names":[],"mappings":"AAEA,KAAK,cAAc,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA0C;WAEnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,GAAG,IAAI;WAI7D,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAG3E;AAmBD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,OAgB1C;AAGD,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAW9C"}