@aptos-labs/ts-sdk 0.0.4 → 0.0.5

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

@@ -0,0 +1,69 @@
+import { Deserializer } from '../deserializer.js';
+import { Serializable, Serializer } from '../serializer.js';
+import { TransactionArgument } from '../../transactions/instances/transactionArgument.js';
+import { Uint8, Uint16, Uint32, AnyNumber } from '../../types/index.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../../core/hex.js';
+import '../../core/common.js';
+
+declare class Bool extends Serializable implements TransactionArgument {
+    readonly value: boolean;
+    constructor(value: boolean);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Bool;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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

@@ -0,0 +1,2 @@
+import{a,b,c,d,e,f,g}from"../../chunk-PDLUCVJB.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.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

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/bcs/serializable/moveStructs.d.ts

@@ -0,0 +1,284 @@
+import { U8, U16, U32, U64, U128, U256, Bool } from './movePrimitives.js';
+import { Serializable, Serializer } from '../serializer.js';
+import { Deserializer, Deserializable } from '../deserializer.js';
+import { HexInput, AnyNumber } from '../../types/index.js';
+import { EntryFunctionArgument, TransactionArgument } from '../../transactions/instances/transactionArgument.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../../core/hex.js';
+import '../../core/common.js';
+
+/**
+ * This class is the Aptos Typescript SDK representation of a Move `vector<T>`,
+ * where `T` represents either a primitive type (`bool`, `u8`, `u64`, ...)
+ * or a BCS-serializable struct itself.
+ *
+ * It is a BCS-serializable, array-like type that contains an array of values of type `T`,
+ * where `T` is a class that implements `Serializable`.
+ *
+ * The purpose of this class is to facilitate easy construction of BCS-serializable
+ * Move `vector<T>` types.
+ *
+ * @example
+ * // in Move: `vector<u8> [1, 2, 3, 4];`
+ * const vecOfU8s = new MoveVector<U8>([new U8(1), new U8(2), new U8(3), new U8(4)]);
+ * // in Move: `std::bcs::to_bytes(vector<u8> [1, 2, 3, 4]);`
+ * const bcsBytes = vecOfU8s.toUint8Array();
+ *
+ * // vector<vector<u8>> [ vector<u8> [1], vector<u8> [1, 2, 3, 4], vector<u8> [5, 6, 7, 8] ];
+ * const vecOfVecs = new MoveVector<MoveVector<U8>>([
+ *   new MoveVector<U8>([new U8(1)]),
+ *   MoveVector.U8([1, 2, 3, 4]),
+ *   MoveVector.U8([5, 6, 7, 8]),
+ * ]);
+ *
+ * // vector<Option<u8>> [ std::option::some<u8>(1), std::option::some<u8>(2) ];
+ * const vecOfOptionU8s = new MoveVector<MoveOption<U8>>([
+ *    MoveOption.U8(1),
+ *    MoveOption.U8(2),
+ * ]);
+ *
+ * // vector<MoveString> [ std::string::utf8(b"hello"), std::string::utf8(b"world") ];
+ * const vecOfStrings = new MoveVector([new MoveString("hello"), new MoveString("world")]);
+ * const vecOfStrings2 = MoveVector.MoveString(["hello", "world"]);
+ *
+ * @params
+ * values: an Array<T> of values where T is a class that implements Serializable
+ * @returns a `MoveVector<T>` with the values `values`
+ */
+declare class MoveVector<T extends Serializable & EntryFunctionArgument> extends Serializable implements TransactionArgument {
+    values: Array<T>;
+    constructor(values: Array<T>);
+    serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
+     * @param serializer
+     */
+    serializeForScriptFunction(serializer: Serializer): void;
+    /**
+     * Factory method to generate a MoveVector of U8s from an array of numbers.
+     *
+     * @example
+     * const v = MoveVector.U8([1, 2, 3, 4]);
+     * @params values: an array of `numbers` to convert to U8s
+     * @returns a `MoveVector<U8>`
+     */
+    static U8(values: Array<number> | HexInput): MoveVector<U8>;
+    /**
+     * Factory method to generate a MoveVector of U16s from an array of numbers.
+     *
+     * @example
+     * const v = MoveVector.U16([1, 2, 3, 4]);
+     * @params values: an array of `numbers` to convert to U16s
+     * @returns a `MoveVector<U16>`
+     */
+    static U16(values: Array<number>): MoveVector<U16>;
+    /**
+     * Factory method to generate a MoveVector of U32s from an array of numbers.
+     *
+     * @example
+     * const v = MoveVector.U32([1, 2, 3, 4]);
+     * @params values: an array of `numbers` to convert to U32s
+     * @returns a `MoveVector<U32>`
+     */
+    static U32(values: Array<number>): MoveVector<U32>;
+    /**
+     * Factory method to generate a MoveVector of U64s from an array of numbers or bigints.
+     *
+     * @example
+     * const v = MoveVector.U64([1, 2, 3, 4]);
+     * @params values: an array of numbers of type `number | bigint` to convert to U64s
+     * @returns a `MoveVector<U64>`
+     */
+    static U64(values: Array<AnyNumber>): MoveVector<U64>;
+    /**
+     * Factory method to generate a MoveVector of U128s from an array of numbers or bigints.
+     *
+     * @example
+     * const v = MoveVector.U128([1, 2, 3, 4]);
+     * @params values: an array of numbers of type `number | bigint` to convert to U128s
+     * @returns a `MoveVector<U128>`
+     */
+    static U128(values: Array<AnyNumber>): MoveVector<U128>;
+    /**
+     * Factory method to generate a MoveVector of U256s from an array of numbers or bigints.
+     *
+     * @example
+     * const v = MoveVector.U256([1, 2, 3, 4]);
+     * @params values: an array of numbers of type `number | bigint` to convert to U256s
+     * @returns a `MoveVector<U256>`
+     */
+    static U256(values: Array<AnyNumber>): MoveVector<U256>;
+    /**
+     * Factory method to generate a MoveVector of Bools from an array of booleans.
+     *
+     * @example
+     * const v = MoveVector.Bool([true, false, true, false]);
+     * @params values: an array of `bools` to convert to Bools
+     * @returns a `MoveVector<Bool>`
+     */
+    static Bool(values: Array<boolean>): MoveVector<Bool>;
+    /**
+     * Factory method to generate a MoveVector of MoveStrings from an array of strings.
+     *
+     * @example
+     * const v = MoveVector.MoveString(["hello", "world"]);
+     * @params values: an array of `strings` to convert to MoveStrings
+     * @returns a `MoveVector<MoveString>`
+     */
+    static MoveString(values: Array<string>): MoveVector<MoveString>;
+    serialize(serializer: Serializer): void;
+    /**
+     * Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.
+     *
+     * NOTE: This only works with a depth of one. Generics will not work.
+     *
+     * NOTE: This will not work with types that aren't of the Serializable class.
+     *
+     * If you're looking for a more flexible deserialization function, you can use the deserializeVector function
+     * in the Deserializer class.
+     *
+     * @example
+     * const vec = MoveVector.deserialize(deserializer, U64);
+     * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.
+     * cls: the class to typecast the input values to, must be a Serializable and Deserializable type.
+     * @returns a MoveVector of the corresponding class T
+     * *
+     */
+    static deserialize<T extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<T>): MoveVector<T>;
+}
+declare class MoveString extends Serializable implements TransactionArgument {
+    value: string;
+    constructor(value: string);
+    serialize(serializer: Serializer): void;
+    serializeForEntryFunction(serializer: Serializer): void;
+    serializeForScriptFunction(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MoveString;
+}
+declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends Serializable implements EntryFunctionArgument {
+    private vec;
+    readonly value?: T;
+    constructor(value?: T | null);
+    serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * Retrieves the inner value of the MoveOption.
+     *
+     * This method is inspired by Rust's `Option<T>.unwrap()`.
+     * In Rust, attempting to unwrap a `None` value results in a panic.
+     *
+     * Similarly, this method will throw an error if the value is not present.
+     *
+     * @example
+     * const option = new MoveOption<Bool>(new Bool(true));
+     * const value = option.unwrap();  // Returns the Bool instance
+     *
+     * @throws {Error} Throws an error if the MoveOption does not contain a value.
+     *
+     * @returns {T} The contained value if present.
+     */
+    unwrap(): T;
+    isSome(): boolean;
+    serialize(serializer: Serializer): void;
+    /**
+     * Factory method to generate a MoveOption<U8> from a `number` or `undefined`.
+     *
+     * @example
+     * MoveOption.U8(1).isSome() === true;
+     * MoveOption.U8().isSome() === false;
+     * MoveOption.U8(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U8(value?: number | null): MoveOption<U8>;
+    /**
+     * Factory method to generate a MoveOption<U16> from a `number` or `undefined`.
+     *
+     * @example
+     * MoveOption.U16(1).isSome() === true;
+     * MoveOption.U16().isSome() === false;
+     * MoveOption.U16(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U16(value?: number | null): MoveOption<U16>;
+    /**
+     * Factory method to generate a MoveOption<U32> from a `number` or `undefined`.
+     *
+     * @example
+     * MoveOption.U32(1).isSome() === true;
+     * MoveOption.U32().isSome() === false;
+     * MoveOption.U32(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U32(value?: number | null): MoveOption<U32>;
+    /**
+     * Factory method to generate a MoveOption<U64> from a `number` or a `bigint` or `undefined`.
+     *
+     * @example
+     * MoveOption.U64(1).isSome() === true;
+     * MoveOption.U64().isSome() === false;
+     * MoveOption.U64(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U64(value?: AnyNumber | null): MoveOption<U64>;
+    /**
+     * Factory method to generate a MoveOption<U128> from a `number` or a `bigint` or `undefined`.
+     *
+     * @example
+     * MoveOption.U128(1).isSome() === true;
+     * MoveOption.U128().isSome() === false;
+     * MoveOption.U128(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U128(value?: AnyNumber | null): MoveOption<U128>;
+    /**
+     * Factory method to generate a MoveOption<U256> from a `number` or a `bigint` or `undefined`.
+     *
+     * @example
+     * MoveOption.U256(1).isSome() === true;
+     * MoveOption.U256().isSome() === false;
+     * MoveOption.U256(undefined).isSome() === false;
+     * @params 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`
+     */
+    static U256(value?: AnyNumber | null): MoveOption<U256>;
+    /**
+     * Factory method to generate a MoveOption<Bool> from a `boolean` or `undefined`.
+     *
+     * @example
+     * MoveOption.Bool(true).isSome() === true;
+     * MoveOption.Bool().isSome() === false;
+     * MoveOption.Bool(undefined).isSome() === false;
+     * @params 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`
+     */
+    static Bool(value?: boolean | null): MoveOption<Bool>;
+    /**
+     * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
+     *
+     * @example
+     * MoveOption.MoveString("hello").isSome() === true;
+     * MoveOption.MoveString("").isSome() === true;
+     * MoveOption.MoveString().isSome() === false;
+     * MoveOption.MoveString(undefined).isSome() === false;
+     * @params 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`
+     */
+    static MoveString(value?: string | null): MoveOption<MoveString>;
+    static deserialize<U extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U>;
+}
+
+export { MoveOption, MoveString, MoveVector };

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

@@ -0,0 +1,2 @@
+import{a,b,c}from"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{c as MoveOption,b as MoveString,a as MoveVector};
+//# sourceMappingURL=moveStructs.mjs.map

package/dist/esm/bcs/serializable/moveStructs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/bcs/serializer.d.ts

@@ -0,0 +1,192 @@
+import { Hex } from '../core/hex.js';
+import { Uint8, Uint16, Uint32, AnyNumber } from '../types/index.js';
+import '../core/common.js';
+import '../utils/apiEndpoints.js';
+import '../types/indexer.js';
+import '../types/generated/operations.js';
+import '../types/generated/types.js';
+
+declare abstract class Serializable {
+    abstract serialize(serializer: Serializer): void;
+    /**
+     * Serializes a `Serializable` value to its BCS representation.
+     * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.
+     * @returns the BCS representation of the Serializable instance as a byte buffer
+     */
+    bcsToBytes(): Uint8Array;
+    /**
+     * Helper function to get a value's BCS-serialized bytes as a Hex instance.
+     * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
+     */
+    bcsToHex(): Hex;
+}
+declare class Serializer {
+    private buffer;
+    private offset;
+    constructor(length?: number);
+    private ensureBufferWillHandleSize;
+    protected appendToBuffer(values: Uint8Array): void;
+    private serializeWithFunction;
+    /**
+     * 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.
+     *
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeStr("1234abcd");
+     * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
+     * ```
+     */
+    serializeStr(value: string): void;
+    /**
+     * Serializes an array of bytes.
+     *
+     * 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.
+     */
+    serializeBytes(value: Uint8Array): 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: Uint8Array): void;
+    /**
+     * Serializes a boolean value.
+     *
+     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     */
+    serializeBool(value: boolean): void;
+    /**
+     * Serializes a uint8 number.
+     *
+     * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     */
+    serializeU8(value: Uint8): void;
+    /**
+     * Serializes a uint16 number.
+     *
+     * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeU16(4660);
+     * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));
+     * ```
+     */
+    serializeU16(value: Uint16): void;
+    /**
+     * Serializes a uint32 number.
+     *
+     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeU32(305419896);
+     * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
+     * ```
+     */
+    serializeU32(value: Uint32): void;
+    /**
+     * Serializes a uint64 number.
+     *
+     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @example
+     * ```ts
+     * const serializer = new Serializer();
+     * serializer.serializeU64(1311768467750121216);
+     * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
+     * ```
+     */
+    serializeU64(value: AnyNumber): void;
+    /**
+     * Serializes a uint128 number.
+     *
+     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU128(value: AnyNumber): void;
+    /**
+     * Serializes a uint256 number.
+     *
+     * BCS layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
+     */
+    serializeU256(value: AnyNumber): void;
+    /**
+     * Serializes a uint32 number with uleb128.
+     *
+     * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     */
+    serializeU32AsUleb128(val: Uint32): void;
+    /**
+     * Returns the buffered bytes
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Serializes a `Serializable` value, facilitating composable serialization.
+     *
+     * @param value The Serializable value to serialize
+     *
+     * @example
+     * // Define the MoveStruct class that implements the Serializable interface
+     * class MoveStruct extends Serializable {
+     *     constructor(
+     *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
+     *         public collectionName: string,
+     *         public tokenName: string
+     *     ) {}
+     *
+     *     serialize(serializer: Serializer): void {
+     *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
+     *         serializer.serializeStr(this.collectionName);
+     *         serializer.serializeStr(this.tokenName);
+     *     }
+     * }
+     *
+     * // Construct a MoveStruct
+     * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
+     *
+     * // Serialize a string, a u64 number, and a MoveStruct instance.
+     * const serializer = new Serializer();
+     * serializer.serializeStr("ExampleString");
+     * serializer.serializeU64(12345678);
+     * serializer.serialize(moveStruct);
+     *
+     * // Get the bytes from the Serializer instance
+     * const serializedBytes = serializer.toUint8Array();
+     *
+     * @returns the serializer instance
+     */
+    serialize<T extends Serializable>(value: T): void;
+    /**
+     * Serializes an array of BCS Serializable values to a serializer instance.
+     * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+     *
+     * @param values The array of BCS Serializable values
+     * @example
+     * const addresses = new Array<AccountAddress>(
+     *   AccountAddress.fromRelaxed("0x1"),
+     *   AccountAddress.fromRelaxed("0x2"),
+     *   AccountAddress.fromRelaxed("0xa"),
+     *   AccountAddress.fromRelaxed("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])`;
+     */
+    serializeVector<T extends Serializable>(values: Array<T>): void;
+}
+declare function ensureBoolean(value: unknown): asserts value is boolean;
+declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
+declare function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T): void;
+
+export { Serializable, Serializer, ensureBoolean, outOfRangeErrorMessage, validateNumberInRange };

