@aztec/foundation 0.7.2 → 0.7.4

package/dest/serialize/free_funcs.js

@@ -0,0 +1,250 @@
+import { toBigIntBE, toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * Serialize a Buffer into a vector format by encoding the length of the buffer and concatenating it with the original buffer.
+ * The resulting vector consists of a 4-byte header containing the big-endian representation of the original buffer's length, followed by the original buffer.
+ * This function is useful when storing buffers as data structures with dynamic lengths and later deserializing them using 'deserializeBufferFromVector'.
+ *
+ * @param buf - The input Buffer to be serialized into a vector format.
+ * @returns A Buffer containing the serialized vector with the encoded length header.
+ */
+export function serializeBufferToVector(buf) {
+    const lengthBuf = Buffer.alloc(4);
+    lengthBuf.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthBuf, buf]);
+}
+/**
+ * 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 buffer from a vector by reading the length from its first 4 bytes, and then extracting the contents of the buffer.
+ * The function returns an object containing the deserialized buffer as 'elem' and the number of bytes advanced ('adv') after deserialization.
+ *
+ * @param vector - The input buffer containing the serialized vector.
+ * @param offset - The starting position from where the deserialization should begin (default is 0).
+ * @returns An object with the deserialized buffer as 'elem' and the number of bytes advanced ('adv') after deserialization.
+ */
+export function deserializeBufferFromVector(vector, offset = 0) {
+    const length = vector.readUInt32BE(offset);
+    const adv = 4 + length;
+    return { elem: vector.subarray(offset + 4, offset + adv), adv };
+}
+/**
+ * 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 };
+}
+/**
+ * Deserialize a field element from a buffer, starting at the given offset.
+ * The function reads 32 bytes from the buffer and converts it into a field element using Fr.fromBuffer.
+ * It returns an object containing the deserialized field element and the number of bytes read (adv).
+ *
+ * @param buf - The buffer containing the serialized field element.
+ * @param offset - The position in the buffer where the field element starts. Default is 0.
+ * @returns An object with 'elem' as the deserialized field element and 'adv' as the number of bytes read.
+ */
+export function deserializeField(buf, offset = 0) {
+    const adv = 32;
+    return { elem: Fr.fromBuffer(buf.subarray(offset, offset + adv)), adv };
+}
+/**
+ * Serialize an array of Buffer instances into a single Buffer by concatenating the array length as a 4-byte unsigned integer
+ * and then the individual Buffer elements. The function is useful for storing or transmitting an array of binary data chunks
+ * (e.g., file parts) in a compact format.
+ *
+ * @param arr - An array of Buffer instances to be serialized into a single vector-like Buffer.
+ * @returns A Buffer containing the serialized array length followed by the concatenated elements of the input Buffer array.
+ */
+export function serializeBufferArrayToVector(arr) {
+    const lengthBuf = Buffer.alloc(4);
+    lengthBuf.writeUInt32BE(arr.length, 0);
+    return Buffer.concat([lengthBuf, ...arr]);
+}
+/**
+ * Deserialize an array of fixed length elements from a given buffer using a custom deserializer function.
+ * The deserializer function should take the buffer and an offset as arguments, and return an object containing
+ * the deserialized element and the number of bytes used to deserialize it (adv).
+ *
+ * @param deserialize - A custom deserializer function to extract individual elements from the buffer.
+ * @param vector - The input buffer containing the serialized array.
+ * @param offset - An optional starting position in the buffer for deserializing the array.
+ * @returns An object containing the deserialized array and the total number of bytes used during deserialization (adv).
+ */
+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 };
+}
+/**
+ * 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');
+    }
+    // TS version of https://github.com/AztecProtocol/aztec-packages/blob/e2e3bf1dbeda5199060fb1711200d20414557cd4/circuits/cpp/src/aztec3/circuits/hash.hpp#L330
+    // 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)];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/serialize/index.d.ts

@@ -0,0 +1,6 @@
+export * from './free_funcs.js';
+export * from './deserializer.js';
+export * from './serializer.js';
+export * from './buffer_reader.js';
+export * from './types.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,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dest/serialize/index.js

@@ -0,0 +1,6 @@
+export * from './free_funcs.js';
+export * from './deserializer.js';
+export * from './serializer.js';
+export * from './buffer_reader.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VyaWFsaXplL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxZQUFZLENBQUMifQ==

package/dest/serialize/serialize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=serialize.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.test.d.ts","sourceRoot":"","sources":["../../src/serialize/serialize.test.ts"],"names":[],"mappings":""}

package/dest/serialize/serialize.test.js

@@ -0,0 +1,68 @@
+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);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dest/serialize/serializer.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * The Serializer class provides a convenient and efficient way to serialize various data types into binary format.
+ * It supports serialization of primitive types (like boolean, signed/unsigned integers, BigInt), as well as more complex types (like Buffer, Date, and custom structures with their own 'toBuffer()' methods).
+ * The class maintains an internal buffer array that accumulates serialized data, allowing for easy concatenation and retrieval of the final serialized Buffer.
+ * This can be useful in various applications such as network communication, file storage, or other scenarios where binary data representation is needed.
+ */
+export declare class Serializer {
+    private buf;
+    constructor();
+    /**
+     * Serialize a boolean value into a Buffer and append it to the internal buffer array.
+     * The serialized boolean will be stored as a single byte, where true is represented as 1 and false as 0.
+     * This method updates the Serializer's internal state and does not return any values.
+     *
+     * @param bool - The boolean value to be serialized.
+     */
+    bool(bool: boolean): void;
+    /**
+     * Encodes a given unsigned 32-bit integer into a Buffer and appends it to the internal buffer array.
+     * The provided number should be within the range of 0 and 2^32 - 1, inclusive.
+     * Throws an error if the input value is out of range or not a valid number.
+     *
+     * @param num - The unsigned 32-bit integer to be encoded and appended.
+     */
+    uInt32(num: number): void;
+    /**
+     * Serialize a signed 32-bit integer (int32) into the internal buffer.
+     * The number should be within the range of -2147483648 to 2147483647 inclusive.
+     * Throws an error if the input is not within the valid int32 range.
+     *
+     * @param num - The signed 32-bit integer to serialize.
+     */
+    int32(num: number): void;
+    /**
+     * Serializes a BigInt into a Buffer and appends it to the internal buffer array.
+     * The given 'num' is treated as a signed integer and is serialized using
+     * little-endian byte order. This method is useful for efficiently storing
+     * large integer values that may not fit within the range of a standard number.
+     *
+     * @param num - The BigInt value to serialize.
+     */
+    bigInt(num: bigint): void;
+    /**
+     * The given buffer is of variable length. Prefixes the buffer with its length.
+     * @param buf - The buffer to serialize as a variable-length vector.
+     */
+    vector(buf: Buffer): void;
+    /**
+     * Directly serializes a buffer that maybe of fixed, or variable length.
+     * It is assumed the corresponding deserialize function will handle variable length data, thus the length
+     * does not need to be prefixed here.
+     * If serializing a raw, variable length buffer, use vector().
+     * @param buf - The buffer to serialize as a fixed-length array.
+     */
+    buffer(buf: Buffer): void;
+    /**
+     * Serialize a string by first converting it to a buffer and then encoding its length as a prefix.
+     * The serialized string can be deserialized by reading the prefixed length and extracting the corresponding data.
+     * This method is useful for serializing strings of variable length in a consistent format.
+     *
+     * @param str - The input string to be serialized.
+     */
+    string(str: string): void;
+    /**
+     * Serialize a given Date instance into a Buffer and append it to the internal buffer list.
+     * The serialized date is stored as an 8-byte BigInt representing the number of milliseconds since the Unix epoch.
+     * This function facilitates serialization of JavaScript's built-in Date objects for subsequent data transmission or storage.
+     *
+     * @param date - The Date instance to be serialized.
+     */
+    date(date: Date): void;
+    /**
+     * Returns the serialized Buffer object that was created by calling various serialization methods on this Serializer instance.
+     * The resulting buffer can be used for sending or storing serialized data in binary format.
+     *
+     * @returns A Buffer containing the serialized data.
+     */
+    getBuffer(): Buffer;
+    /**
+     * Serializes an array of elements, where each element has a 'toBuffer()' method, into a single Buffer.
+     * The resulting buffer is prefixed with its length (number of elements), allowing for easy deserialization.
+     * This method is useful for serializing arrays of custom classes or data structures that have their own serialization logic.
+     *
+     * @param arr - The array of elements to be serialized. Each element must have a 'toBuffer()' method for serialization.
+     */
+    serializeArray<T>(arr: T[]): void;
+}
+//# sourceMappingURL=serializer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/serialize/serializer.ts"],"names":[],"mappings":";AAUA;;;;;GAKG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAgB;;IAI3B;;;;;;OAMG;IACI,IAAI,CAAC,IAAI,EAAE,OAAO;IAIzB;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB;;;;;;OAMG;IACI,KAAK,CAAC,GAAG,EAAE,MAAM;IAIxB;;;;;;;OAOG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB;;;OAGG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB;;;;;;OAMG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB;;;;;;OAMG;IACI,IAAI,CAAC,IAAI,EAAE,IAAI;IAItB;;;;;OAKG;IACI,SAAS;IAIhB;;;;;;OAMG;IACI,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;CAGlC"}

