@layerzerolabs/lz-serdes 2.3.34

package/dist/index.d.mts

@@ -0,0 +1,276 @@
+type Seq<T> = T[];
+type Uint8 = number;
+type Uint16 = number;
+type Uint32 = number;
+type Uint64 = bigint;
+type Uint128 = bigint;
+type Uint256 = bigint;
+type AnyNumber = bigint | number;
+type Bytes = Uint8Array;
+
+declare class Serializer {
+    private buffer;
+    private offset;
+    private littleEndian;
+    constructor(littleEndian?: boolean);
+    private ensureBufferWillHandleSize;
+    protected serialize(values: Bytes): void;
+    private serializeWithFunction;
+    /**
+     * Serializes a string. UTF8 string is supported. Serializes the string's bytes length "l" first,
+     * and then serializes "l" bytes of the string content.
+     *
+     * layout for "string": string_length | string_content. string_length is the bytes length of
+     * the string that is uleb128/ubeb128 encoded. string_length is a u32 integer.
+     *
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeStr("çå∞≠¢õß∂ƒ∫");
+     * assert(serializer.getBytes() === new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
+     * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]));
+     * ```
+     */
+    serializeStr(value: string): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Serializes a boolean value.
+     *
+     * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
+     */
+    serializeBool(value: boolean): void;
+    /**
+     * Serializes a uint8 number.
+     *
+     * layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    serializeU8(value: Uint8): void;
+    /**
+     * Serializes a uint16 number.
+     *
+     * layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU16(4660);
+     * assert(serializer.getBytes() === new Uint8Array([0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU16(4660);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34]));
+     * ```
+     */
+    serializeU16(value: Uint16): void;
+    /**
+     * Serializes a uint32 number.
+     *
+     * layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU32(305419896);
+     * assert(serializer.getBytes() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU32(305419896);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78]));
+     * ```
+     */
+    serializeU32(value: Uint32): void;
+    /**
+     * Serializes a uint64 number.
+     *
+     * layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU64(1311768467750121216);
+     * assert(serializer.getBytes() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU64(1311768467750121216);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]));
+     * ```
+     */
+    serializeU64(value: AnyNumber): void;
+    /**
+     * Serializes a uint128 number.
+     *
+     * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU128(value: AnyNumber): void;
+    /**
+     * Serializes a uint256 number.
+     *
+     * layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU256(value: AnyNumber): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Returns the buffered bytes
+     */
+    getBytes(): Bytes;
+}
+
+declare class Deserializer {
+    private buffer;
+    private offset;
+    private littleEndian;
+    constructor(data: Bytes, littleEndian?: boolean);
+    private read;
+    /**
+     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
+     * and then reads "l" bytes of content. Decodes the byte array into a string.
+     *
+     * layout for "string": string_length | string_content. string_length is the bytes length of
+     * the string that is uleb128/ubeb128 encoded. string_length is a u32 integer.
+     *
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
+     * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]), true);
+     * assert(deserializer.deserializeStr() === "çå∞≠¢õß∂ƒ∫");
+     * ```
+     */
+    deserializeStr(): string;
+    /**
+     * Deserializes 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.
+     */
+    deserializeBytes(): Bytes;
+    /**
+     * Deserializes an array of bytes. The number of bytes to read is already known.
+     *
+     */
+    deserializeFixedBytes(len: number): Bytes;
+    /**
+     * Deserializes a boolean value.
+     *
+     * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
+     */
+    deserializeBool(): boolean;
+    /**
+     * Deserializes a uint8 number.
+     *
+     * layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    deserializeU8(): Uint8;
+    /**
+     * Deserializes a uint16 number.
+     *
+     * layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]), true);
+     * assert(deserializer.deserializeU16() === 4660);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34]), false);
+     * assert(deserializer.deserializeU16() === 4660);
+     * ```
+     */
+    deserializeU16(): Uint16;
+    /**
+     * Deserializes a uint32 number.
+     *
+     * layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]), true);
+     * assert(deserializer.deserializeU32() === 305419896);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78]), false);
+     * assert(deserializer.deserializeU32() === 305419896);
+     * ```
+     */
+    deserializeU32(): Uint32;
+    /**
+     * Deserializes a uint64 number.
+     *
+     * layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]), true);
+     * assert(deserializer.deserializeU64() === 1311768467750121216);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]), false);
+     * assert(deserializer.deserializeU64() === 1311768467750121216);
+     * ```
+     */
+    deserializeU64(): Uint64;
+    /**
+     * Deserializes a uint128 number.
+     *
+     * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    deserializeU128(): Uint128;
+    /**
+     * Deserializes a uint256 number.
+     *
+     * layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     */
+    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
+     */
+    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
+     */
+    deserializeUbeb128AsU32(): Uint32;
+}
+
+interface Serializable {
+    serialize(serializer: Serializer): void;
+}
+interface Deserializable<T> {
+    deserialize(deserializer: Deserializer): T;
+}
+/**
+ * Serializes a vector values that are "Serializable".
+ */
+declare function serializeVector<T extends Serializable>(value: Seq<T>, serializer: Serializer): void;
+/**
+ * Serializes a vector with specified item serialization function.
+ * Very dynamic function and bypasses static typechecking.
+ */
+declare function serializeVectorWithFunc(value: unknown[], func: string): Bytes;
+/**
+ * Deserializes a vector of values.
+ */
+declare function deserializeVector<T>(deserializer: Deserializer, cls: Deserializable<T>): any[];
+declare function bcsToBytes<T extends Serializable>(value: T): Bytes;
+declare function bcsSerializeUint64(value: AnyNumber): Bytes;
+declare function bcsSerializeU8(value: Uint8): Bytes;
+declare function bcsSerializeU16(value: Uint16): Bytes;
+declare function bcsSerializeU32(value: Uint32): Bytes;
+declare function bcsSerializeU128(value: AnyNumber): Bytes;
+declare function bcsSerializeU256(value: AnyNumber): Bytes;
+declare function bcsSerializeBool(value: boolean): Bytes;
+declare function bcsSerializeStr(value: string): Bytes;
+declare function bcsSerializeBytes(value: Bytes): 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 };