package/dist/esm/bcs/serializer.mjs

@@ -0,0 +1,2 @@
+import{a,b,c,d,e}from"../chunk-27P7PELS.mjs";import"../chunk-IZHPCZE3.mjs";import"../chunk-FBPNHF54.mjs";import"../chunk-DNDWTM7A.mjs";import"../chunk-XNFEUXDS.mjs";export{a as Serializable,b as Serializer,c as ensureBoolean,d as outOfRangeErrorMessage,e as validateNumberInRange};
+//# sourceMappingURL=serializer.mjs.map

package/dist/esm/bcs/serializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/chunk-2444YR3Y.mjs

@@ -0,0 +1,2 @@
+import{b as n}from"./chunk-2MQZUGO6.mjs";async function m(e){let{aptosConfig:t,overrides:s,params:r,contentType:o,acceptType:p,path:i,originMethod:a,type:u}=e,R=t.getRequestUrl(u);return n({url:R,method:"GET",originMethod:a,path:i,contentType:o?.valueOf(),acceptType:p?.valueOf(),params:r,overrides:{...t.clientConfig,...s}},t)}async function y(e){return m({...e,type:0})}async function f(e){let t=[],s,r=e.params;for(;;){r.start=s;let o=await y({aptosConfig:e.aptosConfig,originMethod:e.originMethod,path:e.path,params:r,overrides:e.overrides});if(s=o.headers["x-aptos-cursor"],delete o.headers,t.push(...o.data),s==null)break}return t}export{m as a,y as b,f as c};
+//# sourceMappingURL=chunk-2444YR3Y.mjs.map

