@aztec/foundation 0.0.0-test.0

package/dest/schemas/parse.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { times } from '../collection/array.js';
+/** Parses the given arguments using a tuple from the provided schemas. */ export function parse(args, ...schemas) {
+    return z.tuple(schemas).parse(args);
+}
+/**
+ * Parses the given arguments against a tuple, allowing empty for optional items.
+ * @dev Zod doesn't like tuplues with optional items. See https://github.com/colinhacks/zod/discussions/949.
+ */ export function parseWithOptionals(args, schema) {
+    const missingCount = schema.items.length - args.length;
+    const optionalCount = schema.items.filter(isOptional).length;
+    const toParse = missingCount > 0 && missingCount <= optionalCount ? args.concat(times(missingCount, ()=>undefined)) : args;
+    return schema.parseAsync(toParse);
+}
+function isOptional(schema) {
+    try {
+        return schema.isOptional();
+    } catch (err) {
+        // See https://github.com/colinhacks/zod/issues/1911
+        return schema._def.typeName === 'ZodOptional';
+    }
+}

package/dest/schemas/schemas.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { z } from 'zod';
+import { Buffer32 } from '../buffer/buffer32.js';
+import { EthAddress } from '../eth-address/index.js';
+import { Fq, Fr } from '../fields/fields.js';
+import { Point } from '../fields/point.js';
+export declare const schemas: {
+    /** Accepts a hex string. */
+    EthAddress: z.ZodType<EthAddress, any, string>;
+    /** Accepts a hex string. */
+    Fr: z.ZodType<Fr, any, string>;
+    /** Accepts a hex string. */
+    Fq: z.ZodType<Fq, any, string>;
+    /** Point. Serialized as a hex string. */
+    Point: z.ZodType<Point, any, string>;
+    /** Coerces any input to bigint. */
+    BigInt: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    /** Coerces any input to integer number. */
+    Integer: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    /** Coerces input to UInt32. */
+    UInt32: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    /** Accepts a hex string as a Buffer32 type. */
+    Buffer32: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer32, string>;
+    /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
+    Buffer: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer, string>, z.ZodEffects<z.ZodObject<{
+        type: z.ZodLiteral<"Buffer">;
+        data: z.ZodArray<z.ZodNumber, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>;
+    /** Accepts a hex string as a buffer. */
+    BufferHex: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, Buffer, string>;
+    /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
+    HexString: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+};
+export type { EthAddress, Point, Fr, Fq };
+//# sourceMappingURL=schemas.d.ts.map

package/dest/schemas/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/schemas.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAI3C,eAAO,MAAM,OAAO;IAClB,4BAA4B;;IAG5B,4BAA4B;;IAG5B,4BAA4B;;IAG5B,yCAAyC;;IAGzC,mCAAmC;;IAGnC,2CAA2C;;IAG3C,+BAA+B;;IAS/B,+CAA+C;;IAG/C,oGAAoG;;;;;;;;;;;;;;IAWpG,wCAAwC;;IAOxC,uFAAuF;;CAExF,CAAC;AAGF,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC"}

package/dest/schemas/schemas.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { Buffer32 } from '../buffer/buffer32.js';
+import { EthAddress } from '../eth-address/index.js';
+import { Fq, Fr } from '../fields/fields.js';
+import { Point } from '../fields/point.js';
+import { isHex, withoutHexPrefix } from '../string/index.js';
+import { bufferSchema, hexSchema } from './utils.js';
+export const schemas = {
+    /** Accepts a hex string. */ EthAddress: EthAddress.schema,
+    /** Accepts a hex string. */ Fr: Fr.schema,
+    /** Accepts a hex string. */ Fq: Fq.schema,
+    /** Point. Serialized as a hex string. */ Point: Point.schema,
+    /** Coerces any input to bigint. */ BigInt: z.union([
+        z.bigint(),
+        z.number(),
+        z.string()
+    ]).pipe(z.coerce.bigint()),
+    /** Coerces any input to integer number. */ Integer: z.union([
+        z.bigint(),
+        z.number(),
+        z.string()
+    ]).pipe(z.coerce.number().int()),
+    /** Coerces input to UInt32. */ UInt32: z.union([
+        z.bigint(),
+        z.number(),
+        z.string()
+    ]).pipe(z.coerce.number().int().min(0).max(2 ** 32 - 1)),
+    /** Accepts a hex string as a Buffer32 type. */ Buffer32: z.string().refine(isHex, 'Not a valid hex string').transform(Buffer32.fromString),
+    /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */ Buffer: z.union([
+        bufferSchema,
+        z.object({
+            type: z.literal('Buffer'),
+            data: z.array(z.number().int().min(0).max(255))
+        }).transform(({ data })=>Buffer.from(data))
+    ]),
+    /** Accepts a hex string as a buffer. */ BufferHex: z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix).transform((data)=>Buffer.from(data, 'hex')),
+    /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */ HexString: hexSchema
+};