package/dest/serialize/serializer.js

@@ -0,0 +1,111 @@
+import { boolToByte, numToInt32BE, numToUInt32BE, serializeBigInt, serializeBufferToVector, serializeDate, } from './free_funcs.js';
+import { serializeBufferArrayToVector } from './index.js';
+/**
+ * The Serializer class provides a convenient and efficient way to serialize various data types into binary format.
+ * It supports serialization of primitive types (like boolean, signed/unsigned integers, BigInt), as well as more complex types (like Buffer, Date, and custom structures with their own 'toBuffer()' methods).
+ * The class maintains an internal buffer array that accumulates serialized data, allowing for easy concatenation and retrieval of the final serialized Buffer.
+ * This can be useful in various applications such as network communication, file storage, or other scenarios where binary data representation is needed.
+ */
+export class Serializer {
+    constructor() {
+        this.buf = [];
+    }
+    /**
+     * Serialize a boolean value into a Buffer and append it to the internal buffer array.
+     * The serialized boolean will be stored as a single byte, where true is represented as 1 and false as 0.
+     * This method updates the Serializer's internal state and does not return any values.
+     *
+     * @param bool - The boolean value to be serialized.
+     */
+    bool(bool) {
+        this.buf.push(boolToByte(bool));
+    }
+    /**
+     * Encodes a given unsigned 32-bit integer into a Buffer and appends it to the internal buffer array.
+     * The provided number should be within the range of 0 and 2^32 - 1, inclusive.
+     * Throws an error if the input value is out of range or not a valid number.
+     *
+     * @param num - The unsigned 32-bit integer to be encoded and appended.
+     */
+    uInt32(num) {
+        this.buf.push(numToUInt32BE(num));
+    }
+    /**
+     * Serialize a signed 32-bit integer (int32) into the internal buffer.
+     * The number should be within the range of -2147483648 to 2147483647 inclusive.
+     * Throws an error if the input is not within the valid int32 range.
+     *
+     * @param num - The signed 32-bit integer to serialize.
+     */
+    int32(num) {
+        this.buf.push(numToInt32BE(num));
+    }
+    /**
+     * Serializes a BigInt into a Buffer and appends it to the internal buffer array.
+     * The given 'num' is treated as a signed integer and is serialized using
+     * little-endian byte order. This method is useful for efficiently storing
+     * large integer values that may not fit within the range of a standard number.
+     *
+     * @param num - The BigInt value to serialize.
+     */
+    bigInt(num) {
+        this.buf.push(serializeBigInt(num));
+    }
+    /**
+     * The given buffer is of variable length. Prefixes the buffer with its length.
+     * @param buf - The buffer to serialize as a variable-length vector.
+     */
+    vector(buf) {
+        this.buf.push(serializeBufferToVector(buf));
+    }
+    /**
+     * Directly serializes a buffer that maybe of fixed, or variable length.
+     * It is assumed the corresponding deserialize function will handle variable length data, thus the length
+     * does not need to be prefixed here.
+     * If serializing a raw, variable length buffer, use vector().
+     * @param buf - The buffer to serialize as a fixed-length array.
+     */
+    buffer(buf) {
+        this.buf.push(buf);
+    }
+    /**
+     * Serialize a string by first converting it to a buffer and then encoding its length as a prefix.
+     * The serialized string can be deserialized by reading the prefixed length and extracting the corresponding data.
+     * This method is useful for serializing strings of variable length in a consistent format.
+     *
+     * @param str - The input string to be serialized.
+     */
+    string(str) {
+        this.vector(Buffer.from(str));
+    }
+    /**
+     * Serialize a given Date instance into a Buffer and append it to the internal buffer list.
+     * The serialized date is stored as an 8-byte BigInt representing the number of milliseconds since the Unix epoch.
+     * This function facilitates serialization of JavaScript's built-in Date objects for subsequent data transmission or storage.
+     *
+     * @param date - The Date instance to be serialized.
+     */
+    date(date) {
+        this.buf.push(serializeDate(date));
+    }
+    /**
+     * Returns the serialized Buffer object that was created by calling various serialization methods on this Serializer instance.
+     * The resulting buffer can be used for sending or storing serialized data in binary format.
+     *
+     * @returns A Buffer containing the serialized data.
+     */
+    getBuffer() {
+        return Buffer.concat(this.buf);
+    }
+    /**
+     * Serializes an array of elements, where each element has a 'toBuffer()' method, into a single Buffer.
+     * The resulting buffer is prefixed with its length (number of elements), allowing for easy deserialization.
+     * This method is useful for serializing arrays of custom classes or data structures that have their own serialization logic.
+     *
+     * @param arr - The array of elements to be serialized. Each element must have a 'toBuffer()' method for serialization.
+     */
+    serializeArray(arr) {
+        this.buf.push(serializeBufferArrayToVector(arr.map((e) => e.toBuffer())));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJpYWxpemUvc2VyaWFsaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsVUFBVSxFQUNWLFlBQVksRUFDWixhQUFhLEVBQ2IsZUFBZSxFQUNmLHVCQUF1QixFQUN2QixhQUFhLEdBQ2QsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QixPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFMUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sVUFBVTtJQUdyQjtRQUZRLFFBQUcsR0FBYSxFQUFFLENBQUM7SUFFWixDQUFDO0lBRWhCOzs7Ozs7T0FNRztJQUNJLElBQUksQ0FBQyxJQUFhO1FBQ3ZCLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxNQUFNLENBQUMsR0FBVztRQUN2QixJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksS0FBSyxDQUFDLEdBQVc7UUFDdEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDbkMsQ0FBQztJQUVEOzs7Ozs7O09BT0c7SUFDSSxNQUFNLENBQUMsR0FBVztRQUN2QixJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksTUFBTSxDQUFDLEdBQVc7UUFDdkIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsdUJBQXVCLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksTUFBTSxDQUFDLEdBQVc7UUFDdkIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNJLE1BQU0sQ0FBQyxHQUFXO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxJQUFJLENBQUMsSUFBVTtRQUNwQixJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNyQyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxTQUFTO1FBQ2QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNqQyxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksY0FBYyxDQUFJLEdBQVE7UUFDL0IsSUFBSSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsNEJBQTRCLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLENBQUM7Q0FDRiJ9

package/dest/serialize/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents a fixed-length array.
+ */
+export type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _Tuple<T, N, []>) : never;
+/**
+ * Recursive type helper for constructing a fixed-length tuple of a given type.
+ * This is utilized internally by Tuple to create the final fixed-length tuple.
+ */
+type _Tuple<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _Tuple<T, N, [T, ...R]>;
+/**
+ * Check an array size, and cast it to a tuple.
+ * @param array - The array.
+ * @param n - The size.
+ * @returns The case tuple, or throws Error.
+ */
+export declare function assertLength<T, N extends number>(array: T[], n: N): Tuple<T, N>;
+/**
+ * Annoying, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @typeparam T - The original array type.
+ */
+type MapTuple<T extends any[], F extends (item: any) => any> = {
+    [K in keyof T]: T[K] extends infer U ? (F extends (item: U) => infer V ? V : never) : never;
+};
+/**
+ * Annoyingly, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @see https://github.com/microsoft/TypeScript/issues/29841.
+ * @param array - A tuple array.
+ */
+export declare function mapTuple<T extends any[], F extends (item: any) => any>(tuple: T, fn: F): MapTuple<T, F>;
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialize/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAC3G;;;GAGG;AACH,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAE5G;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAK/E;AACD;;;;GAIG;AACH,KAAK,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI;KAC5D,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK;CAC5F,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAEvG"}

package/dest/serialize/types.js

@@ -0,0 +1,22 @@
+/**
+ * Check an array size, and cast it to a tuple.
+ * @param array - The array.
+ * @param n - The size.
+ * @returns The case tuple, or throws Error.
+ */
+export function assertLength(array, n) {
+    if (array.length !== n) {
+        throw new Error("Wrong 'fixed array' size");
+    }
+    return array;
+}
+/**
+ * Annoyingly, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @see https://github.com/microsoft/TypeScript/issues/29841.
+ * @param array - A tuple array.
+ */
+export function mapTuple(tuple, fn) {
+    return tuple.map(fn);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VyaWFsaXplL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBc0IsS0FBVSxFQUFFLENBQUk7SUFDaEUsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRTtRQUN0QixNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUM7S0FDN0M7SUFDRCxPQUFPLEtBQW9CLENBQUM7QUFDOUIsQ0FBQztBQVVEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBZ0QsS0FBUSxFQUFFLEVBQUs7SUFDckYsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBbUIsQ0FBQztBQUN6QyxDQUFDIn0=