package/dist/esm/chunk-2444YR3Y.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/get.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { aptosRequest } from \"./core\";\nimport { AptosResponse } from \"./types\";\nimport { AnyNumber, ClientConfig, MimeType } from \"../types\";\nimport { AptosApiType } from \"../utils/const\";\n\nexport type GetRequestOptions = {\n  /**\n   * The config for the API client\n   */\n  aptosConfig: AptosConfig;\n  /**\n   * The type of API endpoint to call e.g. fullnode, indexer, etc\n   */\n  type: AptosApiType;\n  /**\n   * The name of the API method\n   */\n  originMethod: string;\n  /**\n   * The URL path to the API method\n   */\n  path: string;\n  /**\n   * The content type of the request body\n   */\n  contentType?: MimeType;\n  /**\n   * The accepted content type of the response of the API\n   */\n  acceptType?: MimeType;\n  /**\n   * The query parameters for the request\n   */\n  params?: Record<string, string | AnyNumber | boolean | undefined>;\n  /**\n   * Specific client overrides for this request to override aptosConfig\n   */\n  overrides?: ClientConfig;\n};\n\nexport type GetAptosRequestOptions = Omit<GetRequestOptions, \"type\">;\n\n/**\n * Main function to do a Get request\n *\n * @param options GetRequestOptions\n * @returns\n */\nexport async function get<Req, Res>(options: GetRequestOptions): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosRequest<Req, Res>(\n    {\n      url,\n      method: \"GET\",\n      originMethod,\n      path,\n      contentType: contentType?.valueOf(),\n      acceptType: acceptType?.valueOf(),\n      params,\n      overrides: {\n        ...aptosConfig.clientConfig,\n        ...overrides,\n      },\n    },\n    aptosConfig,\n  );\n}\n\nexport async function getAptosFullNode<Req, Res>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>> {\n  return get<Req, Res>({ ...options, type: AptosApiType.FULLNODE });\n}\n\n/// This function is a helper for paginating using a function wrapping an API\nexport async function paginateWithCursor<Req extends Record<string, any>, Res extends any[]>(\n  options: GetAptosRequestOptions,\n): Promise<Res> {\n  const out = [];\n  let cursor: string | undefined;\n  const requestParams = options.params as Req & { start?: string; limit?: number };\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    requestParams.start = cursor;\n    // eslint-disable-next-line no-await-in-loop\n    const response = await getAptosFullNode<Req, Res>({\n      aptosConfig: options.aptosConfig,\n      originMethod: options.originMethod,\n      path: options.path,\n      params: requestParams,\n      overrides: options.overrides,\n    });\n    /**\n     * the cursor is a \"state key\" from the API perspective. Client\n     * should not need to \"care\" what it represents but just use it\n     * to query the next chunk of data.\n     */\n    cursor = response.headers[\"x-aptos-cursor\"];\n    // Now that we have the cursor (if any), we remove the headers before\n    // adding these to the output of this function.\n    delete (response as any).headers;\n    out.push(...response.data);\n    if (cursor === null || cursor === undefined) {\n      break;\n    }\n  }\n  return out as any;\n}\n"],"mappings":"yCAiDA,eAAsBA,EAAcC,EAA8D,CAChG,GAAM,CAAE,YAAAC,EAAa,UAAAC,EAAW,OAAAC,EAAQ,YAAAC,EAAa,WAAAC,EAAY,KAAAC,EAAM,aAAAC,EAAc,KAAAC,CAAK,EAAIR,EACxFS,EAAMR,EAAY,cAAcO,CAAI,EAE1C,OAAOE,EACL,CACE,IAAAD,EACA,OAAQ,MACR,aAAAF,EACA,KAAAD,EACA,YAAaF,GAAa,QAAQ,EAClC,WAAYC,GAAY,QAAQ,EAChC,OAAAF,EACA,UAAW,CACT,GAAGF,EAAY,aACf,GAAGC,CACL,CACF,EACAD,CACF,CACF,CAEA,eAAsBU,EAA2BX,EAAmE,CAClH,OAAOD,EAAc,CAAE,GAAGC,EAAS,MAA4B,CAAC,CAClE,CAGA,eAAsBY,EACpBZ,EACc,CACd,IAAMa,EAAM,CAAC,EACTC,EACEC,EAAgBf,EAAQ,OAE9B,OAAa,CACXe,EAAc,MAAQD,EAEtB,IAAME,EAAW,MAAML,EAA2B,CAChD,YAAaX,EAAQ,YACrB,aAAcA,EAAQ,aACtB,KAAMA,EAAQ,KACd,OAAQe,EACR,UAAWf,EAAQ,SACrB,CAAC,EAWD,GALAc,EAASE,EAAS,QAAQ,kBAG1B,OAAQA,EAAiB,QACzBH,EAAI,KAAK,GAAGG,EAAS,IAAI,EACrBF,GAAW,KACb,KAEJ,CACA,OAAOD,CACT","names":["get","options","aptosConfig","overrides","params","contentType","acceptType","path","originMethod","type","url","aptosRequest","getAptosFullNode","paginateWithCursor","out","cursor","requestParams","response"]}

