@aptos-labs/ts-sdk 2.0.1 → 3.1.0

package/dist/esm/bcs/deserializer.d.mts

@@ -1,308 +1,7 @@
-import { HexInput, Uint8, Uint16, Uint32, Uint64, Uint128, Uint256 } from '../types/types.mjs';
+export { D as Deserializable, a as Deserializer } from '../account--Q9z_xMN.mjs';
 import '../types/indexer.mjs';
 import '../types/generated/operations.mjs';
 import '../types/generated/types.mjs';
 import '../utils/apiEndpoints.mjs';
-
-/**
- * This interface exists to define Deserializable<T> inputs for functions that
- * deserialize a byte buffer into a type T.
- * It is not intended to be implemented or extended, because Typescript has no support
- * for static methods in interfaces.
- *
- * @template T - The type that this will deserialize into.
- * @group Implementation
- * @category BCS
- */
-interface Deserializable<T> {
-    /**
-     * Deserializes the buffered bytes into an instance of the specified class type.
-     * This function provides an alternative syntax for deserialization, allowing users to call
-     * `deserializer.deserialize(MyClass)` instead of `MyClass.deserialize(deserializer)`.
-     *
-     * @param deserializer - The deserializer instance with the buffered bytes.
-     * @returns The deserialized value of class type T.
-     * @example
-     * ```typescript
-     * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
-     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
-     * // value is now an instance of MyClass
-     * // equivalent to `const value = MyClass.deserialize(deserializer)`
-     * ```
-     * @group Implementation
-     * @category BCS
-     */
-    deserialize(deserializer: Deserializer): 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
- */
-declare class Deserializer {
-    private buffer;
-    private offset;
-    /**
-     * Creates a new instance of the class with a copy of the provided data buffer.
-     * 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);
-    static fromHex(hex: HexInput): Deserializer;
-    /**
-     * 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;
-    /**
-     * Returns the number of bytes remaining in the buffer.
-     *
-     * 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;
-    /**
-     * Asserts that the buffer has no remaining bytes.
-     *
-     * @throws {Error} Throws an error if there are remaining bytes in the buffer.
-     * @group Implementation
-     * @category BCS
-     */
-    assertFinished(): void;
-    /**
-     * Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes,
-     * followed by the actual byte content, and decodes it into a string.
-     *
-     * 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.
-     *
-     * @example
-     * ```typescript
-     * 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;
-    /**
-     * @deprecated use `deserializeOption("string")` instead.
-     *
-     * The BCS layout for Optional<String> is 0 if none, else 1 followed by the string length and string content.
-     * @returns The deserialized string if it exists, otherwise undefined.
-     * @example
-     * ```typescript
-     * const deserializer = new Deserializer(new Uint8Array([0x00]));
-     * assert(deserializer.deserializeOptionStr() === undefined);
-     * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
-     * assert(deserializer.deserializeOptionStr() === "1234abcd");
-     * ```
-     */
-    deserializeOptionStr(): string | undefined;
-    /**
-     * Deserializes an optional value from the buffer.
-     *
-     * The BCS layout for Optional<T> starts with a boolean byte (0 if none, 1 if some),
-     * followed by the value if present.
-     *
-     * @template T - The type of the value to deserialize
-     * @param type - Either a Deserializable class or one of the string literals: "string", "bytes", or "fixedBytes"
-     * @param len - Required length when type is "fixedBytes", ignored otherwise
-     * @returns The deserialized value if present, undefined otherwise
-     *
-     * @throws {Error} When "fixedBytes" is specified without a length
-     *
-     * @example
-     * ```typescript
-     * // Deserialize an optional string
-     * const deserializer = new Deserializer(new Uint8Array([1, 3, 97, 98, 99]));
-     * const optStr = deserializer.deserializeOption("string");
-     * // optStr === "abc"
-     *
-     * // Deserialize an optional custom type
-     * const deserializer = new Deserializer(new Uint8Array([0]));
-     * const optValue = deserializer.deserializeOption(MyClass);
-     * // optValue === undefined
-     *
-     * // Deserialize optional bytes
-     * const deserializer = new Deserializer(new Uint8Array([1, 3, 1, 2, 3]));
-     * const optBytes = deserializer.deserializeOption("bytes");
-     * // optBytes === Uint8Array[1, 2, 3]
-     *
-     * // Deserialize optional fixed bytes
-     * const deserializer = new Deserializer(new Uint8Array([1, 1, 2, 3, 4]));
-     * 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;
-    deserializeOption(type: "fixedBytes", len: number): Uint8Array | undefined;
-    deserializeOption<T>(type: Deserializable<T>): T | undefined;
-    /**
-     * Deserializes an array of bytes.
-     *
-     * The BCS layout for "bytes" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer
-     * 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;
-    /**
-     * 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;
-    /**
-     * Deserializes a boolean value from a byte stream.
-     *
-     * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
-     * An error is thrown if the byte value is not valid.
-     *
-     * @returns The deserialized boolean value.
-     * @throws Throws an error if the boolean value is invalid.
-     * @group Implementation
-     * @category BCS
-     */
-    deserializeBool(): boolean;
-    /**
-     * Deserializes a uint8 number from the binary data.
-     *
-     * BCS layout for "uint8": One byte. Binary format in little-endian representation.
-     *
-     * @returns {number} The deserialized uint8 number.
-     * @group Implementation
-     * @category BCS
-     */
-    deserializeU8(): Uint8;
-    /**
-     * Deserializes a uint16 number from a binary format in little-endian representation.
-     *
-     * BCS layout for "uint16": Two bytes.
-     * @example
-     * ```typescript
-     * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
-     * assert(deserializer.deserializeU16() === 4660);
-     * ```
-     * @group Implementation
-     * @category BCS
-     */
-    deserializeU16(): Uint16;
-    /**
-     * Deserializes a uint32 number from a binary format in little-endian representation.
-     *
-     * BCS layout for "uint32": Four bytes.
-     * @example
-     * ```typescript
-     * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
-     * assert(deserializer.deserializeU32() === 305419896);
-     * ```
-     * @group Implementation
-     * @category BCS
-     */
-    deserializeU32(): Uint32;
-    /**
-     * Deserializes a uint64 number.
-     *
-     * This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.
-     * @example
-     * ```typescript
-     * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
-     * assert(deserializer.deserializeU64() === 1311768467750121216);
-     * ```
-     * @group Implementation
-     * @category BCS
-     */
-    deserializeU64(): Uint64;
-    /**
-     * Deserializes a uint128 number from its binary representation.
-     * 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;
-    /**
-     * Deserializes a uint256 number from its binary representation.
-     *
-     * 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;
-    /**
-     * Deserializes a uleb128 encoded uint32 number.
-     *
-     * This function is used for interpreting lengths of variable-length sequences and tags of enum values in BCS encoding.
-     *
-     * @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;
-    /**
-     * Helper function that primarily exists to support alternative syntax for deserialization.
-     * That is, if we have a `const deserializer: new Deserializer(...)`, instead of having to use
-     * `MyClass.deserialize(deserializer)`, we can call `deserializer.deserialize(MyClass)`.
-     *
-     * @example const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
-     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
-     * // value is now an instance of MyClass
-     * // equivalent to `const value = MyClass.deserialize(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;
-    /**
-     * Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
-     *
-     * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
-     * @returns An array of deserialized values of type T.
-     * @example
-     * // serialize a vector of addresses
-     * 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();
-     *
-     * // deserialize the bytes into an array of addresses
-     * 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>;
-}
-
-export { type Deserializable, Deserializer };
+import '../utils/const.mjs';
+import '../core/common.mjs';

package/dist/esm/bcs/index.d.mts

@@ -1,14 +1,8 @@
-export { Deserializable, Deserializer } from './deserializer.mjs';
-export { Serializable, Serializer, ensureBoolean, outOfRangeErrorMessage, validateNumberInRange } from './serializer.mjs';
+export { B as Bool, D as Deserializable, a as Deserializer, F as FixedBytes, k as MoveOption, j as MoveString, M as MoveVector, S as Serializable, i as Serialized, b as Serializer, g as U128, c as U16, h as U256, d as U32, f as U64, U as U8, e as ensureBoolean, o as outOfRangeErrorMessage, v as validateNumberInRange } from '../account--Q9z_xMN.mjs';
 export { EntryFunctionBytes } from './serializable/entryFunctionBytes.mjs';
-export { FixedBytes } from './serializable/fixedBytes.mjs';
-export { Bool, U128, U16, U256, U32, U64, U8 } from './serializable/movePrimitives.mjs';
-export { MoveOption, MoveString, MoveVector, Serialized } from './serializable/moveStructs.mjs';
-import '../types/types.mjs';
 import '../types/indexer.mjs';
 import '../types/generated/operations.mjs';
 import '../types/generated/types.mjs';
 import '../utils/apiEndpoints.mjs';
-import '../core/hex.mjs';
+import '../utils/const.mjs';
 import '../core/common.mjs';
-import '../transactions/instances/transactionArgument.mjs';

package/dist/esm/bcs/index.mjs

@@ -1,2 +1,2 @@
-import"../chunk-FZY4PMEE.mjs";import{a as p,b as q,c as r,d as s}from"../chunk-Q4W3WJ2U.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o}from"../chunk-ORMOQWWH.mjs";import{a as h}from"../chunk-TOBQ5UE6.mjs";import{a as g}from"../chunk-MT2RJ7H3.mjs";import{a}from"../chunk-FLZPUYXQ.mjs";import"../chunk-FD6FGKYY.mjs";import"../chunk-ODAAZLPK.mjs";import"../chunk-4WPQQPUF.mjs";import{a as b,b as c,c as d,d as e,e as f}from"../chunk-EBMEXURY.mjs";import"../chunk-STY74NUA.mjs";import"../chunk-IF4UU2MT.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-KDMSOCZY.mjs";export{i as Bool,a as Deserializer,h as EntryFunctionBytes,g as FixedBytes,s as MoveOption,r as MoveString,p as MoveVector,b as Serializable,q as Serialized,c as Serializer,n as U128,k as U16,o as U256,l as U32,m as U64,j as U8,d as ensureBoolean,e as outOfRangeErrorMessage,f as validateNumberInRange};
+import"../chunk-FZY4PMEE.mjs";import{a as p,b as q,c as r,d as s}from"../chunk-2BOHKN33.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o}from"../chunk-ORMOQWWH.mjs";import{a as h}from"../chunk-TOBQ5UE6.mjs";import{a as g}from"../chunk-MT2RJ7H3.mjs";import"../chunk-FD6FGKYY.mjs";import"../chunk-IJE2LVZG.mjs";import"../chunk-4WPQQPUF.mjs";import{a as b,b as c,c as d,d as e,e as f}from"../chunk-EBMEXURY.mjs";import{a}from"../chunk-FLZPUYXQ.mjs";import"../chunk-STY74NUA.mjs";import"../chunk-IF4UU2MT.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-KDMSOCZY.mjs";export{i as Bool,a as Deserializer,h as EntryFunctionBytes,g as FixedBytes,s as MoveOption,r as MoveString,p as MoveVector,b as Serializable,q as Serialized,c as Serializer,n as U128,k as U16,o as U256,l as U32,m as U64,j as U8,d as ensureBoolean,e as outOfRangeErrorMessage,f as validateNumberInRange};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/bcs/serializable/entryFunctionBytes.d.mts

@@ -1,14 +1,10 @@
-import { Serializable, Serializer } from '../serializer.mjs';
-import { Deserializer } from '../deserializer.mjs';
-import { FixedBytes } from './fixedBytes.mjs';
-import { EntryFunctionArgument } from '../../transactions/instances/transactionArgument.mjs';
-import '../../core/hex.mjs';
-import '../../core/common.mjs';
-import '../../types/types.mjs';
+import { S as Serializable, a9 as EntryFunctionArgument, F as FixedBytes, b as Serializer, a as Deserializer } from '../../account--Q9z_xMN.mjs';
 import '../../types/indexer.mjs';
 import '../../types/generated/operations.mjs';
 import '../../types/generated/types.mjs';
 import '../../utils/apiEndpoints.mjs';
+import '../../utils/const.mjs';
+import '../../core/common.mjs';
 
 /**
  * This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because

package/dist/esm/bcs/serializable/fixedBytes.d.mts

@@ -1,94 +1,7 @@
-import { Serializable, Serializer } from '../serializer.mjs';
-import { Deserializer } from '../deserializer.mjs';
-import { HexInput } from '../../types/types.mjs';
-import { TransactionArgument } from '../../transactions/instances/transactionArgument.mjs';
-import '../../core/hex.mjs';
-import '../../core/common.mjs';
+export { F as FixedBytes } from '../../account--Q9z_xMN.mjs';
 import '../../types/indexer.mjs';
 import '../../types/generated/operations.mjs';
 import '../../types/generated/types.mjs';
 import '../../utils/apiEndpoints.mjs';
-
-/**
- * Represents a contiguous sequence of already serialized BCS bytes.
- *
- * This class differs from most other Serializable classes in that its internal byte buffer is serialized to BCS
- * bytes exactly as-is, without prepending the length of the bytes. It is ideal for scenarios where custom serialization
- * is required, such as passing serialized bytes as transaction arguments. Additionally, it serves as a representation
- * of type-agnostic BCS bytes, akin to a vector<u8>.
- *
- * An example use case includes handling bytes resulting from entry function arguments that have been serialized
- * for an entry function.
- *
- * @example
- * const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
- * const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
- * const payload = await generateTransactionPayload({
- *   function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
- *   functionArguments: [yourCustomBytes],
- * });
- *
- * This class is particularly useful when you want to handle a fixed-size byte array without the overhead of
- * length prepending, such as when dealing with 32-byte addresses stored as U8 in a MoveVector<U8>.
-
- *  For example, if you store each of the 32 bytes for an address as a U8 in a MoveVector<U8>, when you
- *  serialize that MoveVector<U8>, it will be serialized to 33 bytes. If you solely want to pass around
- *  the 32 bytes as a Serializable class that *does not* prepend the length to the BCS-serialized representation,
- *  use this class.*
- * @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
- */
-declare class FixedBytes extends Serializable implements TransactionArgument {
-    value: Uint8Array;
-    /**
-     * Creates an instance of the class with a specified hexadecimal input.
-     * 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);
-    /**
-     * Serializes the fixed bytes value using the provided serializer.
-     * 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;
-    /**
-     * Serializes the current instance for an entry function using the provided serializer.
-     * 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;
-    /**
-     * Serializes the current instance using the provided serializer.
-     * 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;
-    /**
-     * Deserializes a fixed-length byte array from the provided deserializer.
-     * This function helps in reconstructing a FixedBytes object from the serialized data.
-     *
-     * @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;
-}
-
-export { FixedBytes };
+import '../../utils/const.mjs';
+import '../../core/common.mjs';

package/dist/esm/bcs/serializable/movePrimitives.d.mts

@@ -1,172 +1,7 @@
-import { Deserializer } from '../deserializer.mjs';
-import { Serializable, Serializer } from '../serializer.mjs';
-import { TransactionArgument } from '../../transactions/instances/transactionArgument.mjs';
-import { AnyNumber, Uint8, Uint16, Uint32 } from '../../types/types.mjs';
+export { B as Bool, g as U128, c as U16, h as U256, d as U32, f as U64, U as U8 } from '../../account--Q9z_xMN.mjs';
 import '../../types/indexer.mjs';
 import '../../types/generated/operations.mjs';
 import '../../types/generated/types.mjs';
 import '../../utils/apiEndpoints.mjs';
-import '../../core/hex.mjs';
+import '../../utils/const.mjs';
 import '../../core/common.mjs';
-
-/**
- * Represents a boolean value that can be serialized and deserialized.
- * This class extends the Serializable class and provides methods to serialize
- * the boolean value for different contexts, such as entry functions and script functions.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class Bool extends Serializable implements TransactionArgument {
-    readonly value: boolean;
-    /**
-     * Constructs a new instance with a specified value.
-     * 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);
-    /**
-     * Serializes the value using the provided serializer.
-     * 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;
-    /**
-     * Serializes the current instance for use in an entry function by converting it to a byte sequence.
-     * 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;
-    /**
-     * Serializes the current instance for use in a script function.
-     * 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;
-    /**
-     * Deserializes a U256 value from the provided deserializer.
-     *
-     * @param deserializer - The deserializer instance used to read the U256 data.
-     * @group Implementation
-     * @category BCS
-     */
-    deserialize(deserializer: Deserializer): U256;
-    static deserialize(deserializer: Deserializer): Bool;
-}
-/**
- * Represents an unsigned 8-bit integer (U8) value.
- * This class extends the Serializable class and provides methods for serialization and deserialization of U8 values.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U8 extends Serializable implements TransactionArgument {
-    readonly value: Uint8;
-    constructor(value: Uint8);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U8;
-}
-/**
- * Represents a 16-bit unsigned integer (U16) value.
- * This class extends the Serializable class and provides methods for serialization
- * and deserialization of the U16 value.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U16 extends Serializable implements TransactionArgument {
-    readonly value: Uint16;
-    constructor(value: Uint16);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U16;
-}
-/**
- * Represents a 32-bit unsigned integer (U32) that can be serialized and deserialized.
- * This class ensures that the value is within the valid range for a U32.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U32 extends Serializable implements TransactionArgument {
-    readonly value: Uint32;
-    constructor(value: Uint32);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U32;
-}
-/**
- * Represents a 64-bit unsigned integer (U64) and provides methods for serialization.
- *
- * This class ensures that the value is within the valid range for a U64 and provides
- * functionality to serialize the value for various use cases, including entry functions
- * and script functions.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U64 extends Serializable implements TransactionArgument {
-    readonly value: bigint;
-    constructor(value: AnyNumber);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U64;
-}
-/**
- * Represents a 128-bit unsigned integer value.
- * This class provides methods for serialization and deserialization
- * of U128 values, ensuring that the values are within the valid range.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U128 extends Serializable implements TransactionArgument {
-    readonly value: bigint;
-    constructor(value: AnyNumber);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U128;
-}
-/**
- * Represents a 256-bit unsigned integer (U256) that extends the Serializable class.
- * This class provides methods for serialization and deserialization of U256 values,
- * ensuring that the values are within the valid range.
- *
- * @extends Serializable
- * @group Implementation
- * @category BCS
- */
-declare class U256 extends Serializable implements TransactionArgument {
-    readonly value: bigint;
-    constructor(value: AnyNumber);
-    serialize(serializer: Serializer): void;
-    serializeForEntryFunction(serializer: Serializer): void;
-    serializeForScriptFunction(serializer: Serializer): void;
-    static deserialize(deserializer: Deserializer): U256;
-}
-
-export { Bool, U128, U16, U256, U32, U64, U8 };

package/dist/esm/bcs/serializable/movePrimitives.mjs

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f,g}from"../../chunk-ORMOQWWH.mjs";import"../../chunk-FD6FGKYY.mjs";import"../../chunk-ODAAZLPK.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-EBMEXURY.mjs";import"../../chunk-STY74NUA.mjs";import"../../chunk-IF4UU2MT.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-KDMSOCZY.mjs";export{a as Bool,f as U128,c as U16,g as U256,d as U32,e as U64,b as U8};
+import{a,b,c,d,e,f,g}from"../../chunk-ORMOQWWH.mjs";import"../../chunk-FD6FGKYY.mjs";import"../../chunk-IJE2LVZG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-EBMEXURY.mjs";import"../../chunk-STY74NUA.mjs";import"../../chunk-IF4UU2MT.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-KDMSOCZY.mjs";export{a as Bool,f as U128,c as U16,g as U256,d as U32,e as U64,b as U8};
 //# sourceMappingURL=movePrimitives.mjs.map