package/dist/index.d.ts

@@ -0,0 +1,276 @@
+type Seq<T> = T[];
+type Uint8 = number;
+type Uint16 = number;
+type Uint32 = number;
+type Uint64 = bigint;
+type Uint128 = bigint;
+type Uint256 = bigint;
+type AnyNumber = bigint | number;
+type Bytes = Uint8Array;
+
+declare class Serializer {
+    private buffer;
+    private offset;
+    private littleEndian;
+    constructor(littleEndian?: boolean);
+    private ensureBufferWillHandleSize;
+    protected serialize(values: Bytes): void;
+    private serializeWithFunction;
+    /**
+     * Serializes a string. UTF8 string is supported. Serializes the string's bytes length "l" first,
+     * and then serializes "l" bytes of the string content.
+     *
+     * layout for "string": string_length | string_content. string_length is the bytes length of
+     * the string that is uleb128/ubeb128 encoded. string_length is a u32 integer.
+     *
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeStr("çå∞≠¢õß∂ƒ∫");
+     * assert(serializer.getBytes() === new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
+     * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]));
+     * ```
+     */
+    serializeStr(value: string): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Serializes a boolean value.
+     *
+     * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
+     */
+    serializeBool(value: boolean): void;
+    /**
+     * Serializes a uint8 number.
+     *
+     * layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    serializeU8(value: Uint8): void;
+    /**
+     * Serializes a uint16 number.
+     *
+     * layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU16(4660);
+     * assert(serializer.getBytes() === new Uint8Array([0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU16(4660);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34]));
+     * ```
+     */
+    serializeU16(value: Uint16): void;
+    /**
+     * Serializes a uint32 number.
+     *
+     * layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU32(305419896);
+     * assert(serializer.getBytes() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU32(305419896);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78]));
+     * ```
+     */
+    serializeU32(value: Uint32): void;
+    /**
+     * Serializes a uint64 number.
+     *
+     * layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer(true);
+     * serializer.serializeU64(1311768467750121216);
+     * assert(serializer.getBytes() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
+     * const serializer = new Serializer(false);
+     * serializer.serializeU64(1311768467750121216);
+     * assert(serializer.getBytes() === new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]));
+     * ```
+     */
+    serializeU64(value: AnyNumber): void;
+    /**
+     * Serializes a uint128 number.
+     *
+     * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU128(value: AnyNumber): void;
+    /**
+     * Serializes a uint256 number.
+     *
+     * layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU256(value: AnyNumber): void;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Returns the buffered bytes
+     */
+    getBytes(): Bytes;
+}
+
+declare class Deserializer {
+    private buffer;
+    private offset;
+    private littleEndian;
+    constructor(data: Bytes, littleEndian?: boolean);
+    private read;
+    /**
+     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
+     * and then reads "l" bytes of content. Decodes the byte array into a string.
+     *
+     * layout for "string": string_length | string_content. string_length is the bytes length of
+     * the string that is uleb128/ubeb128 encoded. string_length is a u32 integer.
+     *
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
+     * 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]), true);
+     * assert(deserializer.deserializeStr() === "çå∞≠¢õß∂ƒ∫");
+     * ```
+     */
+    deserializeStr(): string;
+    /**
+     * Deserializes 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.
+     */
+    deserializeBytes(): Bytes;
+    /**
+     * Deserializes an array of bytes. The number of bytes to read is already known.
+     *
+     */
+    deserializeFixedBytes(len: number): Bytes;
+    /**
+     * Deserializes a boolean value.
+     *
+     * layout for "boolean": One byte. "0x01" for True and "0x00" for False.
+     */
+    deserializeBool(): boolean;
+    /**
+     * Deserializes a uint8 number.
+     *
+     * layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    deserializeU8(): Uint8;
+    /**
+     * Deserializes a uint16 number.
+     *
+     * layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]), true);
+     * assert(deserializer.deserializeU16() === 4660);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34]), false);
+     * assert(deserializer.deserializeU16() === 4660);
+     * ```
+     */
+    deserializeU16(): Uint16;
+    /**
+     * Deserializes a uint32 number.
+     *
+     * layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]), true);
+     * assert(deserializer.deserializeU32() === 305419896);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78]), false);
+     * assert(deserializer.deserializeU32() === 305419896);
+     * ```
+     */
+    deserializeU32(): Uint32;
+    /**
+     * Deserializes a uint64 number.
+     *
+     * layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]), true);
+     * assert(deserializer.deserializeU64() === 1311768467750121216);
+     * const deserializer = new Deserializer(new Uint8Array([0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD, 0xEF, 0x00]), false);
+     * assert(deserializer.deserializeU64() === 1311768467750121216);
+     * ```
+     */
+    deserializeU64(): Uint64;
+    /**
+     * Deserializes a uint128 number.
+     *
+     * layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    deserializeU128(): Uint128;
+    /**
+     * Deserializes a uint256 number.
+     *
+     * layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     */
+    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
+     */
+    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
+     */
+    deserializeUbeb128AsU32(): Uint32;
+}
+
+interface Serializable {
+    serialize(serializer: Serializer): void;
+}
+interface Deserializable<T> {
+    deserialize(deserializer: Deserializer): T;
+}
+/**
+ * Serializes a vector values that are "Serializable".
+ */
+declare function serializeVector<T extends Serializable>(value: Seq<T>, serializer: Serializer): void;
+/**
+ * Serializes a vector with specified item serialization function.
+ * Very dynamic function and bypasses static typechecking.
+ */
+declare function serializeVectorWithFunc(value: unknown[], func: string): Bytes;
+/**
+ * Deserializes a vector of values.
+ */
+declare function deserializeVector<T>(deserializer: Deserializer, cls: Deserializable<T>): any[];
+declare function bcsToBytes<T extends Serializable>(value: T): Bytes;
+declare function bcsSerializeUint64(value: AnyNumber): Bytes;
+declare function bcsSerializeU8(value: Uint8): Bytes;
+declare function bcsSerializeU16(value: Uint16): Bytes;
+declare function bcsSerializeU32(value: Uint32): Bytes;
+declare function bcsSerializeU128(value: AnyNumber): Bytes;
+declare function bcsSerializeU256(value: AnyNumber): Bytes;
+declare function bcsSerializeBool(value: boolean): Bytes;
+declare function bcsSerializeStr(value: string): Bytes;
+declare function bcsSerializeBytes(value: Bytes): 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 };