package/dist/esm/chunk-27P7PELS.mjs

@@ -0,0 +1,2 @@
+import{b as c}from"./chunk-IZHPCZE3.mjs";import{a as U,b,c as f,d as u,e as h,f as y}from"./chunk-DNDWTM7A.mjs";import{a as s}from"./chunk-XNFEUXDS.mjs";var B=class{bcsToBytes(){let e=new n;return this.serialize(e),e.toUint8Array()}bcsToHex(){let e=this.bcsToBytes();return c.fromHexInput(e)}},n=class{constructor(e=64){if(e<=0)throw new Error("Length needs to be greater than 0");this.buffer=new ArrayBuffer(e),this.offset=0}ensureBufferWillHandleSize(e){for(;this.buffer.byteLength<this.offset+e;){let t=new ArrayBuffer(this.buffer.byteLength*2);new Uint8Array(t).set(new Uint8Array(this.buffer)),this.buffer=t}}appendToBuffer(e){this.ensureBufferWillHandleSize(e.length),new Uint8Array(this.buffer,this.offset).set(e),this.offset+=e.length}serializeWithFunction(e,t,i){this.ensureBufferWillHandleSize(t);let a=new DataView(this.buffer,this.offset);e.apply(a,[0,i,!0]),this.offset+=t}serializeStr(e){let t=new TextEncoder;this.serializeBytes(t.encode(e))}serializeBytes(e){this.serializeU32AsUleb128(e.length),this.appendToBuffer(e)}serializeFixedBytes(e){this.appendToBuffer(e)}serializeBool(e){A(e);let t=e?1:0;this.appendToBuffer(new Uint8Array([t]))}serializeU8(e){this.appendToBuffer(new Uint8Array([e]))}serializeU16(e){this.serializeWithFunction(DataView.prototype.setUint16,2,e)}serializeU32(e){this.serializeWithFunction(DataView.prototype.setUint32,4,e)}serializeU64(e){let t=BigInt(e)&BigInt(f),i=BigInt(e)>>BigInt(32);this.serializeU32(Number(t)),this.serializeU32(Number(i))}serializeU128(e){let t=BigInt(e)&u,i=BigInt(e)>>BigInt(64);this.serializeU64(t),this.serializeU64(i)}serializeU256(e){let t=BigInt(e)&h,i=BigInt(e)>>BigInt(128);this.serializeU128(t),this.serializeU128(i)}serializeU32AsUleb128(e){let t=e,i=[];for(;t>>>7!==0;)i.push(t&127|128),t>>>=7;i.push(t),this.appendToBuffer(new Uint8Array(i))}toUint8Array(){return new Uint8Array(this.buffer).slice(0,this.offset)}serialize(e){e.serialize(this)}serializeVector(e){this.serializeU32AsUleb128(e.length),e.forEach(t=>{t.serialize(this)})}};s([o(0,U)],n.prototype,"serializeU8",1),s([o(0,b)],n.prototype,"serializeU16",1),s([o(0,f)],n.prototype,"serializeU32",1),s([o(BigInt(0),u)],n.prototype,"serializeU64",1),s([o(BigInt(0),h)],n.prototype,"serializeU128",1),s([o(BigInt(0),y)],n.prototype,"serializeU256",1),s([o(0,f)],n.prototype,"serializeU32AsUleb128",1);function A(r){if(typeof r!="boolean")throw new Error(`${r} is not a boolean value`)}var g=(r,e,t)=>`${r} is out of range: [${e}, ${t}]`;function w(r,e,t){let i=BigInt(r);if(i>BigInt(t)||i<BigInt(e))throw new Error(g(r,e,t))}function o(r,e){return(t,i,a)=>{let p=a.value;return a.value=function(l){return w(l,r,e),p.apply(this,[l])},a}}export{B as a,n as b,A as c,g as d,w as e};
+//# sourceMappingURL=chunk-27P7PELS.mjs.map