package/dest/schemas/types.d.ts

@@ -0,0 +1,3 @@
+import type { ZodType } from 'zod';
+export type ZodFor<T> = ZodType<T, any, any>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schemas/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC"}

package/dest/schemas/types.js

@@ -0,0 +1 @@
+export { };

package/dest/schemas/utils.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type ParseInput, type ParseReturnType, type ZodObject, ZodOptional, type ZodRawShape, type ZodType, type ZodTypeAny, z } from 'zod';
+import type { ZodFor } from './types.js';
+export declare const hexSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/** Schema for a buffer represented as a base64 string. */
+export declare const bufferSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer, string>;
+export declare class ZodNullableOptional<T extends ZodTypeAny> extends ZodOptional<T> {
+    _isNullableOptional: boolean;
+    _parse(input: ParseInput): ParseReturnType<this['_output']>;
+    static create<T extends ZodTypeAny>(type: T): ZodNullableOptional<T>;
+}
+/**
+ * Declares a parameter as optional. Use this over z.optional in order to accept nulls as undefineds.
+ * This is required as JSON does not have an undefined type, and null is used to represent it, so we
+ * need to convert nulls to undefineds as we parse.
+ */
+export declare function optional<T extends ZodTypeAny>(schema: T): ZodNullableOptional<T>;
+type ToJsonIs<T, TRet> = T extends {
+    toJSON(): TRet;
+} ? T : never;
+/**
+ * Creates a schema that accepts a hex string and uses it to hydrate an instance.
+ * @param klazz - Class that implements either fromString or fromBuffer.
+ * @returns A schema for the class.
+ */
+export declare function hexSchemaFor<TClass extends {
+    fromString(str: string): any;
+} | {
+    fromBuffer(buf: Buffer): any;
+}>(klazz: TClass, refinement?: (input: string) => boolean): ZodType<TClass extends {
+    fromString(str: string): infer TInstance;
+} | {
+    fromBuffer(buf: Buffer): infer TInstance;
+} ? ToJsonIs<TInstance, string> : never, any, string>;
+/**
+ * Creates a schema that accepts a base64 string and uses it to hydrate an instance.
+ * @param klazz - Class that implements fromBuffer.
+ * @returns A schema for the class.
+ */
+export declare function bufferSchemaFor<TClass extends {
+    fromBuffer(buf: Buffer): any;
+}>(klazz: TClass): ZodType<TClass extends {
+    fromBuffer(buf: Buffer): infer TInstance;
+} ? ToJsonIs<TInstance, Buffer> : never, any, string>;
+/** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */
+export declare function mapSchema<TKey, TValue>(key: ZodFor<TKey>, value: ZodFor<TValue>): ZodFor<Map<TKey, TValue>>;
+/** Creates a schema for a js Set type that matches the serialization used in jsonStringify. */
+export declare function setSchema<T>(value: ZodFor<T>): ZodFor<Set<T>>;
+/** Given an already parsed and validated object, extracts the keys defined in the given schema. Does not validate again. */
+export declare function pickFromSchema<T extends object, S extends ZodObject<ZodRawShape>>(obj: T, schema: S): Partial<T>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dest/schemas/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/schemas/utils.ts"],"names":[],"mappings":";;AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,eAAe,EAEpB,KAAK,SAAS,EACd,WAAW,EAEX,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,CAAC,EACF,MAAM,KAAK,CAAC;AAIb,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,SAAS,yEAAiF,CAAC;AAKxG,0DAA0D;AAC1D,eAAO,MAAM,YAAY,yEAKwB,CAAC;AAElD,qBAAa,mBAAmB,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC3E,mBAAmB,UAAQ;IAElB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;WAQpD,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC;CAM9E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,0BAEvD;AAED,KAAK,QAAQ,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,SAAS;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC;AAElE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7G,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GACtC,OAAO,CACR,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GACtG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAC3B,KAAK,EACT,GAAG,EACH,MAAM,CACP,CAMA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7E,KAAK,EAAE,MAAM,GACZ,OAAO,CACR,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,KAAK,EACjG,GAAG,EACH,MAAM,CACP,CAEA;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAE3G;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAE7D;AAED,4HAA4H;AAC5H,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,cAEnG"}

