Constructs a serializer with a buffer of size length bytes, 64 bytes by default.
The length must be greater than 0.
The size of the buffer in bytes.
Serializes a Serializable value, facilitating composable serialization.
The Serializable value to serialize.
the serializer instance
Serializes a boolean value into a byte representation.
The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
The boolean value to serialize.
Serializes an array of bytes.
This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself. BCS layout for "bytes": bytes_length | bytes where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
The byte array to serialize.
Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the length itself. When deserializing, the number of bytes to deserialize needs to be passed in.
The Uint8Array to be serialized.
Serializes a 128-bit signed integer value.
The 128-bit signed integer value to serialize.
Serializes a 16-bit signed integer value into a binary format. BCS layout for "int16": Two bytes. Binary format in little-endian representation.
The 16-bit signed integer value to serialize.
Serializes a 256-bit signed integer value.
The 256-bit signed integer value to serialize.
Serializes a 32-bit signed integer value into a binary format.
The 32-bit signed integer value to serialize.
Serializes a 64-bit signed integer into a format suitable for storage or transmission. This function uses two's complement representation for negative values.
The 64-bit signed integer to serialize.
Serializes an 8-bit signed integer value. BCS layout for "int8": One byte. Binary format in little-endian representation.
The 8-bit signed integer value to serialize.
Serializes an optional value which can be a Serializable, string, or Uint8Array. For strings and Uint8Arrays, it uses the appropriate serialization method.
Optionalvalue: TThe value to serialize (Serializable, string, Uint8Array, or undefined)
Optionallen: numberOptional fixed length for Uint8Array serialization. If provided, uses serializeFixedBytes instead of serializeBytes
const serializer = new Serializer();
serializer.serializeOption("hello"); // Serializes optional string
serializer.serializeOption(new Uint8Array([1, 2, 3])); // Serializes optional bytes
serializer.serializeOption(new Uint8Array([1, 2, 3]), 3); // Serializes optional fixed-length bytes
serializer.serializeOption(new AccountAddress(...)); // Serializes optional Serializable
serializer.serializeOption(undefined); // Serializes none case
Optionalvalue: stringThe optional string to serialize. If undefined, it will serialize as 0.
use serializeOption instead.
Serializes an optional string, supporting UTF8 encoding.
The function encodes the existence of the string first, followed by the length and content if it exists.
BCS layout for optional "string": 1 | string_length | string_content where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content. BCS layout for undefined: 0
Serializes a string. UTF8 string is supported. The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer. Then the string content is serialized as UTF8 encoded bytes.
BCS layout for "string": string_length | string_content where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
The string to serialize.
Serializes a U128 value into a format suitable for storage or transmission.
The U128 value to serialize, represented as a number.
Serializes a 16-bit unsigned integer value into a binary format. BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
The 16-bit unsigned integer value to serialize.
Serializes a U256 value into a byte representation. This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
The U256 value to serialize, represented as an AnyNumber.
Serializes a 32-bit unsigned integer value into a binary format. This function is useful for encoding data that needs to be stored or transmitted in a compact form.
The 32-bit unsigned integer value to serialize.
Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array. BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
The 32-bit unsigned integer value to be serialized.
Serializes a 64-bit unsigned integer into a format suitable for storage or transmission. This function breaks down the value into two 32-bit components and writes them in little-endian order.
The 64-bit unsigned integer to serialize, represented as a number.
Serializes a Uint8 value and appends it to the buffer. BCS layout for "uint8": One byte. Binary format in little-endian representation.
The Uint8 value to serialize.
Serializes an array of BCS Serializable values to a serializer instance. The bytes are added to the serializer instance's byte buffer.
The array of BCS Serializable values
const addresses = new Array<AccountAddress>(
AccountAddress.from("0x1"),
AccountAddress.from("0x2"),
AccountAddress.from("0xa"),
AccountAddress.from("0xb"),
);
const serializer = new Serializer();
serializer.serializeVector(addresses);
const serializedBytes = serializer.toUint8Array();
// serializedBytes is now the BCS-serialized bytes
// The equivalent value in Move would be:
// `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
Returns the buffered bytes as a Uint8Array.
This function allows you to retrieve the byte representation of the buffer up to the current offset.
Uint8Array - The byte array representation of the buffer.
A class for serializing various data types into a binary format. It provides methods to serialize strings, bytes, numbers, and other serializable objects using the Binary Coded Serialization (BCS) layout. The serialized data can be retrieved as a Uint8Array.