package/dist/esm/chunk-27P7PELS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bcs/serializer.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable no-bitwise */\nimport {\n  MAX_U128_BIG_INT,\n  MAX_U16_NUMBER,\n  MAX_U32_NUMBER,\n  MAX_U64_BIG_INT,\n  MAX_U8_NUMBER,\n  MAX_U256_BIG_INT,\n} from \"./consts\";\nimport { Hex } from \"../core/hex\";\nimport { AnyNumber, Uint16, Uint32, Uint8 } from \"../types\";\n\n// This class is intended to be used as a base class for all serializable types.\n// It can be used to facilitate composable serialization of a complex type and\n// in general to serialize a type to its BCS representation.\nexport abstract class Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Serializes a `Serializable` value to its BCS representation.\n   * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.\n   * @returns the BCS representation of the Serializable instance as a byte buffer\n   */\n  bcsToBytes(): Uint8Array {\n    const serializer = new Serializer();\n    this.serialize(serializer);\n    return serializer.toUint8Array();\n  }\n\n  /**\n   * Helper function to get a value's BCS-serialized bytes as a Hex instance.\n   * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array\n   */\n  bcsToHex(): Hex {\n    const bcsBytes = this.bcsToBytes();\n    return Hex.fromHexInput(bcsBytes);\n  }\n}\n\nexport class Serializer {\n  private buffer: ArrayBuffer;\n\n  private offset: number;\n\n  // Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.\n  // `length` must be greater than 0.\n  constructor(length: number = 64) {\n    if (length <= 0) {\n      throw new Error(\"Length needs to be greater than 0\");\n    }\n    this.buffer = new ArrayBuffer(length);\n    this.offset = 0;\n  }\n\n  private ensureBufferWillHandleSize(bytes: number) {\n    while (this.buffer.byteLength < this.offset + bytes) {\n      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);\n      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));\n      this.buffer = newBuffer;\n    }\n  }\n\n  protected appendToBuffer(values: Uint8Array) {\n    this.ensureBufferWillHandleSize(values.length);\n    new Uint8Array(this.buffer, this.offset).set(values);\n    this.offset += values.length;\n  }\n\n  private serializeWithFunction(\n    fn: (byteOffset: number, value: number, littleEndian?: boolean) => void,\n    bytesLength: number,\n    value: number,\n  ) {\n    this.ensureBufferWillHandleSize(bytesLength);\n    const dv = new DataView(this.buffer, this.offset);\n    fn.apply(dv, [0, value, true]);\n    this.offset += bytesLength;\n  }\n\n  /**\n   * Serializes a string. UTF8 string is supported.\n   *\n   * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.\n   * Then the string content is serialized as UTF8 encoded bytes.\n   *\n   * BCS layout for \"string\": string_length | string_content\n   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.\n   *\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"1234abcd\");\n   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));\n   * ```\n   */\n  serializeStr(value: string) {\n    const textEncoder = new TextEncoder();\n    this.serializeBytes(textEncoder.encode(value));\n  }\n\n  /**\n   * Serializes an array of bytes.\n   *\n   * BCS layout for \"bytes\": bytes_length | bytes\n   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.\n   */\n  serializeBytes(value: Uint8Array) {\n    this.serializeU32AsUleb128(value.length);\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes an array of bytes with known length. Therefore, length doesn't need to be\n   * serialized to help deserialization.\n   *\n   * When deserializing, the number of bytes to deserialize needs to be passed in.\n   */\n  serializeFixedBytes(value: Uint8Array) {\n    this.appendToBuffer(value);\n  }\n\n  /**\n   * Serializes a boolean value.\n   *\n   * BCS layout for \"boolean\": One byte. \"0x01\" for true and \"0x00\" for false.\n   */\n  serializeBool(value: boolean) {\n    ensureBoolean(value);\n    const byteValue = value ? 1 : 0;\n    this.appendToBuffer(new Uint8Array([byteValue]));\n  }\n\n  /**\n   * Serializes a uint8 number.\n   *\n   * BCS layout for \"uint8\": One byte. Binary format in little-endian representation.\n   */\n  @checkNumberRange(0, MAX_U8_NUMBER)\n  serializeU8(value: Uint8) {\n    this.appendToBuffer(new Uint8Array([value]));\n  }\n\n  /**\n   * Serializes a uint16 number.\n   *\n   * BCS layout for \"uint16\": Two bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU16(4660);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U16_NUMBER)\n  serializeU16(value: Uint16) {\n    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);\n  }\n\n  /**\n   * Serializes a uint32 number.\n   *\n   * BCS layout for \"uint32\": Four bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU32(305419896);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32(value: Uint32) {\n    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);\n  }\n\n  /**\n   * Serializes a uint64 number.\n   *\n   * BCS layout for \"uint64\": Eight bytes. Binary format in little-endian representation.\n   * @example\n   * ```ts\n   * const serializer = new Serializer();\n   * serializer.serializeU64(1311768467750121216);\n   * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));\n   * ```\n   */\n  @checkNumberRange(BigInt(0), MAX_U64_BIG_INT)\n  serializeU64(value: AnyNumber) {\n    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);\n    const high = BigInt(value) >> BigInt(32);\n\n    // write little endian number\n    this.serializeU32(Number(low));\n    this.serializeU32(Number(high));\n  }\n\n  /**\n   * Serializes a uint128 number.\n   *\n   * BCS layout for \"uint128\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U128_BIG_INT)\n  serializeU128(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U64_BIG_INT;\n    const high = BigInt(value) >> BigInt(64);\n\n    // write little endian number\n    this.serializeU64(low);\n    this.serializeU64(high);\n  }\n\n  /**\n   * Serializes a uint256 number.\n   *\n   * BCS layout for \"uint256\": Sixteen bytes. Binary format in little-endian representation.\n   */\n  @checkNumberRange(BigInt(0), MAX_U256_BIG_INT)\n  serializeU256(value: AnyNumber) {\n    const low = BigInt(value) & MAX_U128_BIG_INT;\n    const high = BigInt(value) >> BigInt(128);\n\n    // write little endian number\n    this.serializeU128(low);\n    this.serializeU128(high);\n  }\n\n  /**\n   * Serializes a uint32 number with uleb128.\n   *\n   * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values\n   */\n  @checkNumberRange(0, MAX_U32_NUMBER)\n  serializeU32AsUleb128(val: Uint32) {\n    let value = val;\n    const valueArray = [];\n    while (value >>> 7 !== 0) {\n      valueArray.push((value & 0x7f) | 0x80);\n      value >>>= 7;\n    }\n    valueArray.push(value);\n    this.appendToBuffer(new Uint8Array(valueArray));\n  }\n\n  /**\n   * Returns the buffered bytes\n   */\n  toUint8Array(): Uint8Array {\n    return new Uint8Array(this.buffer).slice(0, this.offset);\n  }\n\n  /**\n   * Serializes a `Serializable` value, facilitating composable serialization.\n   *\n   * @param value The Serializable value to serialize\n   *\n   * @example\n   * // Define the MoveStruct class that implements the Serializable interface\n   * class MoveStruct extends Serializable {\n   *     constructor(\n   *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable\n   *         public collectionName: string,\n   *         public tokenName: string\n   *     ) {}\n   *\n   *     serialize(serializer: Serializer): void {\n   *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object\n   *         serializer.serializeStr(this.collectionName);\n   *         serializer.serializeStr(this.tokenName);\n   *     }\n   * }\n   *\n   * // Construct a MoveStruct\n   * const moveStruct = new MoveStruct(new AccountAddress(...), \"MyCollection\", \"TokenA\");\n   *\n   * // Serialize a string, a u64 number, and a MoveStruct instance.\n   * const serializer = new Serializer();\n   * serializer.serializeStr(\"ExampleString\");\n   * serializer.serializeU64(12345678);\n   * serializer.serialize(moveStruct);\n   *\n   * // Get the bytes from the Serializer instance\n   * const serializedBytes = serializer.toUint8Array();\n   *\n   * @returns the serializer instance\n   */\n  serialize<T extends Serializable>(value: T): void {\n    // NOTE: The `serialize` method called by `value` is defined in `value`'s\n    // Serializable interface, not the one defined in this class.\n    value.serialize(this);\n  }\n\n  /**\n   * Serializes an array of BCS Serializable values to a serializer instance.\n   * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.\n   *\n   * @param values The array of BCS Serializable values\n   * @example\n   * const addresses = new Array<AccountAddress>(\n   *   AccountAddress.fromRelaxed(\"0x1\"),\n   *   AccountAddress.fromRelaxed(\"0x2\"),\n   *   AccountAddress.fromRelaxed(\"0xa\"),\n   *   AccountAddress.fromRelaxed(\"0xb\"),\n   * );\n   * const serializer = new Serializer();\n   * serializer.serializeVector(addresses);\n   * const serializedBytes = serializer.toUint8Array();\n   * // serializedBytes is now the BCS-serialized bytes\n   * // The equivalent value in Move would be:\n   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;\n   */\n  serializeVector<T extends Serializable>(values: Array<T>): void {\n    this.serializeU32AsUleb128(values.length);\n    values.forEach((item) => {\n      item.serialize(this);\n    });\n  }\n}\n\nexport function ensureBoolean(value: unknown): asserts value is boolean {\n  if (typeof value !== \"boolean\") {\n    throw new Error(`${value} is not a boolean value`);\n  }\n}\n\nexport const outOfRangeErrorMessage = (value: AnyNumber, min: AnyNumber, max: AnyNumber) =>\n  `${value} is out of range: [${min}, ${max}]`;\n\nexport function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T) {\n  const valueBigInt = BigInt(value);\n  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {\n    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));\n  }\n}\n\n/**\n * A decorator to ensure the input argument for a function is within a range.\n * @param minValue The input argument must be >= minValue\n * @param maxValue The input argument must be <= maxValue\n */\nfunction checkNumberRange<T extends AnyNumber>(minValue: T, maxValue: T) {\n  return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {\n    const childFunction = descriptor.value;\n    // eslint-disable-next-line no-param-reassign\n    descriptor.value = function deco(value: AnyNumber) {\n      validateNumberInRange(value, minValue, maxValue);\n      return childFunction.apply(this, [value]);\n    };\n\n    return descriptor;\n  };\n}\n"],"mappings":"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","names":["Serializable","serializer","Serializer","bcsBytes","Hex","length","bytes","newBuffer","values","fn","bytesLength","value","dv","textEncoder","ensureBoolean","byteValue","low","MAX_U32_NUMBER","high","MAX_U64_BIG_INT","MAX_U128_BIG_INT","val","valueArray","item","__decorateClass","checkNumberRange","MAX_U8_NUMBER","MAX_U16_NUMBER","MAX_U256_BIG_INT","outOfRangeErrorMessage","min","max","validateNumberInRange","minValue","maxValue","valueBigInt","target","propertyKey","descriptor","childFunction"]}

