@aptos-labs/ts-sdk 1.33.2 → 1.35.0-zeta.0

package/dist/common/chunk-CSUBLTFA.js

@@ -0,0 +1,1297 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/core/common.ts
+var ParsingError = class extends Error {
+  /**
+   * Creates an instance of the error with a specified message and invalid reason.
+   *
+   * @param message The error message that describes the issue.
+   * @param invalidReason The reason why the input is considered invalid.
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(message, invalidReason) {
+    super(message);
+    this.invalidReason = invalidReason;
+  }
+};
+
+// src/core/hex.ts
+var _utils = require('@noble/hashes/utils');
+var HexInvalidReason = /* @__PURE__ */ ((HexInvalidReason2) => {
+  HexInvalidReason2["TOO_SHORT"] = "too_short";
+  HexInvalidReason2["INVALID_LENGTH"] = "invalid_length";
+  HexInvalidReason2["INVALID_HEX_CHARS"] = "invalid_hex_chars";
+  return HexInvalidReason2;
+})(HexInvalidReason || {});
+var Hex = class _Hex {
+  /**
+   * Create a new Hex instance from a Uint8Array.
+   *
+   * @param data - The Uint8Array containing the data to initialize the Hex instance.
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(data) {
+    this.data = data;
+  }
+  // ===
+  // Methods for representing an instance of Hex as other types.
+  // ===
+  /**
+   * Get the inner hex data as a Uint8Array. The inner data is already a Uint8Array, so no conversion takes place.
+   *
+   * @returns Hex data as Uint8Array
+   * @group Implementation
+   * @category Serialization
+   */
+  toUint8Array() {
+    return this.data;
+  }
+  /**
+   * Get the hex data as a string without the 0x prefix.
+   *
+   * @returns Hex string without 0x prefix
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringWithoutPrefix() {
+    return _utils.bytesToHex.call(void 0, this.data);
+  }
+  /**
+   * Get the hex data as a string with the 0x prefix.
+   *
+   * @returns Hex string with 0x prefix
+   * @group Implementation
+   * @category Serialization
+   */
+  toString() {
+    return `0x${this.toStringWithoutPrefix()}`;
+  }
+  // ===
+  // Methods for creating an instance of Hex from other types.
+  // ===
+  /**
+   * Converts a hex string into a Hex instance, allowing for both prefixed and non-prefixed formats.
+   *
+   * @param str - A hex string, with or without the 0x prefix.
+   *
+   * @throws ParsingError - If the hex string is too short, has an odd number of characters, or contains invalid hex characters.
+   *
+   * @returns Hex - The resulting Hex instance created from the provided string.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromHexString(str) {
+    let input = str;
+    if (input.startsWith("0x")) {
+      input = input.slice(2);
+    }
+    if (input.length === 0) {
+      throw new ParsingError(
+        "Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.",
+        "too_short" /* TOO_SHORT */
+      );
+    }
+    if (input.length % 2 !== 0) {
+      throw new ParsingError("Hex string must be an even number of hex characters.", "invalid_length" /* INVALID_LENGTH */);
+    }
+    try {
+      return new _Hex(_utils.hexToBytes.call(void 0, input));
+    } catch (error) {
+      throw new ParsingError(
+        `Hex string contains invalid hex characters: ${_optionalChain([error, 'optionalAccess', _ => _.message])}`,
+        "invalid_hex_chars" /* INVALID_HEX_CHARS */
+      );
+    }
+  }
+  /**
+   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Hex instance.
+   * This function is useful for transforming hexadecimal representations into a structured Hex object for further manipulation.
+   *
+   * @param hexInput - A HexInput which can be a string or Uint8Array.
+   * @returns A Hex instance created from the provided hexInput.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromHexInput(hexInput) {
+    if (hexInput instanceof Buffer) return new _Hex(new Uint8Array(hexInput));
+    if (hexInput instanceof Uint8Array) return new _Hex(hexInput);
+    if (typeof hexInput === "string") return _Hex.fromHexString(hexInput);
+    throw new Error(`Invalid hex input type: ${typeof hexInput}`);
+  }
+  /**
+   * Converts an instance of HexInput, which can be a string or a Uint8Array, into a Uint8Array.
+   *
+   * @param hexInput - A HexInput which can be a string or Uint8Array.
+   * @returns A Uint8Array created from the provided hexInput.
+   */
+  static hexInputToUint8Array(hexInput) {
+    if (hexInput instanceof Uint8Array) return hexInput;
+    return _Hex.fromHexString(hexInput).toUint8Array();
+  }
+  /**
+   * Converts a HexInput (string or Uint8Array) to a hex string with '0x' prefix.
+   *
+   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
+   * @returns A hex string with '0x' prefix (e.g., "0x1234")
+   *
+   * @example
+   * ```typescript
+   * Hex.hexInputToString("1234")        // returns "0x1234"
+   * Hex.hexInputToString("0x1234")      // returns "0x1234"
+   * Hex.hexInputToString(new Uint8Array([0x12, 0x34])) // returns "0x1234"
+   * ```
+   */
+  static hexInputToString(hexInput) {
+    return _Hex.fromHexInput(hexInput).toString();
+  }
+  /**
+   * Converts a HexInput (string or Uint8Array) to a hex string without '0x' prefix.
+   *
+   * @param hexInput - The input to convert, either a hex string (with/without '0x' prefix) or Uint8Array
+   * @returns A hex string without '0x' prefix (e.g., "1234")
+   *
+   * @example
+   * ```typescript
+   * Hex.hexInputToStringWithoutPrefix("1234")        // returns "1234"
+   * Hex.hexInputToStringWithoutPrefix("0x1234")      // returns "1234"
+   * Hex.hexInputToStringWithoutPrefix(new Uint8Array([0x12, 0x34])) // returns "1234"
+   * ```
+   */
+  static hexInputToStringWithoutPrefix(hexInput) {
+    return _Hex.fromHexInput(hexInput).toStringWithoutPrefix();
+  }
+  // ===
+  // Methods for checking validity.
+  // ===
+  /**
+   * Check if the provided string is a valid hexadecimal representation.
+   *
+   * @param str - A hex string representing byte data.
+   *
+   * @returns An object containing:
+   *  - valid: A boolean indicating whether the string is valid.
+   *  - invalidReason: The reason for invalidity if the string is not valid.
+   *  - invalidReasonMessage: A message explaining why the string is invalid.
+   * @group Implementation
+   * @category Serialization
+   */
+  static isValid(str) {
+    try {
+      _Hex.fromHexString(str);
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        invalidReason: _optionalChain([error, 'optionalAccess', _2 => _2.invalidReason]),
+        invalidReasonMessage: _optionalChain([error, 'optionalAccess', _3 => _3.message])
+      };
+    }
+  }
+  /**
+   * Determine if two Hex instances are equal by comparing their underlying byte data.
+   *
+   * @param other The Hex instance to compare to.
+   * @returns true if the Hex instances are equal, false if not.
+   * @group Implementation
+   * @category Serialization
+   */
+  equals(other) {
+    if (this.data.length !== other.data.length) return false;
+    return this.data.every((value, index) => value === other.data[index]);
+  }
+};
+var hexToAsciiString = (hex) => new TextDecoder().decode(Hex.fromHexInput(hex).toUint8Array());
+
+// src/bcs/consts.ts
+var MAX_U8_NUMBER = 255;
+var MAX_U16_NUMBER = 65535;
+var MAX_U32_NUMBER = 4294967295;
+var MAX_U64_BIG_INT = 18446744073709551615n;
+var MAX_U128_BIG_INT = 340282366920938463463374607431768211455n;
+var MAX_U256_BIG_INT = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+
+// src/bcs/serializer.ts
+var Serializable = class {
+  /**
+   * 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.
+   * @group Implementation
+   * @category BCS
+   */
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  /**
+   * Converts the BCS-serialized bytes of a value into a Hex instance.
+   * This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
+   * @returns A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
+   * @group Implementation
+   * @category BCS
+   */
+  bcsToHex() {
+    const bcsBytes = this.bcsToBytes();
+    return Hex.fromHexInput(bcsBytes);
+  }
+  /**
+   * Returns the hex string representation of the `Serializable` value without the 0x prefix.
+   * @returns the hex format as a string without `0x` prefix.
+   */
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  /**
+   * Returns the hex string representation of the `Serializable` value with the 0x prefix.
+   * @returns the hex formatas a string prefixed by `0x`.
+   */
+  toString() {
+    return `0x${this.toStringWithoutPrefix()}`;
+  }
+};
+var Serializer = class {
+  /**
+   * Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
+   * The `length` must be greater than 0.
+   *
+   * @param length - The size of the buffer in bytes.
+   * @group Implementation
+   * @category BCS
+   */
+  constructor(length = 64) {
+    if (length <= 0) {
+      throw new Error("Length needs to be greater than 0");
+    }
+    this.buffer = new ArrayBuffer(length);
+    this.offset = 0;
+  }
+  /**
+   * Ensures that the internal buffer can accommodate the specified number of bytes.
+   * This function dynamically resizes the buffer if the current size is insufficient.
+   *
+   * @param bytes - The number of bytes to ensure the buffer can handle.
+   * @group Implementation
+   * @category BCS
+   */
+  ensureBufferWillHandleSize(bytes) {
+    while (this.buffer.byteLength < this.offset + bytes) {
+      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
+      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+      this.buffer = newBuffer;
+    }
+  }
+  /**
+   * Appends the specified values to the buffer, ensuring that the buffer can accommodate the new data.
+   *
+   * @param {Uint8Array} values - The values to be appended to the buffer.
+   * @group Implementation
+   * @category BCS
+   */
+  appendToBuffer(values) {
+    this.ensureBufferWillHandleSize(values.length);
+    new Uint8Array(this.buffer, this.offset).set(values);
+    this.offset += values.length;
+  }
+  /**
+   * Serializes a value into the buffer using the provided function, ensuring the buffer can accommodate the size.
+   *
+   * @param fn - The function to serialize the value, which takes a byte offset, the value to serialize, and an optional little-endian flag.
+   * @param fn.byteOffset - The byte offset at which to write the value.
+   * @param fn.value - The numeric value to serialize into the buffer.
+   * @param fn.littleEndian - Optional flag indicating whether to use little-endian byte order (defaults to true).
+   * @group Implementation
+   * @category BCS
+   */
+  // TODO: JSDoc bytesLength and value
+  serializeWithFunction(fn, bytesLength, value) {
+    this.ensureBufferWillHandleSize(bytesLength);
+    const dv = new DataView(this.buffer, this.offset);
+    fn.apply(dv, [0, value, true]);
+    this.offset += bytesLength;
+  }
+  /**
+   * 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.
+   *
+   * @param value - The string to serialize.
+   *
+   * @example
+   * ```typescript
+   * const serializer = new Serializer();
+   * serializer.serializeStr("1234abcd");
+   * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  serializeStr(value) {
+    const textEncoder = new TextEncoder();
+    this.serializeBytes(textEncoder.encode(value));
+  }
+  /**
+   * Serializes an array of bytes.
+   *
+   * This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself.
+   * BCS layout for "bytes": bytes_length | bytes
+   * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+   * @param value - The byte array to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  serializeBytes(value) {
+    this.serializeU32AsUleb128(value.length);
+    this.appendToBuffer(value);
+  }
+  /**
+     * Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the
+     * length itself.
+     * When deserializing, the number of bytes to deserialize needs to be passed in.
+  
+     * @param value - The Uint8Array to be serialized.
+     * @group Implementation
+     * @category BCS
+     */
+  serializeFixedBytes(value) {
+    this.appendToBuffer(value);
+  }
+  /**
+   * Serializes a boolean value into a byte representation.
+   *
+   * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
+   *
+   * @param value - The boolean value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  serializeBool(value) {
+    ensureBoolean(value);
+    const byteValue = value ? 1 : 0;
+    this.appendToBuffer(new Uint8Array([byteValue]));
+  }
+  serializeU8(value) {
+    this.appendToBuffer(new Uint8Array([value]));
+  }
+  serializeU16(value) {
+    this.serializeWithFunction(DataView.prototype.setUint16, 2, value);
+  }
+  serializeU32(value) {
+    this.serializeWithFunction(DataView.prototype.setUint32, 4, value);
+  }
+  serializeU64(value) {
+    const low = BigInt(value) & BigInt(MAX_U32_NUMBER);
+    const high = BigInt(value) >> BigInt(32);
+    this.serializeU32(Number(low));
+    this.serializeU32(Number(high));
+  }
+  serializeU128(value) {
+    const low = BigInt(value) & MAX_U64_BIG_INT;
+    const high = BigInt(value) >> BigInt(64);
+    this.serializeU64(low);
+    this.serializeU64(high);
+  }
+  serializeU256(value) {
+    const low = BigInt(value) & MAX_U128_BIG_INT;
+    const high = BigInt(value) >> BigInt(128);
+    this.serializeU128(low);
+    this.serializeU128(high);
+  }
+  serializeU32AsUleb128(val) {
+    let value = val;
+    const valueArray = [];
+    while (value >>> 7 !== 0) {
+      valueArray.push(value & 127 | 128);
+      value >>>= 7;
+    }
+    valueArray.push(value);
+    this.appendToBuffer(new Uint8Array(valueArray));
+  }
+  /**
+   * Returns the buffered bytes as a Uint8Array.
+   *
+   * This function allows you to retrieve the byte representation of the buffer up to the current offset.
+   *
+   * @returns Uint8Array - The byte array representation of the buffer.
+   * @group Implementation
+   * @category BCS
+   */
+  toUint8Array() {
+    return new Uint8Array(this.buffer).slice(0, this.offset);
+  }
+  /**
+   * Serializes a `Serializable` value, facilitating composable serialization.
+   *
+   * @param value The Serializable value to serialize.
+   *
+   * @returns the serializer instance
+   * @group Implementation
+   * @category BCS
+   */
+  serialize(value) {
+    value.serialize(this);
+  }
+  /**
+   * Serializes an array of BCS Serializable values to a serializer instance.
+   * 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.from("0x1"),
+   *   AccountAddress.from("0x2"),
+   *   AccountAddress.from("0xa"),
+   *   AccountAddress.from("0xb"),
+   * );
+   * const serializer = new Serializer();
+   * serializer.serializeVector(addresses);
+   * const serializedBytes = serializer.toUint8Array();
+   * // serializedBytes is now the BCS-serialized bytes
+   * // The equivalent value in Move would be:
+   * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
+   * @group Implementation
+   * @category BCS
+   */
+  serializeVector(values) {
+    this.serializeU32AsUleb128(values.length);
+    values.forEach((item) => {
+      item.serialize(this);
+    });
+  }
+  /**
+   * Serializes an optional value which can be a Serializable, string, or Uint8Array.
+   * For strings and Uint8Arrays, it uses the appropriate serialization method.
+   *
+   * @param value The value to serialize (Serializable, string, Uint8Array, or undefined)
+   * @param len Optional fixed length for Uint8Array serialization. If provided, uses serializeFixedBytes instead of serializeBytes
+   *
+   * @example
+   * ```typescript
+   * const serializer = new Serializer();
+   * serializer.serializeOption("hello");  // Serializes optional string
+   * serializer.serializeOption(new Uint8Array([1, 2, 3]));  // Serializes optional bytes
+   * serializer.serializeOption(new Uint8Array([1, 2, 3]), 3);  // Serializes optional fixed-length bytes
+   * serializer.serializeOption(new AccountAddress(...));  // Serializes optional Serializable
+   * serializer.serializeOption(undefined);  // Serializes none case
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  serializeOption(value, len) {
+    const hasValue = value !== void 0;
+    this.serializeBool(hasValue);
+    if (hasValue) {
+      if (typeof value === "string") {
+        this.serializeStr(value);
+      } else if (value instanceof Uint8Array) {
+        if (len !== void 0) {
+          this.serializeFixedBytes(value);
+        } else {
+          this.serializeBytes(value);
+        }
+      } else {
+        value.serialize(this);
+      }
+    }
+  }
+  /**
+   * @deprecated use `serializeOption` instead.
+   * Serializes an optional string, supporting UTF8 encoding.
+   * The function encodes the existence of the string first, followed by the length and content if it exists.
+   *
+   * BCS layout for optional "string": 1 | string_length | string_content
+   * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
+   * BCS layout for undefined: 0
+   *
+   * @param value - The optional string to serialize. If undefined, it will serialize as 0.
+   * @group Implementation
+   * @category BCS
+   */
+  serializeOptionStr(value) {
+    if (value === void 0) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      this.serializeStr(value);
+    }
+  }
+};
+__decorateClass([
+  checkNumberRange(0, MAX_U8_NUMBER)
+], Serializer.prototype, "serializeU8", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U16_NUMBER)
+], Serializer.prototype, "serializeU16", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U32_NUMBER)
+], Serializer.prototype, "serializeU32", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
+], Serializer.prototype, "serializeU64", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
+], Serializer.prototype, "serializeU128", 1);
+__decorateClass([
+  checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
+], Serializer.prototype, "serializeU256", 1);
+__decorateClass([
+  checkNumberRange(0, MAX_U32_NUMBER)
+], Serializer.prototype, "serializeU32AsUleb128", 1);
+function ensureBoolean(value) {
+  if (typeof value !== "boolean") {
+    throw new Error(`${value} is not a boolean value`);
+  }
+}
+var outOfRangeErrorMessage = (value, min, max) => `${value} is out of range: [${min}, ${max}]`;
+function validateNumberInRange(value, minValue, maxValue) {
+  const valueBigInt = BigInt(value);
+  if (valueBigInt > BigInt(maxValue) || valueBigInt < BigInt(minValue)) {
+    throw new Error(outOfRangeErrorMessage(value, minValue, maxValue));
+  }
+}
+function checkNumberRange(minValue, maxValue) {
+  return (target, propertyKey, descriptor) => {
+    const childFunction = descriptor.value;
+    descriptor.value = function deco(value) {
+      validateNumberInRange(value, minValue, maxValue);
+      return childFunction.apply(this, [value]);
+    };
+    return descriptor;
+  };
+}
+
+// src/types/types.ts
+var MimeType = /* @__PURE__ */ ((MimeType2) => {
+  MimeType2["JSON"] = "application/json";
+  MimeType2["BCS"] = "application/x-bcs";
+  MimeType2["BCS_SIGNED_TRANSACTION"] = "application/x.aptos.signed_transaction+bcs";
+  MimeType2["BCS_VIEW_FUNCTION"] = "application/x.aptos.view_function+bcs";
+  return MimeType2;
+})(MimeType || {});
+var TypeTagVariants = /* @__PURE__ */ ((TypeTagVariants2) => {
+  TypeTagVariants2[TypeTagVariants2["Bool"] = 0] = "Bool";
+  TypeTagVariants2[TypeTagVariants2["U8"] = 1] = "U8";
+  TypeTagVariants2[TypeTagVariants2["U64"] = 2] = "U64";
+  TypeTagVariants2[TypeTagVariants2["U128"] = 3] = "U128";
+  TypeTagVariants2[TypeTagVariants2["Address"] = 4] = "Address";
+  TypeTagVariants2[TypeTagVariants2["Signer"] = 5] = "Signer";
+  TypeTagVariants2[TypeTagVariants2["Vector"] = 6] = "Vector";
+  TypeTagVariants2[TypeTagVariants2["Struct"] = 7] = "Struct";
+  TypeTagVariants2[TypeTagVariants2["U16"] = 8] = "U16";
+  TypeTagVariants2[TypeTagVariants2["U32"] = 9] = "U32";
+  TypeTagVariants2[TypeTagVariants2["U256"] = 10] = "U256";
+  TypeTagVariants2[TypeTagVariants2["Reference"] = 254] = "Reference";
+  TypeTagVariants2[TypeTagVariants2["Generic"] = 255] = "Generic";
+  return TypeTagVariants2;
+})(TypeTagVariants || {});
+var ScriptTransactionArgumentVariants = /* @__PURE__ */ ((ScriptTransactionArgumentVariants2) => {
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U8"] = 0] = "U8";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U64"] = 1] = "U64";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U128"] = 2] = "U128";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["Address"] = 3] = "Address";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U8Vector"] = 4] = "U8Vector";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["Bool"] = 5] = "Bool";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U16"] = 6] = "U16";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U32"] = 7] = "U32";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["U256"] = 8] = "U256";
+  ScriptTransactionArgumentVariants2[ScriptTransactionArgumentVariants2["Serialized"] = 9] = "Serialized";
+  return ScriptTransactionArgumentVariants2;
+})(ScriptTransactionArgumentVariants || {});
+var TransactionPayloadVariants = /* @__PURE__ */ ((TransactionPayloadVariants2) => {
+  TransactionPayloadVariants2[TransactionPayloadVariants2["Script"] = 0] = "Script";
+  TransactionPayloadVariants2[TransactionPayloadVariants2["EntryFunction"] = 2] = "EntryFunction";
+  TransactionPayloadVariants2[TransactionPayloadVariants2["Multisig"] = 3] = "Multisig";
+  return TransactionPayloadVariants2;
+})(TransactionPayloadVariants || {});
+var TransactionVariants = /* @__PURE__ */ ((TransactionVariants2) => {
+  TransactionVariants2[TransactionVariants2["MultiAgentTransaction"] = 0] = "MultiAgentTransaction";
+  TransactionVariants2[TransactionVariants2["FeePayerTransaction"] = 1] = "FeePayerTransaction";
+  return TransactionVariants2;
+})(TransactionVariants || {});
+var TransactionAuthenticatorVariant = /* @__PURE__ */ ((TransactionAuthenticatorVariant2) => {
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["Ed25519"] = 0] = "Ed25519";
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["MultiEd25519"] = 1] = "MultiEd25519";
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["MultiAgent"] = 2] = "MultiAgent";
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["FeePayer"] = 3] = "FeePayer";
+  TransactionAuthenticatorVariant2[TransactionAuthenticatorVariant2["SingleSender"] = 4] = "SingleSender";
+  return TransactionAuthenticatorVariant2;
+})(TransactionAuthenticatorVariant || {});
+var AccountAuthenticatorVariant = /* @__PURE__ */ ((AccountAuthenticatorVariant2) => {
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["Ed25519"] = 0] = "Ed25519";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["MultiEd25519"] = 1] = "MultiEd25519";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["SingleKey"] = 2] = "SingleKey";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["MultiKey"] = 3] = "MultiKey";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["NoAccountAuthenticator"] = 4] = "NoAccountAuthenticator";
+  AccountAuthenticatorVariant2[AccountAuthenticatorVariant2["Abstraction"] = 5] = "Abstraction";
+  return AccountAuthenticatorVariant2;
+})(AccountAuthenticatorVariant || {});
+var PrivateKeyVariants = /* @__PURE__ */ ((PrivateKeyVariants2) => {
+  PrivateKeyVariants2["Ed25519"] = "ed25519";
+  PrivateKeyVariants2["Secp256k1"] = "secp256k1";
+  return PrivateKeyVariants2;
+})(PrivateKeyVariants || {});
+var AnyPublicKeyVariant = /* @__PURE__ */ ((AnyPublicKeyVariant2) => {
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["Ed25519"] = 0] = "Ed25519";
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["Secp256k1"] = 1] = "Secp256k1";
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["Keyless"] = 3] = "Keyless";
+  AnyPublicKeyVariant2[AnyPublicKeyVariant2["FederatedKeyless"] = 4] = "FederatedKeyless";
+  return AnyPublicKeyVariant2;
+})(AnyPublicKeyVariant || {});
+var AnySignatureVariant = /* @__PURE__ */ ((AnySignatureVariant2) => {
+  AnySignatureVariant2[AnySignatureVariant2["Ed25519"] = 0] = "Ed25519";
+  AnySignatureVariant2[AnySignatureVariant2["Secp256k1"] = 1] = "Secp256k1";
+  AnySignatureVariant2[AnySignatureVariant2["Keyless"] = 3] = "Keyless";
+  return AnySignatureVariant2;
+})(AnySignatureVariant || {});
+var EphemeralPublicKeyVariant = /* @__PURE__ */ ((EphemeralPublicKeyVariant2) => {
+  EphemeralPublicKeyVariant2[EphemeralPublicKeyVariant2["Ed25519"] = 0] = "Ed25519";
+  return EphemeralPublicKeyVariant2;
+})(EphemeralPublicKeyVariant || {});
+var EphemeralSignatureVariant = /* @__PURE__ */ ((EphemeralSignatureVariant2) => {
+  EphemeralSignatureVariant2[EphemeralSignatureVariant2["Ed25519"] = 0] = "Ed25519";
+  return EphemeralSignatureVariant2;
+})(EphemeralSignatureVariant || {});
+var EphemeralCertificateVariant = /* @__PURE__ */ ((EphemeralCertificateVariant2) => {
+  EphemeralCertificateVariant2[EphemeralCertificateVariant2["ZkProof"] = 0] = "ZkProof";
+  return EphemeralCertificateVariant2;
+})(EphemeralCertificateVariant || {});
+var ZkpVariant = /* @__PURE__ */ ((ZkpVariant2) => {
+  ZkpVariant2[ZkpVariant2["Groth16"] = 0] = "Groth16";
+  return ZkpVariant2;
+})(ZkpVariant || {});
+var TransactionResponseType = /* @__PURE__ */ ((TransactionResponseType2) => {
+  TransactionResponseType2["Pending"] = "pending_transaction";
+  TransactionResponseType2["User"] = "user_transaction";
+  TransactionResponseType2["Genesis"] = "genesis_transaction";
+  TransactionResponseType2["BlockMetadata"] = "block_metadata_transaction";
+  TransactionResponseType2["StateCheckpoint"] = "state_checkpoint_transaction";
+  TransactionResponseType2["Validator"] = "validator_transaction";
+  TransactionResponseType2["BlockEpilogue"] = "block_epilogue_transaction";
+  return TransactionResponseType2;
+})(TransactionResponseType || {});
+function isPendingTransactionResponse(response) {
+  return response.type === "pending_transaction" /* Pending */;
+}
+function isUserTransactionResponse(response) {
+  return response.type === "user_transaction" /* User */;
+}
+function isGenesisTransactionResponse(response) {
+  return response.type === "genesis_transaction" /* Genesis */;
+}
+function isBlockMetadataTransactionResponse(response) {
+  return response.type === "block_metadata_transaction" /* BlockMetadata */;
+}
+function isStateCheckpointTransactionResponse(response) {
+  return response.type === "state_checkpoint_transaction" /* StateCheckpoint */;
+}
+function isValidatorTransactionResponse(response) {
+  return response.type === "validator_transaction" /* Validator */;
+}
+function isBlockEpilogueTransactionResponse(response) {
+  return response.type === "block_epilogue_transaction" /* BlockEpilogue */;
+}
+function isEd25519Signature(signature) {
+  return "signature" in signature && signature.type === "ed25519_signature";
+}
+function isSecp256k1Signature(signature) {
+  return "signature" in signature && signature.signature === "secp256k1_ecdsa_signature";
+}
+function isMultiAgentSignature(signature) {
+  return signature.type === "multi_agent_signature";
+}
+function isFeePayerSignature(signature) {
+  return signature.type === "fee_payer_signature";
+}
+function isMultiEd25519Signature(signature) {
+  return signature.type === "multi_ed25519_signature";
+}
+function isSingleSenderSignature(signature) {
+  return signature.type === "single_sender";
+}
+var MoveFunctionVisibility = /* @__PURE__ */ ((MoveFunctionVisibility2) => {
+  MoveFunctionVisibility2["PRIVATE"] = "private";
+  MoveFunctionVisibility2["PUBLIC"] = "public";
+  MoveFunctionVisibility2["FRIEND"] = "friend";
+  return MoveFunctionVisibility2;
+})(MoveFunctionVisibility || {});
+var MoveAbility = /* @__PURE__ */ ((MoveAbility2) => {
+  MoveAbility2["STORE"] = "store";
+  MoveAbility2["DROP"] = "drop";
+  MoveAbility2["KEY"] = "key";
+  MoveAbility2["COPY"] = "copy";
+  return MoveAbility2;
+})(MoveAbility || {});
+var RoleType = /* @__PURE__ */ ((RoleType2) => {
+  RoleType2["VALIDATOR"] = "validator";
+  RoleType2["FULL_NODE"] = "full_node";
+  return RoleType2;
+})(RoleType || {});
+var SigningScheme = /* @__PURE__ */ ((SigningScheme2) => {
+  SigningScheme2[SigningScheme2["Ed25519"] = 0] = "Ed25519";
+  SigningScheme2[SigningScheme2["MultiEd25519"] = 1] = "MultiEd25519";
+  SigningScheme2[SigningScheme2["SingleKey"] = 2] = "SingleKey";
+  SigningScheme2[SigningScheme2["MultiKey"] = 3] = "MultiKey";
+  return SigningScheme2;
+})(SigningScheme || {});
+var SigningSchemeInput = /* @__PURE__ */ ((SigningSchemeInput2) => {
+  SigningSchemeInput2[SigningSchemeInput2["Ed25519"] = 0] = "Ed25519";
+  SigningSchemeInput2[SigningSchemeInput2["Secp256k1Ecdsa"] = 2] = "Secp256k1Ecdsa";
+  return SigningSchemeInput2;
+})(SigningSchemeInput || {});
+var DeriveScheme = /* @__PURE__ */ ((DeriveScheme2) => {
+  DeriveScheme2[DeriveScheme2["DeriveAuid"] = 251] = "DeriveAuid";
+  DeriveScheme2[DeriveScheme2["DeriveObjectAddressFromObject"] = 252] = "DeriveObjectAddressFromObject";
+  DeriveScheme2[DeriveScheme2["DeriveObjectAddressFromGuid"] = 253] = "DeriveObjectAddressFromGuid";
+  DeriveScheme2[DeriveScheme2["DeriveObjectAddressFromSeed"] = 254] = "DeriveObjectAddressFromSeed";
+  DeriveScheme2[DeriveScheme2["DeriveResourceAccountAddress"] = 255] = "DeriveResourceAccountAddress";
+  return DeriveScheme2;
+})(DeriveScheme || {});
+
+// src/types/index.ts
+var _scriptcomposerpack = require('@aptos-labs/script-composer-pack');
+
+// src/core/accountAddress.ts
+
+var AddressInvalidReason = /* @__PURE__ */ ((AddressInvalidReason2) => {
+  AddressInvalidReason2["INCORRECT_NUMBER_OF_BYTES"] = "incorrect_number_of_bytes";
+  AddressInvalidReason2["INVALID_HEX_CHARS"] = "invalid_hex_chars";
+  AddressInvalidReason2["TOO_SHORT"] = "too_short";
+  AddressInvalidReason2["TOO_LONG"] = "too_long";
+  AddressInvalidReason2["LEADING_ZERO_X_REQUIRED"] = "leading_zero_x_required";
+  AddressInvalidReason2["LONG_FORM_REQUIRED_UNLESS_SPECIAL"] = "long_form_required_unless_special";
+  AddressInvalidReason2["INVALID_PADDING_ZEROES"] = "INVALID_PADDING_ZEROES";
+  AddressInvalidReason2["INVALID_PADDING_STRICTNESS"] = "INVALID_PADDING_STRICTNESS";
+  return AddressInvalidReason2;
+})(AddressInvalidReason || {});
+var _AccountAddress = class _AccountAddress extends Serializable {
+  /**
+   * Creates an instance of AccountAddress from a Uint8Array.
+   *
+   * This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.
+   *
+   * @param input A Uint8Array representing an account address.
+   * @throws ParsingError if the input length is not equal to 32 bytes.
+   * @group Implementation
+   * @category Serialization
+   */
+  constructor(input) {
+    super();
+    if (input.length !== _AccountAddress.LENGTH) {
+      throw new ParsingError(
+        "AccountAddress data should be exactly 32 bytes long",
+        "incorrect_number_of_bytes" /* INCORRECT_NUMBER_OF_BYTES */
+      );
+    }
+    this.data = input;
+  }
+  /**
+   * Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive.
+   * In other words, the last byte of the address must be < 0b10000 (16)
+   * and every other byte must be zero.
+   *
+   * For more information on how special addresses are defined, see AIP-40:
+   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+   *
+   * @returns true if the address is special, false otherwise.
+   * @group Implementation
+   * @category Serialization
+   */
+  isSpecial() {
+    return this.data.slice(0, this.data.length - 1).every((byte) => byte === 0) && this.data[this.data.length - 1] < 16;
+  }
+  // ===
+  // Methods for representing an instance of AccountAddress as other types.
+  // ===
+  /**
+   * Return the AccountAddress as a string as per AIP-40.
+   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+   * This representation returns special addresses in SHORT form (0xf)
+   * and other addresses in LONG form (0x + 64 characters).
+   *
+   * @returns AccountAddress as a string conforming to AIP-40.
+   * @group Implementation
+   * @category Serialization
+   */
+  toString() {
+    return `0x${this.toStringWithoutPrefix()}`;
+  }
+  /**
+   * Return the AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+   *
+   * NOTE: Prefer to use `toString` where possible.
+   *
+   * @returns AccountAddress as a string without the leading 0x.
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringWithoutPrefix() {
+    let hex = _utils.bytesToHex.call(void 0, this.data);
+    if (this.isSpecial()) {
+      hex = hex[hex.length - 1];
+    }
+    return hex;
+  }
+  /**
+   * Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.
+   *
+   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
+   *
+   * @returns AccountAddress as a string in LONG form.
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringLong() {
+    return `0x${this.toStringLongWithoutPrefix()}`;
+  }
+  /**
+   * Returns the account address as a string in LONG form without a leading 0x.
+   * This function will include leading zeroes and will produce a string of 64 hex characters.
+   *
+   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
+   *
+   * @returns {string} The account address in LONG form.
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringLongWithoutPrefix() {
+    return _utils.bytesToHex.call(void 0, this.data);
+  }
+  /**
+   * Get the inner data as a Uint8Array.
+   * The inner data is already a Uint8Array, so no conversion takes place.
+   *
+   * @returns Hex data as Uint8Array
+   * @group Implementation
+   * @category Serialization
+   */
+  toUint8Array() {
+    return this.data;
+  }
+  /**
+   * Serialize the AccountAddress to a Serializer instance's data buffer.
+   * @param serializer The serializer to serialize the AccountAddress to.
+   * @returns void
+   * @example
+   * const serializer = new Serializer();
+   * const address = AccountAddress.fromString("0x1");
+   * address.serialize(serializer);
+   * const bytes = serializer.toUint8Array();
+   * // `bytes` is now the BCS-serialized address.
+   * @group Implementation
+   * @category Serialization
+   */
+  serialize(serializer) {
+    serializer.serializeFixedBytes(this.data);
+  }
+  /**
+   * Serializes the current instance into a byte sequence suitable for entry functions.
+   * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+   *
+   * @param serializer - The serializer instance used to convert the data into bytes.
+   * @group Implementation
+   * @category Serialization
+   */
+  serializeForEntryFunction(serializer) {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+  /**
+   * Serializes the current instance for use in a script function by encoding it into a byte sequence.
+   * This process involves serializing the variant index and the instance data, making it suitable for transmission.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Serialization
+   */
+  serializeForScriptFunction(serializer) {
+    serializer.serializeU32AsUleb128(3 /* Address */);
+    serializer.serialize(this);
+  }
+  /**
+   * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+   * This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.
+   * @param deserializer The deserializer to deserialize the AccountAddress from.
+   * @returns An instance of AccountAddress.
+   * @example
+   * const bytes = hexToBytes("0x0102030405060708091011121314151617181920212223242526272829303132");
+   * const deserializer = new Deserializer(bytes);
+   * const address = AccountAddress.deserialize(deserializer);
+   * // `address` is now an instance of AccountAddress.
+   * @group Implementation
+   * @category Serialization
+   */
+  static deserialize(deserializer) {
+    const bytes = deserializer.deserializeFixedBytes(_AccountAddress.LENGTH);
+    return new _AccountAddress(bytes);
+  }
+  // ===
+  // Methods for creating an instance of AccountAddress from other types.
+  // ===
+  /**
+   * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
+   * the `fromString` function.
+   *
+   * Creates an instance of AccountAddress from a hex string.
+   *
+   * This function allows only the strictest formats defined by AIP-40. In short this
+   * means only the following formats are accepted:
+   *
+   * - LONG
+   * - SHORT for special addresses
+   *
+   * Where:
+   * - LONG is defined as 0x + 64 hex characters.
+   * - SHORT for special addresses is 0x0 to 0xf inclusive without padding zeroes.
+   *
+   * This means the following are not accepted:
+   * - SHORT for non-special addresses.
+   * - Any address without a leading 0x.
+   *
+   * @param input - A hex string representing an account address.
+   *
+   * @throws {ParsingError} If the hex string does not start with 0x or is not in a valid format.
+   *
+   * @remarks
+   *
+   * This function has strict parsing behavior. For relaxed behavior, please use the `fromString` function.
+   *
+   * @see AIP-40 documentation for more details on address formats:
+   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+   *
+   * @returns An instance of AccountAddress.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromStringStrict(input) {
+    if (!input.startsWith("0x")) {
+      throw new ParsingError("Hex string must start with a leading 0x.", "leading_zero_x_required" /* LEADING_ZERO_X_REQUIRED */);
+    }
+    const address = _AccountAddress.fromString(input);
+    if (input.length !== _AccountAddress.LONG_STRING_LENGTH + 2) {
+      if (!address.isSpecial()) {
+        throw new ParsingError(
+          `The given hex string ${input} is not a special address, it must be represented as 0x + 64 chars.`,
+          "long_form_required_unless_special" /* LONG_FORM_REQUIRED_UNLESS_SPECIAL */
+        );
+      } else if (input.length !== 3) {
+        throw new ParsingError(
+          // eslint-disable-next-line max-len
+          `The given hex string ${input} is a special address not in LONG form, it must be 0x0 to 0xf without padding zeroes.`,
+          "INVALID_PADDING_ZEROES" /* INVALID_PADDING_ZEROES */
+        );
+      }
+    }
+    return address;
+  }
+  /**
+   * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
+   * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
+   * function, `fromString`.
+   *
+   * Creates an instance of AccountAddress from a hex string.
+   *
+   * This function allows all formats defined by AIP-40. In short this means the
+   * following formats are accepted:
+   *
+   * - LONG, with or without leading 0x
+   * - SHORT*, with or without leading 0x
+   *
+   * Where:
+   * - LONG is 64 hex characters.
+   * - SHORT* is 1 to 63 hex characters inclusive. The address can have missing values up to `maxMissingChars` before it is padded.
+   * - Padding zeroes are allowed, e.g. 0x0123 is valid.
+   *
+   * Learn more about the different address formats by reading AIP-40:
+   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+   *
+   * @param input A hex string representing an account address.
+   * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.
+   *
+   * @returns An instance of AccountAddress.
+   *
+   * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromString(input, { maxMissingChars = 4 } = {}) {
+    let parsedInput = input;
+    if (input.startsWith("0x")) {
+      parsedInput = input.slice(2);
+    }
+    if (parsedInput.length === 0) {
+      throw new ParsingError(
+        "Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.",
+        "too_short" /* TOO_SHORT */
+      );
+    }
+    if (parsedInput.length > 64) {
+      throw new ParsingError(
+        "Hex string is too long, must be 1 to 64 chars long, excluding the leading 0x.",
+        "too_long" /* TOO_LONG */
+      );
+    }
+    if (maxMissingChars > 63 || maxMissingChars < 0) {
+      throw new ParsingError(
+        `maxMissingChars must be between or equal to 0 and 63. Received ${maxMissingChars}`,
+        "INVALID_PADDING_STRICTNESS" /* INVALID_PADDING_STRICTNESS */
+      );
+    }
+    let addressBytes;
+    try {
+      addressBytes = _utils.hexToBytes.call(void 0, parsedInput.padStart(64, "0"));
+    } catch (error) {
+      throw new ParsingError(`Hex characters are invalid: ${_optionalChain([error, 'optionalAccess', _4 => _4.message])}`, "invalid_hex_chars" /* INVALID_HEX_CHARS */);
+    }
+    const address = new _AccountAddress(addressBytes);
+    if (parsedInput.length < 64 - maxMissingChars) {
+      if (!address.isSpecial()) {
+        throw new ParsingError(
+          `Hex string is too short, must be ${64 - maxMissingChars} to 64 chars long, excluding the leading 0x. You may need to fix 
+the addresss by padding it with 0s before passing it to \`fromString\` (e.g. <addressString>.padStart(64, '0')). 
+Received ${input}`,
+          "too_short" /* TOO_SHORT */
+        );
+      }
+    }
+    return address;
+  }
+  /**
+   * Convenience method for creating an AccountAddress from various input types.
+   * This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding
+   * AccountAddress.
+   *
+   * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,
+   * or an existing AccountAddress.
+   * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.
+   * @group Implementation
+   * @category Serialization
+   */
+  static from(input, { maxMissingChars = 4 } = {}) {
+    if (typeof input === "string") {
+      return _AccountAddress.fromString(input, { maxMissingChars });
+    }
+    if (input instanceof Uint8Array) {
+      return new _AccountAddress(input);
+    }
+    return input;
+  }
+  /**
+   * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
+   *
+   * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
+   * @group Implementation
+   * @category Serialization
+   */
+  static fromStrict(input) {
+    if (typeof input === "string") {
+      return _AccountAddress.fromStringStrict(input);
+    }
+    if (input instanceof Uint8Array) {
+      return new _AccountAddress(input);
+    }
+    return input;
+  }
+  // ===
+  // Methods for checking validity.
+  // ===
+  /**
+   * Check if the provided input is a valid AccountAddress.
+   *
+   * @param args - The arguments for validation.
+   * @param args.input - A hex string representing an account address.
+   * @param args.strict - If true, use strict parsing behavior; if false, use relaxed parsing behavior.
+   *
+   * @returns An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details.
+   * If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.
+   * @group Implementation
+   * @category Serialization
+   */
+  static isValid(args) {
+    try {
+      if (args.strict) {
+        _AccountAddress.fromStrict(args.input);
+      } else {
+        _AccountAddress.from(args.input);
+      }
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        invalidReason: _optionalChain([error, 'optionalAccess', _5 => _5.invalidReason]),
+        invalidReasonMessage: _optionalChain([error, 'optionalAccess', _6 => _6.message])
+      };
+    }
+  }
+  /**
+   * Determine if two AccountAddresses are equal based on their underlying byte data.
+   *
+   * @param other - The AccountAddress to compare to.
+   * @returns true if the AccountAddresses are equal, false if not.
+   * @group Implementation
+   * @category Serialization
+   */
+  equals(other) {
+    if (this.data.length !== other.data.length) return false;
+    return this.data.every((value, index) => value === other.data[index]);
+  }
+};
+/**
+ * The number of bytes that make up an account address.
+ * @group Implementation
+ * @category Serialization
+ */
+_AccountAddress.LENGTH = 32;
+/**
+ * The length of an address string in LONG form without a leading 0x.
+ * @group Implementation
+ * @category Serialization
+ */
+_AccountAddress.LONG_STRING_LENGTH = 64;
+_AccountAddress.ZERO = _AccountAddress.from("0x0");
+_AccountAddress.ONE = _AccountAddress.from("0x1");
+_AccountAddress.TWO = _AccountAddress.from("0x2");
+_AccountAddress.THREE = _AccountAddress.from("0x3");
+_AccountAddress.FOUR = _AccountAddress.from("0x4");
+_AccountAddress.A = _AccountAddress.from("0xA");
+var AccountAddress = _AccountAddress;
+
+// src/utils/helpers.ts
+var _jsbase64 = require('js-base64');
+async function sleep(timeMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeMs);
+  });
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var nowInSeconds = () => Math.floor(Date.now() / 1e3);
+function floorToWholeHour(timestampInSeconds) {
+  const date = new Date(timestampInSeconds * 1e3);
+  date.setMinutes(0);
+  date.setSeconds(0);
+  date.setMilliseconds(0);
+  return Math.floor(date.getTime() / 1e3);
+}
+function base64UrlDecode(base64Url) {
+  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+  const paddedBase64 = base64 + "==".substring(0, (3 - base64.length % 3) % 3);
+  const decodedString = _jsbase64.decode.call(void 0, paddedBase64);
+  return decodedString;
+}
+var convertAmountFromHumanReadableToOnChain = (value, decimal) => value * 10 ** decimal;
+var convertAmountFromOnChainToHumanReadable = (value, decimal) => value / 10 ** decimal;
+var hexToAscii = (hex) => {
+  let str = "";
+  for (let n = 2; n < hex.length; n += 2) {
+    str += String.fromCharCode(parseInt(hex.substring(n, n + 2), 16));
+  }
+  return str;
+};
+var parseEncodedStruct = (structObj) => {
+  const { account_address, module_name, struct_name } = structObj;
+  const moduleName = hexToAscii(module_name);
+  const structName = hexToAscii(struct_name);
+  return `${account_address}::${moduleName}::${structName}`;
+};
+var isEncodedStruct = (structObj) => typeof structObj === "object" && !Array.isArray(structObj) && structObj !== null && "account_address" in structObj && "module_name" in structObj && "struct_name" in structObj && typeof structObj.account_address === "string" && typeof structObj.module_name === "string" && typeof structObj.struct_name === "string";
+function getFunctionParts(functionArg) {
+  const funcNameParts = functionArg.split("::");
+  if (funcNameParts.length !== 3) {
+    throw new Error(`Invalid function ${functionArg}`);
+  }
+  const moduleAddress = funcNameParts[0];
+  const moduleName = funcNameParts[1];
+  const functionName = funcNameParts[2];
+  return { moduleAddress, moduleName, functionName };
+}
+function isValidFunctionInfo(functionInfo) {
+  const parts = functionInfo.split("::");
+  return parts.length === 3 && AccountAddress.isValid({ input: parts[0] }).valid;
+}
+function truncateAddress(address, start = 6, end = 5) {
+  return `${address.slice(0, start)}...${address.slice(-end)}`;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.__decorateClass = __decorateClass; exports.MAX_U8_NUMBER = MAX_U8_NUMBER; exports.MAX_U16_NUMBER = MAX_U16_NUMBER; exports.MAX_U32_NUMBER = MAX_U32_NUMBER; exports.MAX_U64_BIG_INT = MAX_U64_BIG_INT; exports.MAX_U128_BIG_INT = MAX_U128_BIG_INT; exports.MAX_U256_BIG_INT = MAX_U256_BIG_INT; exports.ParsingError = ParsingError; exports.HexInvalidReason = HexInvalidReason; exports.Hex = Hex; exports.hexToAsciiString = hexToAsciiString; exports.Serializable = Serializable; exports.Serializer = Serializer; exports.ensureBoolean = ensureBoolean; exports.outOfRangeErrorMessage = outOfRangeErrorMessage; exports.validateNumberInRange = validateNumberInRange; exports.MimeType = MimeType; exports.TypeTagVariants = TypeTagVariants; exports.ScriptTransactionArgumentVariants = ScriptTransactionArgumentVariants; exports.TransactionPayloadVariants = TransactionPayloadVariants; exports.TransactionVariants = TransactionVariants; exports.TransactionAuthenticatorVariant = TransactionAuthenticatorVariant; exports.AccountAuthenticatorVariant = AccountAuthenticatorVariant; exports.PrivateKeyVariants = PrivateKeyVariants; exports.AnyPublicKeyVariant = AnyPublicKeyVariant; exports.AnySignatureVariant = AnySignatureVariant; exports.EphemeralPublicKeyVariant = EphemeralPublicKeyVariant; exports.EphemeralSignatureVariant = EphemeralSignatureVariant; exports.EphemeralCertificateVariant = EphemeralCertificateVariant; exports.ZkpVariant = ZkpVariant; exports.TransactionResponseType = TransactionResponseType; exports.isPendingTransactionResponse = isPendingTransactionResponse; exports.isUserTransactionResponse = isUserTransactionResponse; exports.isGenesisTransactionResponse = isGenesisTransactionResponse; exports.isBlockMetadataTransactionResponse = isBlockMetadataTransactionResponse; exports.isStateCheckpointTransactionResponse = isStateCheckpointTransactionResponse; exports.isValidatorTransactionResponse = isValidatorTransactionResponse; exports.isBlockEpilogueTransactionResponse = isBlockEpilogueTransactionResponse; exports.isEd25519Signature = isEd25519Signature; exports.isSecp256k1Signature = isSecp256k1Signature; exports.isMultiAgentSignature = isMultiAgentSignature; exports.isFeePayerSignature = isFeePayerSignature; exports.isMultiEd25519Signature = isMultiEd25519Signature; exports.isSingleSenderSignature = isSingleSenderSignature; exports.MoveFunctionVisibility = MoveFunctionVisibility; exports.MoveAbility = MoveAbility; exports.RoleType = RoleType; exports.SigningScheme = SigningScheme; exports.SigningSchemeInput = SigningSchemeInput; exports.DeriveScheme = DeriveScheme; exports.CallArgument = _scriptcomposerpack.CallArgument; exports.AddressInvalidReason = AddressInvalidReason; exports.AccountAddress = AccountAddress; exports.sleep = sleep; exports.getErrorMessage = getErrorMessage; exports.nowInSeconds = nowInSeconds; exports.floorToWholeHour = floorToWholeHour; exports.base64UrlDecode = base64UrlDecode; exports.convertAmountFromHumanReadableToOnChain = convertAmountFromHumanReadableToOnChain; exports.convertAmountFromOnChainToHumanReadable = convertAmountFromOnChainToHumanReadable; exports.parseEncodedStruct = parseEncodedStruct; exports.isEncodedStruct = isEncodedStruct; exports.getFunctionParts = getFunctionParts; exports.isValidFunctionInfo = isValidFunctionInfo; exports.truncateAddress = truncateAddress;
+//# sourceMappingURL=chunk-CSUBLTFA.js.map