@layerzerolabs/lz-serdes 3.0.15 → 3.0.17

package/dist/index.d.mts

@@ -1,20 +1,74 @@
+/**
+ * Type representing a sequence of elements.
+ * @template T - The type of elements in the sequence.
+ */
 type Seq<T> = T[];
+/**
+ * Type representing an 8-bit unsigned integer.
+ */
 type Uint8 = number;
+/**
+ * Type representing a 16-bit unsigned integer.
+ */
 type Uint16 = number;
+/**
+ * Type representing a 32-bit unsigned integer.
+ */
 type Uint32 = number;
+/**
+ * Type representing a 64-bit unsigned integer.
+ */
 type Uint64 = bigint;
+/**
+ * Type representing a 128-bit unsigned integer.
+ */
 type Uint128 = bigint;
+/**
+ * Type representing a 256-bit unsigned integer.
+ */
 type Uint256 = bigint;
+/**
+ * Type representing a number that can be either a bigint or a number.
+ */
 type AnyNumber = bigint | number;
+/**
+ * Type representing a byte array.
+ */
 type Bytes = Uint8Array;
 
+/**
+ * Class representing a serializer for various data types.
+ */
 declare class Serializer {
     private buffer;
     private offset;
     readonly littleEndian: boolean;
+    /**
+     * Creates an instance of Serializer.
+     *
+     * @param {boolean} [littleEndian=true] - Whether to use little-endian byte order.
+     */
     constructor(littleEndian?: boolean);
+    /**
+     * Ensures that the buffer has enough space to handle the specified number of bytes.
+     * If the buffer is not large enough, it will be resized to accommodate the additional bytes.
+     *
+     * @param {number} bytes - The number of bytes to ensure space for.
+     */
     private ensureBufferWillHandleSize;
+    /**
+     * Serializes the given byte values into the buffer.
+     *
+     * @param {Bytes} values - The byte values to serialize.
+     */
     protected serialize(values: Bytes): void;
+    /**
+     * Serializes a value using the specified DataView function.
+     *
+     * @param {(byteOffset: number, value: number, littleEndian?: boolean) => void} fn - The DataView function to use for serialization.
+     * @param {number} bytesLength - The length of the bytes to serialize.
+     * @param {number} value - The value to serialize.
+     */
     private serializeWithFunction;
     /**
      * Serializes a string. UTF8 string is supported. Serializes the string's bytes length "l" first,
@@ -31,32 +85,32 @@ declare class Serializer {
      * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]));
      * ```
      */
-    serializeStr(value: string): void;
+    serializeStr(value: string): this;
     /**
      * Serializes an array of bytes.
      *
      * layout for "bytes": bytes_length | bytes. bytes_length is the length of the bytes array that is
      * uleb128/ubeb128 encoded. bytes_length is a u32 integer.
      */
-    serializeBytes(value: Bytes): void;
+    serializeBytes(value: Bytes): this;
     /**
      * Serializes an array of bytes with known length. Therefore length doesn't need to be
      * serialized to help deserialization.  When deserializing, the number of
      * bytes to deserialize needs to be passed in.
      */
-    serializeFixedBytes(value: Bytes): void;
+    serializeFixedBytes(value: Bytes): this;
     /**
      * Serializes a boolean value.
      *
      * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
      */
-    serializeBool(value: boolean): void;
+    serializeBool(value: boolean): this;
     /**
      * Serializes a uint8 number.
      *
      * layout for "uint8": One byte. Binary format in little-endian representation.
      */
-    serializeU8(value: Uint8): void;
+    serializeU8(value: Uint8): this;
     /**
      * Serializes a uint16 number.
      *
@@ -71,7 +125,7 @@ declare class Serializer {
      * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34]));
      * ```
      */
-    serializeU16(value: Uint16): void;
+    serializeU16(value: Uint16): this;
     /**
      * Serializes a uint32 number.
      *
@@ -86,7 +140,7 @@ declare class Serializer {
      * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78]));
      * ```
      */
-    serializeU32(value: Uint32): void;
+    serializeU32(value: Uint32): this;
     /**
      * Serializes a uint64 number.
      *
@@ -101,44 +155,72 @@ declare class Serializer {
      * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]));
      * ```
      */
-    serializeU64(value: AnyNumber): void;
+    serializeU64(value: AnyNumber): this;
     /**
      * Serializes a uint128 number.
      *
      * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
      */
-    serializeU128(value: AnyNumber): void;
+    serializeU128(value: AnyNumber): this;
     /**
      * Serializes a uint256 number.
      *
      * layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
      */
-    serializeU256(value: AnyNumber): void;
+    serializeU256(value: AnyNumber): this;
     /**
      * Serializes a uint32 number with uleb128.
      *
      * use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
      */
-    serializeU32AsUleb128(val: Uint32): void;
+    serializeU32AsUleb128(val: Uint32): this;
     /**
      * Serializes a uint32 number with unsigned Variable-Length Big-Endian Encoding.
      *
      * use ubeb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
      */
-    serializeU32AsUbeb128(val: Uint32): void;
+    serializeU32AsUbeb128(val: Uint32): this;
     /**
      * Returns the buffered bytes
+     *
+     * @returns {Bytes} The buffered bytes.
      */
     getBytes(): Bytes;
 }
 