package/dest/schemas/utils.js

@@ -0,0 +1,60 @@
+import { OK, ZodFirstPartyTypeKind, ZodOptional, ZodParsedType, z } from 'zod';
+import { pick } from '../collection/object.js';
+import { isHex, withoutHexPrefix } from '../string/index.js';
+export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
+// Copied from zod internals, which was copied from https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
+const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+/** Schema for a buffer represented as a base64 string. */ export const bufferSchema = z.string()// We only test the str for base64 if it's shorter than 1024 bytes, otherwise we've run into maximum
+// stack size exceeded errors when trying to validate excessively long strings (such as contract bytecode).
+.refine((str)=>str.length > 1024 || base64Regex.test(str), 'Not a valid base64 string').transform((data)=>Buffer.from(data, 'base64'));
+export class ZodNullableOptional extends ZodOptional {
+    _isNullableOptional = true;
+    _parse(input) {
+        const parsedType = this._getType(input);
+        if (parsedType === ZodParsedType.undefined || parsedType === ZodParsedType.null) {
+            return OK(undefined);
+        }
+        return this._def.innerType._parse(input);
+    }
+    static create(type) {
+        return new ZodNullableOptional({
+            innerType: type,
+            typeName: ZodFirstPartyTypeKind.ZodOptional
+        });
+    }
+}
+/**
+ * Declares a parameter as optional. Use this over z.optional in order to accept nulls as undefineds.
+ * This is required as JSON does not have an undefined type, and null is used to represent it, so we
+ * need to convert nulls to undefineds as we parse.
+ */ export function optional(schema) {
+    return ZodNullableOptional.create(schema);
+}
+/**
+ * Creates a schema that accepts a hex string and uses it to hydrate an instance.
+ * @param klazz - Class that implements either fromString or fromBuffer.
+ * @returns A schema for the class.
+ */ export function hexSchemaFor(klazz, refinement) {
+    const stringSchema = refinement ? z.string().refine(refinement, `Not a valid instance`) : z.string();
+    const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string');
+    return 'fromString' in klazz ? hexSchema.transform(klazz.fromString.bind(klazz)) : hexSchema.transform((str)=>Buffer.from(withoutHexPrefix(str), 'hex')).transform(klazz.fromBuffer.bind(klazz));
+}
+/**
+ * Creates a schema that accepts a base64 string and uses it to hydrate an instance.
+ * @param klazz - Class that implements fromBuffer.
+ * @returns A schema for the class.
+ */ export function bufferSchemaFor(klazz) {
+    return bufferSchema.transform(klazz.fromBuffer.bind(klazz));
+}
+/** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */ export function mapSchema(key, value) {
+    return z.array(z.tuple([
+        key,
+        value
+    ])).transform((entries)=>new Map(entries));
+}
+/** Creates a schema for a js Set type that matches the serialization used in jsonStringify. */ export function setSchema(value) {
+    return z.array(value).transform((entries)=>new Set(entries));
+}
+/** Given an already parsed and validated object, extracts the keys defined in the given schema. Does not validate again. */ export function pickFromSchema(obj, schema) {
+    return pick(obj, ...Object.keys(schema.shape));
+}

package/dest/serialize/buffer_reader.d.ts