package/dist/esm/chunk-2B5QXKPU.mjs

@@ -0,0 +1,2 @@
+import{g as p}from"./chunk-MIBLZSNS.mjs";import{p as a}from"./chunk-BTK34A5U.mjs";import{b as r}from"./chunk-HH5RSP2H.mjs";async function v(o){let{accountAddress:t,aptosConfig:e,creationNumber:n}=o,i={account_address:{_eq:r.from(t).toStringLong()},creation_number:{_eq:n}};return d({aptosConfig:e,options:{where:i}})}async function A(o){let{accountAddress:t,aptosConfig:e,eventType:n,options:s}=o,c={where:{account_address:{_eq:r.fromRelaxed(t).toStringLong()},indexed_type:{_eq:n}},pagination:s?.pagination,orderBy:s?.orderBy};return d({aptosConfig:e,options:c})}async function d(o){let{aptosConfig:t,options:e}=o,n={query:a,variables:{where_condition:e?.where,offset:e?.pagination?.offset,limit:e?.pagination?.limit,order_by:e?.orderBy}};return(await p({aptosConfig:t,query:n,originMethod:"getEvents"})).events}export{v as a,A as b,d as c};
+//# sourceMappingURL=chunk-2B5QXKPU.mjs.map

package/dist/esm/chunk-2B5QXKPU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internal/event.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/event}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * event namespace and without having a dependency cycle error.\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput } from \"../core\";\nimport { AnyNumber, GetEventsResponse, PaginationArgs, MoveStructType, OrderBy } from \"../types\";\nimport { GetEventsQuery } from \"../types/generated/operations\";\nimport { GetEvents } from \"../types/generated/queries\";\nimport { EventsBoolExp } from \"../types/generated/types\";\nimport { queryIndexer } from \"./general\";\n\nexport async function getAccountEventsByCreationNumber(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  creationNumber: AnyNumber;\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, creationNumber } = args;\n  const address = AccountAddress.from(accountAddress);\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address.toStringLong() },\n    creation_number: { _eq: creationNumber },\n  };\n\n  return getEvents({ aptosConfig, options: { where: whereCondition } });\n}\n\nexport async function getAccountEventsByEventType(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  eventType: MoveStructType;\n  options?: {\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetEventsResponse[0]>;\n  };\n}): Promise<GetEventsResponse> {\n  const { accountAddress, aptosConfig, eventType, options } = args;\n  const address = AccountAddress.fromRelaxed(accountAddress).toStringLong();\n\n  const whereCondition: EventsBoolExp = {\n    account_address: { _eq: address },\n    indexed_type: { _eq: eventType },\n  };\n\n  const customOptions = {\n    where: whereCondition,\n    pagination: options?.pagination,\n    orderBy: options?.orderBy,\n  };\n\n  return getEvents({ aptosConfig, options: customOptions });\n}\n\nexport async function getEvents(args: {\n  aptosConfig: AptosConfig;\n  options?: {\n    where?: EventsBoolExp;\n    pagination?: PaginationArgs;\n    orderBy?: OrderBy<GetEventsResponse[0]>;\n  };\n}): Promise<GetEventsResponse> {\n  const { aptosConfig, options } = args;\n\n  const graphqlQuery = {\n    query: GetEvents,\n    variables: {\n      where_condition: options?.where,\n      offset: options?.pagination?.offset,\n      limit: options?.pagination?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetEventsQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getEvents\",\n  });\n\n  return data.events;\n}\n"],"mappings":"2HAkBA,eAAsBA,EAAiCC,EAIxB,CAC7B,GAAM,CAAE,eAAAC,EAAgB,YAAAC,EAAa,eAAAC,CAAe,EAAIH,EAGlDI,EAAgC,CACpC,gBAAiB,CAAE,IAHLC,EAAe,KAAKJ,CAAc,EAGhB,aAAa,CAAE,EAC/C,gBAAiB,CAAE,IAAKE,CAAe,CACzC,EAEA,OAAOG,EAAU,CAAE,YAAAJ,EAAa,QAAS,CAAE,MAAOE,CAAe,CAAE,CAAC,CACtE,CAEA,eAAsBG,EAA4BP,EAQnB,CAC7B,GAAM,CAAE,eAAAC,EAAgB,YAAAC,EAAa,UAAAM,EAAW,QAAAC,CAAQ,EAAIT,EAQtDU,EAAgB,CACpB,MANoC,CACpC,gBAAiB,CAAE,IAHLL,EAAe,YAAYJ,CAAc,EAAE,aAAa,CAGtC,EAChC,aAAc,CAAE,IAAKO,CAAU,CACjC,EAIE,WAAYC,GAAS,WACrB,QAASA,GAAS,OACpB,EAEA,OAAOH,EAAU,CAAE,YAAAJ,EAAa,QAASQ,CAAc,CAAC,CAC1D,CAEA,eAAsBJ,EAAUN,EAOD,CAC7B,GAAM,CAAE,YAAAE,EAAa,QAAAO,CAAQ,EAAIT,EAE3BW,EAAe,CACnB,MAAOC,EACP,UAAW,CACT,gBAAiBH,GAAS,MAC1B,OAAQA,GAAS,YAAY,OAC7B,MAAOA,GAAS,YAAY,MAC5B,SAAUA,GAAS,OACrB,CACF,EAQA,OANa,MAAMI,EAA6B,CAC9C,YAAAX,EACA,MAAOS,EACP,aAAc,WAChB,CAAC,GAEW,MACd","names":["getAccountEventsByCreationNumber","args","accountAddress","aptosConfig","creationNumber","whereCondition","AccountAddress","getEvents","getAccountEventsByEventType","eventType","options","customOptions","graphqlQuery","GetEvents","queryIndexer"]}