+/**
+ * Class representing a deserializer for various data types.
+ */
 declare class Deserializer {
     private buffer;
     private offset;
     readonly littleEndian: boolean;
+    /**
+     * Creates an instance of Deserializer.
+     *
+     * @param {Bytes} data - The data to deserialize.
+     * @param {boolean} [littleEndian=true] - Whether to use little-endian byte order.
+     */
     constructor(data: Bytes, littleEndian?: boolean);
+    /**
+     * Reads a specified number of bytes from the buffer.
+     *
+     * @param {number} length - The number of bytes to read.
+     * @returns {ArrayBuffer} The read bytes.
+     * @throws {Error} If the end of the buffer is reached.
+     */
     private read;
+    /**
+     * Returns the number of remaining bytes in the buffer.
+     *
+     * @returns {number} The number of remaining bytes.
+     */
     remaining(): number;
+    /**
+     * Rewinds the buffer by a specified number of bytes.
+     *
+     * @param {number} length - The number of bytes to rewind.
+     */
     rewind(length: number): void;
     /**
      * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
@@ -153,6 +235,7 @@ declare class Deserializer {
      * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]), true);
      * assert(deserializer.deserializeStr() === "çå∞≠¢õß∂ƒ∫");
      * ```
+     * @returns {string} The deserialized string.
      */
     deserializeStr(): string;
     /**
@@ -160,23 +243,32 @@ declare class Deserializer {
      *
      * layout for "bytes": bytes_length | bytes. bytes_length is the length of the bytes array that is
      * uleb128/ubeb128 encoded. bytes_length is a u32 integer.
+     *
+     * @returns {Bytes} The deserialized bytes.
      */
     deserializeBytes(): Bytes;
     /**
      * Deserializes an array of bytes. The number of bytes to read is already known.
      *
+     * @param {number} len - The number of bytes to read.
+     * @returns {Bytes} The deserialized bytes.
      */
     deserializeFixedBytes(len: number): Bytes;
     /**
      * Deserializes a boolean value.
      *
      * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
+     *
+     * @returns {boolean} The deserialized boolean value.
+     * @throws {Error} If the boolean value is invalid.
      */
     deserializeBool(): boolean;
     /**
      * Deserializes a uint8 number.
      *
      * layout for "uint8": One byte. Binary format in little-endian representation.
+     *
+     * @returns {Uint8} The deserialized uint8 number.
      */
     deserializeU8(): Uint8;
     /**
@@ -190,6 +282,7 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34]), false);
      * assert(deserializer.deserializeU16() === 4660);
      * ```
+     * @returns {Uint16} The deserialized uint16 number.
      */
     deserializeU16(): Uint16;
     /**
@@ -203,6 +296,7 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78]), false);
      * assert(deserializer.deserializeU32() === 305419896);
      * ```
+     * @returns {Uint32} The deserialized uint32 number.
      */
     deserializeU32(): Uint32;
     /**
@@ -216,63 +310,169 @@ declare class Deserializer {
      * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]), false);
      * assert(deserializer.deserializeU64() === 1311768467750121216);
      * ```
+     * @returns {Uint64} The deserialized uint64 number.
      */
     deserializeU64(): Uint64;
     /**
      * Deserializes a uint128 number.
      *
      * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     *
+     * @returns {Uint128} The deserialized uint128 number.
      */
     deserializeU128(): Uint128;
     /**
      * Deserializes a uint256 number.
      *
      * layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     *
+     * @returns {Uint256} The deserialized uint256 number.
      */
     deserializeU256(): Uint256;
     /**
      * Deserializes a uleb128 encoded uint32 number.
      *
      * use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     *
+     * @returns {Uint32} The deserialized uleb128 encoded uint32 number.
+     * @throws {Error} If there is an overflow while parsing the value.
      */
     deserializeUleb128AsU32(): Uint32;
     /**
      * Deserializes a unsigned Variable-Length Big-Endian Encoding encoded uint32 number.
      *
      * use ubeb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     *
+     * @returns {Uint32} The deserialized ubeb128 encoded uint32 number.
+     * @throws {Error} If there is an overflow while parsing the value.
      */
     deserializeUbeb128AsU32(): Uint32;
 }
 
