@aptos-labs/ts-sdk 1.33.1 → 1.33.2

package/src/bcs/deserializer.ts

@@ -3,7 +3,8 @@
 
 /* eslint-disable no-bitwise */
 import { MAX_U32_NUMBER } from "./consts";
-import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256 } from "../types";
+import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256, HexInput } from "../types";
+import { Hex } from "../core/hex";
 
 /**
  * This interface exists to define Deserializable<T> inputs for functions that
@@ -12,6 +13,8 @@ import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256 } from "../types";
  * for static methods in interfaces.
  *
  * @template T - The type that this will deserialize into.
+ * @group Implementation
+ * @category BCS
  */
 export interface Deserializable<T> {
   /**
@@ -28,6 +31,8 @@ export interface Deserializable<T> {
    * // value is now an instance of MyClass
    * // equivalent to `const value = MyClass.deserialize(deserializer)`
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserialize(deserializer: Deserializer): T;
 }
@@ -35,6 +40,8 @@ export interface Deserializable<T> {
 /**
  * A class that provides methods for deserializing various data types from a byte buffer.
  * It supports deserialization of primitive types, strings, and complex objects using a BCS (Binary Common Serialization) layout.
+ * @group Implementation
+ * @category BCS
  */
 export class Deserializer {
   private buffer: ArrayBuffer;
@@ -46,6 +53,8 @@ export class Deserializer {
    * This prevents outside mutation of the buffer.
    *
    * @param data - The data to be copied into the internal buffer as a Uint8Array.
+   * @group Implementation
+   * @category BCS
    */
   constructor(data: Uint8Array) {
     // copies data to prevent outside mutation of buffer.
@@ -54,11 +63,18 @@ export class Deserializer {
     this.offset = 0;
   }
 
+  static fromHex(hex: HexInput): Deserializer {
+    const data = Hex.hexInputToUint8Array(hex);
+    return new Deserializer(data);
+  }
+
   /**
    * Reads a specified number of bytes from the buffer and advances the offset.
    *
    * @param length - The number of bytes to read from the buffer.
    * @throws Throws an error if the read operation exceeds the buffer's length.
+   * @group Implementation
+   * @category BCS
    */
   private read(length: number): ArrayBuffer {
     if (this.offset + length > this.buffer.byteLength) {
@@ -76,6 +92,8 @@ export class Deserializer {
    * This information is useful to determine if there's more data to be read.
    *
    * @returns The number of bytes remaining in the buffer.
+   * @group Implementation
+   * @category BCS
    */
   remaining(): number {
     return this.buffer.byteLength - this.offset;
@@ -93,6 +111,8 @@ export class Deserializer {
    * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
    * assert(deserializer.deserializeStr() === "1234abcd");
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserializeStr(): string {
     const value = this.deserializeBytes();
@@ -152,6 +172,8 @@ export class Deserializer {
    * const optBytes = deserializer.deserializeOption("fixedBytes", 4);
    * // optBytes === Uint8Array[1, 2, 3, 4]
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserializeOption(type: "string"): string | undefined;
   deserializeOption(type: "bytes"): Uint8Array | undefined;
@@ -187,6 +209,8 @@ export class Deserializer {
    * encoded as a uleb128 integer, indicating the length of the bytes array.
    *
    * @returns {Uint8Array} The deserialized array of bytes.
+   * @group Implementation
+   * @category BCS
    */
   deserializeBytes(): Uint8Array {
     const len = this.deserializeUleb128AsU32();
@@ -197,6 +221,8 @@ export class Deserializer {
    * Deserializes an array of bytes of a specified length.
    *
    * @param len - The number of bytes to read from the source.
+   * @group Implementation
+   * @category BCS
    */
   deserializeFixedBytes(len: number): Uint8Array {
     return new Uint8Array(this.read(len));
@@ -210,6 +236,8 @@ export class Deserializer {
    *
    * @returns The deserialized boolean value.
    * @throws Throws an error if the boolean value is invalid.
+   * @group Implementation
+   * @category BCS
    */
   deserializeBool(): boolean {
     const bool = new Uint8Array(this.read(1))[0];
@@ -225,6 +253,8 @@ export class Deserializer {
    * BCS layout for "uint8": One byte. Binary format in little-endian representation.
    *
    * @returns {number} The deserialized uint8 number.
+   * @group Implementation
+   * @category BCS
    */
   deserializeU8(): Uint8 {
     return new DataView(this.read(1)).getUint8(0);
@@ -239,6 +269,8 @@ export class Deserializer {
    * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
    * assert(deserializer.deserializeU16() === 4660);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserializeU16(): Uint16 {
     return new DataView(this.read(2)).getUint16(0, true);
@@ -253,6 +285,8 @@ export class Deserializer {
    * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
    * assert(deserializer.deserializeU32() === 305419896);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserializeU32(): Uint32 {
     return new DataView(this.read(4)).getUint32(0, true);
@@ -267,6 +301,8 @@ export class Deserializer {
    * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
    * assert(deserializer.deserializeU64() === 1311768467750121216);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   deserializeU64(): Uint64 {
     const low = this.deserializeU32();
@@ -281,6 +317,8 @@ export class Deserializer {
    * This function combines two 64-bit values to return a single uint128 value in little-endian format.
    *
    * @returns {BigInt} The deserialized uint128 number.
+   * @group Implementation
+   * @category BCS
    */
   deserializeU128(): Uint128 {
     const low = this.deserializeU64();
@@ -296,6 +334,8 @@ export class Deserializer {
    * The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
    *
    * @returns {BigInt} The deserialized uint256 number.
+   * @group Implementation
+   * @category BCS
    */
   deserializeU256(): Uint256 {
     const low = this.deserializeU128();
@@ -312,6 +352,8 @@ export class Deserializer {
    *
    * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.
    * @returns {number} The deserialized uint32 value.
+   * @group Implementation
+   * @category BCS
    */
   deserializeUleb128AsU32(): Uint32 {
     let value: bigint = BigInt(0);
@@ -346,6 +388,8 @@ export class Deserializer {
    * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
    *
    * @returns the deserialized value of class type T
+   * @group Implementation
+   * @category BCS
    */
   deserialize<T>(cls: Deserializable<T>): T {
     // NOTE: `deserialize` in `cls.deserialize(this)` here is a static method defined in `cls`,
@@ -374,6 +418,8 @@ export class Deserializer {
    * const deserializer = new Deserializer(serializedBytes);
    * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
    * // deserializedAddresses is now an array of AccountAddress instances
+   * @group Implementation
+   * @category BCS
    */
   deserializeVector<T>(cls: Deserializable<T>): Array<T> {
     const length = this.deserializeUleb128AsU32();

package/src/bcs/serializable/entryFunctionBytes.ts

@@ -16,6 +16,8 @@ import { HexInput } from "../../types";
  * If you wish to convert this class back to a TransactionArgument, you must know the type
  * of the argument beforehand, and use the appropriate class to deserialize the bytes within
  * an instance of this class.
+ * @group Implementation
+ * @category BCS
  */
 export class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {
   public readonly value: FixedBytes;
@@ -24,6 +26,8 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
    * Creates an instance of the class with a specified hexadecimal input value.
    *
    * @param value - The hexadecimal input to be converted into FixedBytes.
+   * @group Implementation
+   * @category BCS
    */
   private constructor(value: HexInput) {
     super();
@@ -45,6 +49,8 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
    * we must not serialize the length prefix.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serialize(serializer: Serializer): void {
     serializer.serialize(this.value);
@@ -62,6 +68,8 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
    * This process includes serializing the length prefix of the byte vector.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(this.value.value.length);
@@ -74,6 +82,8 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
    * @param deserializer - The deserializer instance with the buffered bytes.
    * @param length - The length of the bytes to deserialize.
    * @returns An instance of this class, which will now only be usable as an EntryFunctionArgument.
+   * @group Implementation
+   * @category BCS
    */
   static deserialize(deserializer: Deserializer, length: number): EntryFunctionBytes {
     const fixedBytes = FixedBytes.deserialize(deserializer, length);

package/src/bcs/serializable/fixedBytes.ts

@@ -36,6 +36,8 @@ import { TransactionArgument } from "../../transactions/instances/transactionArg
  * @param value - HexInput representing a sequence of Uint8 bytes.
  * @returns A Serializable FixedBytes instance, which when serialized, does not prepend the length of the bytes.
  * @see EntryFunctionBytes
+ * @group Implementation
+ * @category BCS
  */
 export class FixedBytes extends Serializable implements TransactionArgument {
   public value: Uint8Array;
@@ -45,6 +47,8 @@ export class FixedBytes extends Serializable implements TransactionArgument {
    * The value is converted from hexadecimal format to a Uint8Array.
    *
    * @param value - The hexadecimal input to be converted.
+   * @group Implementation
+   * @category BCS
    */
   constructor(value: HexInput) {
     super();
@@ -56,6 +60,8 @@ export class FixedBytes extends Serializable implements TransactionArgument {
    * This function is essential for converting the fixed bytes into a format suitable for storage or transmission.
    *
    * @param serializer - The serializer instance used for serialization.
+   * @group Implementation
+   * @category BCS
    */
   serialize(serializer: Serializer): void {
     serializer.serializeFixedBytes(this.value);
@@ -66,6 +72,8 @@ export class FixedBytes extends Serializable implements TransactionArgument {
    * This allows the instance to be converted into a format suitable for transmission or storage.
    *
    * @param serializer - The serializer used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
     serializer.serialize(this);
@@ -76,6 +84,8 @@ export class FixedBytes extends Serializable implements TransactionArgument {
    * This function is essential for preparing data to be passed as arguments in script functions.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serializeForScriptFunction(serializer: Serializer): void {
     serializer.serialize(this);
@@ -87,6 +97,8 @@ export class FixedBytes extends Serializable implements TransactionArgument {
    *
    * @param deserializer - The deserializer instance used to read the byte data.
    * @param length - The length of the byte array to be deserialized.
+   * @group Implementation
+   * @category BCS
    */
   static deserialize(deserializer: Deserializer, length: number): FixedBytes {
     const bytes = deserializer.deserializeFixedBytes(length);

package/src/bcs/serializable/movePrimitives.ts

@@ -20,6 +20,8 @@ import { AnyNumber, Uint16, Uint32, Uint8, ScriptTransactionArgumentVariants } f
  * the boolean value for different contexts, such as entry functions and script functions.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class Bool extends Serializable implements TransactionArgument {
   public readonly value: boolean;
@@ -29,6 +31,8 @@ export class Bool extends Serializable implements TransactionArgument {
    * This ensures that the value is validated to be within the acceptable range.
    *
    * @param value - The number to be validated and assigned, which must be between 0 and MAX_U256_BIG_INT.
+   * @group Implementation
+   * @category BCS
    */
   constructor(value: boolean) {
     super();
@@ -39,6 +43,8 @@ export class Bool extends Serializable implements TransactionArgument {
      *
      * @param value - The value to be checked for boolean type.
      * @throws {Error} Throws an error if the value is not a boolean.
+     * @group Implementation
+     * @category BCS
      */
     ensureBoolean(value);
     this.value = value;
@@ -49,6 +55,8 @@ export class Bool extends Serializable implements TransactionArgument {
    * This function is essential for converting the value into a format suitable for transmission or storage.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serialize(serializer: Serializer): void {
     serializer.serializeBool(this.value);
@@ -59,6 +67,8 @@ export class Bool extends Serializable implements TransactionArgument {
    * This allows the instance to be properly formatted for serialization in transactions.
    *
    * @param serializer - The serializer instance used to serialize the byte sequence.
+   * @group Implementation
+   * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
     const bcsBytes = this.bcsToBytes();
@@ -70,6 +80,8 @@ export class Bool extends Serializable implements TransactionArgument {
    * This allows for the conversion of the instance into a format suitable for transmission or storage.
    *
    * @param serializer - The serializer used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serializeForScriptFunction(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Bool);
@@ -80,6 +92,8 @@ export class Bool extends Serializable implements TransactionArgument {
    * Deserializes a U256 value from the provided deserializer.
    *
    * @param deserializer - The deserializer instance used to read the U256 data.
+   * @group Implementation
+   * @category BCS
    */
   // eslint-disable-next-line class-methods-use-this
   deserialize(deserializer: Deserializer) {
@@ -96,6 +110,8 @@ export class Bool extends Serializable implements TransactionArgument {
  * This class extends the Serializable class and provides methods for serialization and deserialization of U8 values.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U8 extends Serializable implements TransactionArgument {
   public readonly value: Uint8;
@@ -131,6 +147,8 @@ export class U8 extends Serializable implements TransactionArgument {
  * and deserialization of the U16 value.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U16 extends Serializable implements TransactionArgument {
   public readonly value: Uint16;
@@ -165,6 +183,8 @@ export class U16 extends Serializable implements TransactionArgument {
  * This class ensures that the value is within the valid range for a U32.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U32 extends Serializable implements TransactionArgument {
   public readonly value: Uint32;
@@ -202,6 +222,8 @@ export class U32 extends Serializable implements TransactionArgument {
  * and script functions.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U64 extends Serializable implements TransactionArgument {
   public readonly value: bigint;
@@ -237,6 +259,8 @@ export class U64 extends Serializable implements TransactionArgument {
  * of U128 values, ensuring that the values are within the valid range.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U128 extends Serializable implements TransactionArgument {
   public readonly value: bigint;
@@ -272,6 +296,8 @@ export class U128 extends Serializable implements TransactionArgument {
  * ensuring that the values are within the valid range.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class U256 extends Serializable implements TransactionArgument {
   public readonly value: bigint;

package/src/bcs/serializable/moveStructs.ts

@@ -44,6 +44,8 @@ import { EntryFunctionArgument, TransactionArgument } from "../../transactions/i
  *
  * @param values an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
+ * @group Implementation
+ * @category BCS
  */
 export class MoveVector<T extends Serializable & EntryFunctionArgument>
   extends Serializable
@@ -56,6 +58,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This constructor sets up the internal vector based on the provided value.
    *
    * @param values - The initial value to be stored in the vector, or null to initialize an empty vector.
+   * @group Implementation
+   * @category BCS
    */
   constructor(values: Array<T>) {
     super();
@@ -67,6 +71,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This allows the data to be properly formatted for transmission or storage.
    *
    * @param serializer - The serializer instance used to serialize the byte sequence.
+   * @group Implementation
+   * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
     const bcsBytes = this.bcsToBytes();
@@ -76,11 +82,15 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
   /**
    * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
    * @param serializer
+   * @group Implementation
+   * @category BCS
    */
 
   /**
    * Serialize the string as a fixed byte string without the length prefix for use in a script function.
    * @param serializer - The serializer used to convert the byte vector into a format suitable for a script function.
+   * @group Implementation
+   * @category BCS
    */
   serializeForScriptFunction(serializer: Serializer): void {
     // This checks if the type of a non-empty vector is of type other than U8.  If so, we use the Serialized
@@ -108,6 +118,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U8([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U8(values: Array<number> | HexInput): MoveVector<U8> {
     let numbers: Array<number>;
@@ -141,6 +153,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U16([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
 
    */
   static U16(values: Array<number>): MoveVector<U16> {
@@ -160,6 +174,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```
    * const v = MoveVector.U32([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
 
    */
   static U32(values: Array<number>): MoveVector<U32> {
@@ -178,6 +194,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U64([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U64(values: Array<AnyNumber>): MoveVector<U64> {
     return new MoveVector<U64>(values.map((v) => new U64(v)));
@@ -194,6 +212,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U128([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U128(values: Array<AnyNumber>): MoveVector<U128> {
     return new MoveVector<U128>(values.map((v) => new U128(v)));
@@ -211,6 +231,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U256([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U256(values: Array<AnyNumber>): MoveVector<U256> {
     return new MoveVector<U256>(values.map((v) => new U256(v)));
@@ -227,6 +249,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    *    * const v = MoveVector.Bool([true, false, true, false]);
+   * @group Implementation
+   * @category BCS
    */
   static Bool(values: Array<boolean>): MoveVector<Bool> {
     return new MoveVector<Bool>(values.map((v) => new Bool(v)));
@@ -242,6 +266,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    * const v = MoveVector.MoveString(["hello", "world"]);
+   * @group Implementation
+   * @category BCS
    */
   static MoveString(values: Array<string>): MoveVector<MoveString> {
     return new MoveVector<MoveString>(values.map((v) => new MoveString(v)));
@@ -252,6 +278,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This function will serialize the value if it is present.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serialize(serializer: Serializer): void;
   serialize(serializer: Serializer): void {
@@ -274,6 +302,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * @param cls the class to typecast the input values to, must be a Serializable and Deserializable type.
    * @returns a MoveVector of the corresponding class T
    *
+   * @group Implementation
+   * @category BCS
    */
   static deserialize<T extends Serializable & EntryFunctionArgument>(
     deserializer: Deserializer,
@@ -294,6 +324,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
  * and deserialization of byte data, as well as converting to a MoveVector.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class Serialized extends Serializable implements TransactionArgument {
   public readonly value: Uint8Array;
@@ -325,6 +357,8 @@ export class Serialized extends Serializable implements TransactionArgument {
    * This function allows you to convert serialized data into a usable MoveVector format.
    *
    * @param cls - The class type of the elements in the MoveVector.
+   * @group Implementation
+   * @category BCS
    */
   toMoveVector<T extends Serializable & EntryFunctionArgument>(cls: Deserializable<T>): MoveVector<T> {
     const deserializer = new Deserializer(this.bcsToBytes());
@@ -341,6 +375,8 @@ export class Serialized extends Serializable implements TransactionArgument {
  * functions and script functions.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class MoveString extends Serializable implements TransactionArgument {
   public value: string;
@@ -410,6 +446,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @throws {Error} Throws an error if the MoveOption does not contain a value.
    *
    * @returns {T} The contained value if present.
+   * @group Implementation
+   * @category BCS
    */
   unwrap(): T {
     if (!this.isSome()) {
@@ -423,6 +461,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * Check if the MoveOption has a value.
    *
    * @returns {boolean} Returns true if there is exactly one value in the MoveOption.
+   * @group Implementation
+   * @category BCS
    */
   isSome(): boolean {
     return this.vec.values.length === 1;
@@ -444,6 +484,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U8> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U8(value?: number | null): MoveOption<U8> {
     return new MoveOption<U8>(value !== null && value !== undefined ? new U8(value) : undefined);
@@ -459,6 +501,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U16> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U16(value?: number | null): MoveOption<U16> {
     return new MoveOption<U16>(value !== null && value !== undefined ? new U16(value) : undefined);
@@ -474,6 +518,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U32> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U32(value?: number | null): MoveOption<U32> {
     return new MoveOption<U32>(value !== null && value !== undefined ? new U32(value) : undefined);
@@ -489,6 +535,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U64> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U64(value?: AnyNumber | null): MoveOption<U64> {
     return new MoveOption<U64>(value !== null && value !== undefined ? new U64(value) : undefined);
@@ -504,6 +552,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U128> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U128(value?: AnyNumber | null): MoveOption<U128> {
     return new MoveOption<U128>(value !== null && value !== undefined ? new U128(value) : undefined);
@@ -519,6 +569,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U256> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U256(value?: AnyNumber | null): MoveOption<U256> {
     return new MoveOption<U256>(value !== null && value !== undefined ? new U256(value) : undefined);
@@ -534,6 +586,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<Bool> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static Bool(value?: boolean | null): MoveOption<Bool> {
     return new MoveOption<Bool>(value !== null && value !== undefined ? new Bool(value) : undefined);
@@ -550,6 +604,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<MoveString> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static MoveString(value?: string | null): MoveOption<MoveString> {
     return new MoveOption<MoveString>(value !== null && value !== undefined ? new MoveString(value) : undefined);