@@ -0,0 +1,239 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Tuple } from './types.js';
+/**
+ * The BufferReader class provides a utility for reading various data types from a buffer.
+ * It supports reading numbers, booleans, byte arrays, Fr and Fq field elements,
+ * vectors, arrays, objects, strings, and maps. It maintains an internal index to
+ * keep track of the current reading position in the buffer.
+ *
+ * Usage:
+ * Create a new instance of BufferReader with a buffer and an optional offset.
+ * Use the provided methods to read desired data types from the buffer.
+ * The reading methods automatically advance the internal index.
+ *
+ * @example
+ * const reader = new BufferReader(someBuffer);
+ * const num = reader.readNumber();
+ * const bool = reader.readBoolean();
+ * const byteArray = reader.readBytes(4);
+ */
+export declare class BufferReader {
+    #private;
+    private buffer;
+    private index;
+    constructor(buffer: Buffer, offset?: number);
+    /**
+     * Creates a BufferReader instance from either a Buffer or an existing BufferReader.
+     * If the input is a Buffer, it creates a new BufferReader with the given buffer.
+     * If the input is already a BufferReader, it returns the input unchanged.
+     *
+     * @param bufferOrReader - A Buffer or BufferReader to initialize the BufferReader.
+     * @returns An instance of BufferReader.
+     */
+    static asReader(bufferOrReader: Uint8Array | Buffer | BufferReader): BufferReader;
+    /** Returns true if the underlying buffer has been consumed completely. */
+    isEmpty(): boolean;
+    /**
+     * Reads a 32-bit unsigned integer from the buffer at the current index position.
+     * Updates the index position by 4 bytes after reading the number.
+     *
+     * @returns The read 32-bit unsigned integer value.
+     */
+    readNumber(): number;
+    /**
+     * Reads `count` 32-bit unsigned integers from the buffer at the current index position.
+     * @param count - The number of 32-bit unsigned integers to read.
+     * @returns An array of 32-bit unsigned integers.
+     */
+    readNumbers<N extends number>(count: N): Tuple<number, N>;
+    /**
+     * Reads a 256-bit unsigned integer from the buffer at the current index position.
+     * Updates the index position by 32 bytes after reading the number.
+     *
+     * Assumes the number is stored in big-endian format.
+     *
+     * @returns The read 256 bit value as a bigint.
+     */
+    readUInt256(): bigint;
+    /**
+     * Reads a 16-bit unsigned integer from the buffer at the current index position.
+     * Updates the index position by 2 bytes after reading the number.
+     *
+     * @returns The read 16 bit value.
+     */
+    readUInt16(): number;
+    /**
+     * Reads a 8-bit unsigned integer from the buffer at the current index position.
+     * Updates the index position by 1 byte after reading the number.
+     *
+     * @returns The read 8 bit value.
+     */
+    readUInt8(): number;
+    /**
+     * Reads and returns the next boolean value from the buffer.
+     * Advances the internal index by 1, treating the byte at the current index as a boolean value.
+     * Returns true if the byte is non-zero, false otherwise.
+     *
+     * @returns A boolean value representing the byte at the current index.
+     */
+    readBoolean(): boolean;
+    /**
+     * Reads a specified number of bytes from the buffer and returns a new Buffer containing those bytes.
+     * Advances the reader's index by the number of bytes read. Throws an error if there are not enough
+     * bytes left in the buffer to satisfy the requested number of bytes.
+     *
+     * @param n - The number of bytes to read from the buffer.
+     * @returns A new Buffer containing the read bytes.
+     */
+    readBytes(n: number): Buffer;
+    /** Reads until the end of the buffer. */
+    readToEnd(): Buffer;
+    /**
+     * Reads a vector of numbers from the buffer and returns it as an array of numbers.
+     * The method utilizes the 'readVector' method, passing a deserializer that reads numbers.
+     *
+     * @returns An array of numbers representing the vector read from the buffer.
+     */
+    readNumberVector(): number[];
+    /**
+     * Reads a vector of fixed size from the buffer and deserializes its elements using the provided itemDeserializer object.
+     * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance and returns the deserialized element.
+     * The method first reads the size of the vector (a number) from the buffer, then iterates through its elements,
+     * deserializing each one using the 'fromBuffer' method of 'itemDeserializer'.
+     *
+     * @param itemDeserializer - Object with 'fromBuffer' method to deserialize vector elements.
+     * @returns An array of deserialized elements of type T.
+     */
+    readVector<T>(itemDeserializer: {
+        /**
+         * A method to deserialize data from a buffer.
+         */
+        fromBuffer: (reader: BufferReader) => T;
+    }): T[];
+    /**
+     * Reads a vector of fixed size from the buffer and deserializes its elements using the provided itemDeserializer object.
+     * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance and returns the deserialized element.
+     * The method first reads the size of the vector (a number) from the buffer, then iterates through its elements,
+     * deserializing each one using the 'fromBuffer' method of 'itemDeserializer'.
+     *
+     * @param itemDeserializer - Object with 'fromBuffer' method to deserialize vector elements.
+     * @returns An array of deserialized elements of type T.
+     */
+    readVectorUint8Prefix<T>(itemDeserializer: {
+        /**
+         * A method to deserialize data from a buffer.
+         */
+        fromBuffer: (reader: BufferReader) => T;
+    }): T[];
+    /**
+     * Read an array of a fixed size with elements of type T from the buffer.
+     * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance as input,
+     * and returns an instance of the desired deserialized data type T.
+     * This method will call the 'fromBuffer' method for each element in the array and return the resulting array.
+     *
+     * @param size - The fixed number of elements in the array.
+     * @param itemDeserializer - An object with a 'fromBuffer' method to deserialize individual elements of type T.
+     * @returns An array of instances of type T.
+     */
+    readArray<T, N extends number>(size: N, itemDeserializer: {
+        /**
+         * A function for deserializing data from a BufferReader instance.
+         */
+        fromBuffer: (reader: BufferReader) => T;
+    }): Tuple<T, N>;
+    /**
+     * Read a variable sized Buffer array where elements are represented by length + data.
+     * The method consecutively looks for a number which is the size of the proceeding buffer,
+     * then reads the bytes until it reaches the end of the reader's internal buffer.
+     * NOTE: if `size` is not provided, this will run to the end of the reader's buffer.
+     * @param size - Size of the buffer array in bytes (full remaining buffer length if left empty).
+     * @returns An array of variable sized buffers.
+     */
+    readBufferArray(size?: number): Buffer[];
+    /**
+     * Reads a serialized object from a buffer and returns the deserialized object using the given deserializer.
+     *
+     * @typeparam T - The type of the deserialized object.
+     * @param deserializer - An object with a 'fromBuffer' method that takes a BufferReader instance and returns an instance of the deserialized object.
+     * @returns The deserialized object of type T.
+     */
+    readObject<T>(deserializer: {
+        /**
+         * A method that takes a BufferReader instance and returns an instance of the deserialized data type.
+         */
+        fromBuffer: (reader: BufferReader) => T;
+    }): T;
+    /**
+     * Returns a Buffer containing the next n bytes from the current buffer without modifying the reader's index position.
+     * If n is not provided or exceeds the remaining length of the buffer, it returns all bytes from the current position till the end of the buffer.
+     *
+     * @param n - The number of bytes to peek from the current buffer. (Optional).
+     * @returns A Buffer with the next n bytes or the remaining bytes if n is not provided or exceeds the buffer length.
+     */
+    peekBytes(n?: number): Buffer;
+    /**
+     * Reads a string from the buffer and returns it.
+     * The method first reads the size of the string, then reads the corresponding
+     * number of bytes from the buffer and converts them to a string.
+     *
+     * @returns The read string from the buffer.
+     */
+    readString(): string;
+    /**
+     * Reads a buffer from the current position of the reader and advances the index.
+     * The method first reads the size (number) of bytes to be read, and then returns
+     * a Buffer with that size containing the bytes. Useful for reading variable-length
+     * binary data encoded as (size, data) format.
+     *
+     * @returns A Buffer containing the read bytes.
+     */
+    readBuffer(): Buffer;
+    /**
+     * Reads a buffer from the current position of the reader and advances the index.
+     * The method first reads the size (number) of bytes to be read, and then returns
+     * a Buffer with that size containing the bytes. Useful for reading variable-length
+     * binary data encoded as (size, data) format.
+     *
+     * @returns A Buffer containing the read bytes.
+     */
+    readUint8Array(): Uint8Array;
+    /**
+     * Reads and constructs a map object from the current buffer using the provided deserializer.
+     * The method reads the number of entries in the map, followed by iterating through each key-value pair.
+     * The key is read as a string, while the value is obtained using the passed deserializer's `fromBuffer` method.
+     * The resulting map object is returned, containing all the key-value pairs read from the buffer.
+     *
+     * @param deserializer - An object with a `fromBuffer` method to deserialize the values in the map.
+     * @returns A map object with string keys and deserialized values based on the provided deserializer.
+     */
+    readMap<T>(deserializer: {
+        /**
+         * Deserializes an element of type T from a BufferReader instance.
+         */
+        fromBuffer: (reader: BufferReader) => T;
+    }): {
+        [key: string]: T;
+    };
+    /**
+     * Get the length of the reader's buffer.
+     * @returns The length of the underlying reader's buffer.
+     */
+    getLength(): number;
+    /**
+     * Gets bytes remaining to be read from the buffer.
+     * @returns Bytes remaining to be read from the buffer.
+     */
+    remainingBytes(): number;
+}
+/**
+ * A deserializer
+ */
+export interface FromBuffer<T> {
+    /**
+     * Deserializes an object from a buffer
+     * @param buffer - The buffer to deserialize.
+     */
+    fromBuffer(buffer: Buffer): T;
+}
+//# sourceMappingURL=buffer_reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_reader.d.ts","sourceRoot":"","sources":["../../src/serialize/buffer_reader.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY;;IAEX,OAAO,CAAC,MAAM;IAD1B,OAAO,CAAC,KAAK,CAAS;gBACF,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI;IAI9C;;;;;;;OAOG;WACW,QAAQ,CAAC,cAAc,EAAE,UAAU,GAAG,MAAM,GAAG,YAAY,GAAG,YAAY;IAYxF,0EAA0E;IACnE,OAAO,IAAI,OAAO;IAIzB;;;;;OAKG;IACI,UAAU,IAAI,MAAM;IAM3B;;;;OAIG;IACI,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAKhE;;;;;;;OAOG;IACI,WAAW,IAAI,MAAM;IAY5B;;;;;OAKG;IACI,UAAU,IAAI,MAAM;IAM3B;;;;;OAKG;IACI,SAAS,IAAI,MAAM;IAM1B;;;;;;OAMG;IACI,WAAW,IAAI,OAAO;IAM7B;;;;;;;OAOG;IACI,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAMnC,yCAAyC;IAClC,SAAS,IAAI,MAAM;IAM1B;;;;;OAKG;IACI,gBAAgB,IAAI,MAAM,EAAE;IAMnC;;;;;;;;OAQG;IACI,UAAU,CAAC,CAAC,EAAE,gBAAgB,EAAE;QACrC;;WAEG;QACH,UAAU,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC;KACzC,GAAG,CAAC,EAAE;IASP;;;;;;;;OAQG;IACI,qBAAqB,CAAC,CAAC,EAAE,gBAAgB,EAAE;QAChD;;WAEG;QACH,UAAU,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC;KACzC,GAAG,CAAC,EAAE;IASP;;;;;;;;;OASG;IACI,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAClC,IAAI,EAAE,CAAC,EACP,gBAAgB,EAAE;QAChB;;WAEG;QACH,UAAU,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC;KACzC,GACA,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAKd;;;;;;;OAOG;IACI,eAAe,CAAC,IAAI,SAAK,GAAG,MAAM,EAAE;IAiB3C;;;;;;OAMG;IACI,UAAU,CAAC,CAAC,EAAE,YAAY,EAAE;QACjC;;WAEG;QACH,UAAU,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC;KACzC,GAAG,CAAC;IAIL;;;;;;OAMG;IACI,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAKpC;;;;;;OAMG;IACI,UAAU,IAAI,MAAM;IAI3B;;;;;;;OAOG;IACI,UAAU,IAAI,MAAM;IAM3B;;;;;;;OAOG;IACI,cAAc,IAAI,UAAU;IAMnC;;;;;;;;OAQG;IACI,OAAO,CAAC,CAAC,EAAE,YAAY,EAAE;QAC9B;;WAEG;QACH,UAAU,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC;KACzC,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAA;KAAE;IAWxB;;;OAGG;IACI,SAAS,IAAI,MAAM;IAI1B;;;OAGG;IACI,cAAc,IAAI,MAAM;CAWhC;AAED;;GAEG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC;CAC/B"}