+/**
+ * Interface representing a serializable object.
+ */
 interface Serializable {
+    /**
+     * Serializes the object using the provided serializer.
+     *
+     * @param {Serializer} serializer - The serializer to use.
+     */
     serialize(serializer: Serializer): void;
 }
+/**
+ * Interface representing a deserializable object.
+ */
 interface Deserializable<T> {
+    /**
+     * Deserializes the object using the provided deserializer.
+     *
+     * @param {Deserializer} deserializer - The deserializer to use.
+     * @returns {T} The deserialized object.
+     */
     deserialize(deserializer: Deserializer): T;
 }
 /**
- * Serializes a vector values that are "Serializable".
+ * Serializes a vector of values that are "Serializable".
+ *
+ * @param {Seq<T>} value - The vector of values to serialize.
+ * @param {Serializer} serializer - The serializer to use.
  */
 declare function serializeVector<T extends Serializable>(value: Seq<T>, serializer: Serializer): void;
 /**
- * Serializes a vector with specified item serialization function.
+ * Serializes a vector with a specified item serialization function.
  * Very dynamic function and bypasses static typechecking.
+ *
+ * @param {unknown[]} value - The vector of values to serialize.
+ * @param {string} func - The name of the serialization function to use.
+ * @returns {Bytes} The serialized bytes.
+ * @throws {Error} If the specified function does not exist on the serializer.
  */
 declare function serializeVectorWithFunc(value: unknown[], func: string): Bytes;
 /**
  * Deserializes a vector of values.
+ *
+ * @param {Deserializer} deserializer - The deserializer to use.
+ * @param {Deserializable<T>} cls - The class to use for deserialization.
+ * @returns {T[]} The deserialized vector of values.
  */
 declare function deserializeVector<T>(deserializer: Deserializer, cls: Deserializable<T>): any[];
+/**
+ * Serializes a value to bytes using BCS (Binary Canonical Serialization).
+ *
+ * @param {T} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsToBytes<T extends Serializable>(value: T): Bytes;
+/**
+ * Serializes a uint64 value to bytes using BCS.
+ *
+ * @param {AnyNumber} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeUint64(value: AnyNumber): Bytes;
+/**
+ * Serializes a uint8 value to bytes using BCS.
+ *
+ * @param {Uint8} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeU8(value: Uint8): Bytes;
+/**
+ * Serializes a uint16 value to bytes using BCS.
+ *
+ * @param {Uint16} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeU16(value: Uint16): Bytes;
+/**
+ * Serializes a uint32 value to bytes using BCS.
+ *
+ * @param {Uint32} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeU32(value: Uint32): Bytes;
+/**
+ * Serializes a uint128 value to bytes using BCS.
+ *
+ * @param {AnyNumber} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeU128(value: AnyNumber): Bytes;
+/**
+ * Serializes a uint256 value to bytes using BCS.
+ *
+ * @param {AnyNumber} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeU256(value: AnyNumber): Bytes;
+/**
+ * Serializes a boolean value to bytes using BCS.
+ *
+ * @param {boolean} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeBool(value: boolean): Bytes;
+/**
+ * Serializes a string value to bytes using BCS.
+ *
+ * @param {string} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeStr(value: string): Bytes;
+/**
+ * Serializes a byte array to bytes using BCS.
+ *
+ * @param {Bytes} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeBytes(value: Bytes): Bytes;
+/**
+ * Serializes a fixed-length byte array to bytes using BCS.
+ *
+ * @param {Bytes} value - The value to serialize.
+ * @returns {Bytes} The serialized bytes.
+ */
 declare function bcsSerializeFixedBytes(value: Bytes): Bytes;
 
 export { type AnyNumber, type Bytes, Deserializer, type Seq, Serializer, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, bcsSerializeBool, bcsSerializeBytes, bcsSerializeFixedBytes, bcsSerializeStr, bcsSerializeU128, bcsSerializeU16, bcsSerializeU256, bcsSerializeU32, bcsSerializeU8, bcsSerializeUint64, bcsToBytes, deserializeVector, serializeVector, serializeVectorWithFunc };