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 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 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 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 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 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])`;
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.