@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-BDM6FBUO.mjs

@@ -1,198 +0,0 @@
-import {
-  ParsingError
-} from "./chunk-QPT4BSAB.mjs";
-
-// src/core/hex.ts
-import { bytesToHex, hexToBytes } from "@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 bytesToHex(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(hexToBytes(input));
-    } catch (error) {
-      throw new ParsingError(
-        `Hex string contains invalid hex characters: ${error?.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: error?.invalidReason,
-        invalidReasonMessage: error?.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());
-
-export {
-  HexInvalidReason,
-  Hex,
-  hexToAsciiString
-};
-//# sourceMappingURL=chunk-BDM6FBUO.mjs.map

package/dist/esm/chunk-BEYIOC2H.mjs

@@ -1,34 +0,0 @@
-// src/utils/memoize.ts
-var cache = /* @__PURE__ */ new Map();
-function memoizeAsync(func, key, ttlMs) {
-  return async (...args) => {
-    if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key);
-      if (ttlMs === void 0 || Date.now() - timestamp <= ttlMs) {
-        return value;
-      }
-    }
-    const result = await func(...args);
-    cache.set(key, { value: result, timestamp: Date.now() });
-    return result;
-  };
-}
-function memoize(func, key, ttlMs) {
-  return (...args) => {
-    if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key);
-      if (ttlMs === void 0 || Date.now() - timestamp <= ttlMs) {
-        return value;
-      }
-    }
-    const result = func(...args);
-    cache.set(key, { value: result, timestamp: Date.now() });
-    return result;
-  };
-}
-
-export {
-  memoizeAsync,
-  memoize
-};
-//# sourceMappingURL=chunk-BEYIOC2H.mjs.map

package/dist/esm/chunk-BMM72IIP.mjs

@@ -1,250 +0,0 @@
-import {
-  StructTag,
-  TypeTagAddress,
-  TypeTagBool,
-  TypeTagGeneric,
-  TypeTagReference,
-  TypeTagSigner,
-  TypeTagStruct,
-  TypeTagU128,
-  TypeTagU16,
-  TypeTagU256,
-  TypeTagU32,
-  TypeTagU64,
-  TypeTagU8,
-  TypeTagVector
-} from "./chunk-DDZGHA66.mjs";
-import {
-  Identifier
-} from "./chunk-MFFBZ43D.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-
-// src/transactions/typeTag/parser.ts
-function isValidIdentifier(str) {
-  return !!str.match(/^[_a-zA-Z0-9]+$/);
-}
-function isValidWhitespaceCharacter(char) {
-  return !!char.match(/\s/);
-}
-function isGeneric(str) {
-  return !!str.match(/^T[0-9]+$/);
-}
-function isRef(str) {
-  return !!str.match(/^&.+$/);
-}
-function isPrimitive(str) {
-  switch (str) {
-    case "signer":
-    case "address":
-    case "bool":
-    case "u8":
-    case "u16":
-    case "u32":
-    case "u64":
-    case "u128":
-    case "u256":
-      return true;
-    default:
-      return false;
-  }
-}
-function consumeWhitespace(tagStr, pos) {
-  let i = pos;
-  for (; i < tagStr.length; i += 1) {
-    const innerChar = tagStr[i];
-    if (!isValidWhitespaceCharacter(innerChar)) {
-      break;
-    }
-  }
-  return i;
-}
-var TypeTagParserErrorType = /* @__PURE__ */ ((TypeTagParserErrorType2) => {
-  TypeTagParserErrorType2["InvalidTypeTag"] = "unknown type";
-  TypeTagParserErrorType2["UnexpectedGenericType"] = "unexpected generic type";
-  TypeTagParserErrorType2["UnexpectedTypeArgumentClose"] = "unexpected '>'";
-  TypeTagParserErrorType2["UnexpectedWhitespaceCharacter"] = "unexpected whitespace character";
-  TypeTagParserErrorType2["UnexpectedComma"] = "unexpected ','";
-  TypeTagParserErrorType2["TypeArgumentCountMismatch"] = "type argument count doesn't match expected amount";
-  TypeTagParserErrorType2["MissingTypeArgumentClose"] = "no matching '>' for '<'";
-  TypeTagParserErrorType2["MissingTypeArgument"] = "no type argument before ','";
-  TypeTagParserErrorType2["UnexpectedPrimitiveTypeArguments"] = "primitive types not expected to have type arguments";
-  TypeTagParserErrorType2["UnexpectedVectorTypeArgumentCount"] = "vector type expected to have exactly one type argument";
-  TypeTagParserErrorType2["UnexpectedStructFormat"] = "unexpected struct format, must be of the form 0xaddress::module_name::struct_name";
-  TypeTagParserErrorType2["InvalidModuleNameCharacter"] = "module name must only contain alphanumeric or '_' characters";
-  TypeTagParserErrorType2["InvalidStructNameCharacter"] = "struct name must only contain alphanumeric or '_' characters";
-  TypeTagParserErrorType2["InvalidAddress"] = "struct address must be valid";
-  return TypeTagParserErrorType2;
-})(TypeTagParserErrorType || {});
-var TypeTagParserError = class extends Error {
-  /**
-   * Constructs an error indicating a failure to parse a type tag.
-   * This error provides details about the specific type tag that could not be parsed and the reason for the failure.
-   *
-   * @param typeTagStr - The string representation of the type tag that failed to parse.
-   * @param invalidReason - The reason why the type tag is considered invalid.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(typeTagStr, invalidReason) {
-    super(`Failed to parse typeTag '${typeTagStr}', ${invalidReason}`);
-  }
-};
-function parseTypeTag(typeStr, options) {
-  const allowGenerics = options?.allowGenerics ?? false;
-  const saved = [];
-  let innerTypes = [];
-  let curTypes = [];
-  let cur = 0;
-  let currentStr = "";
-  let expectedTypes = 1;
-  while (cur < typeStr.length) {
-    const char = typeStr[cur];
-    if (char === "<") {
-      saved.push({
-        savedExpectedTypes: expectedTypes,
-        savedStr: currentStr,
-        savedTypes: curTypes
-      });
-      currentStr = "";
-      curTypes = [];
-      expectedTypes = 1;
-    } else if (char === ">") {
-      if (currentStr !== "") {
-        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
-        curTypes.push(newType);
-      }
-      const savedPop = saved.pop();
-      if (savedPop === void 0) {
-        throw new TypeTagParserError(typeStr, "unexpected '>'" /* UnexpectedTypeArgumentClose */);
-      }
-      if (expectedTypes !== curTypes.length) {
-        throw new TypeTagParserError(typeStr, "type argument count doesn't match expected amount" /* TypeArgumentCountMismatch */);
-      }
-      const { savedStr, savedTypes, savedExpectedTypes } = savedPop;
-      innerTypes = curTypes;
-      curTypes = savedTypes;
-      currentStr = savedStr;
-      expectedTypes = savedExpectedTypes;
-    } else if (char === ",") {
-      if (saved.length === 0) {
-        throw new TypeTagParserError(typeStr, "unexpected ','" /* UnexpectedComma */);
-      }
-      if (currentStr.length === 0) {
-        throw new TypeTagParserError(typeStr, "no type argument before ','" /* MissingTypeArgument */);
-      }
-      const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
-      innerTypes = [];
-      curTypes.push(newType);
-      currentStr = "";
-      expectedTypes += 1;
-    } else if (isValidWhitespaceCharacter(char)) {
-      let parsedTypeTag = false;
-      if (currentStr.length !== 0) {
-        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);
-        innerTypes = [];
-        curTypes.push(newType);
-        currentStr = "";
-        parsedTypeTag = true;
-      }
-      cur = consumeWhitespace(typeStr, cur);
-      const nextChar = typeStr[cur];
-      if (cur < typeStr.length && parsedTypeTag && nextChar !== "," && nextChar !== ">") {
-        throw new TypeTagParserError(typeStr, "unexpected whitespace character" /* UnexpectedWhitespaceCharacter */);
-      }
-      continue;
-    } else {
-      currentStr += char;
-    }
-    cur += 1;
-  }
-  if (saved.length > 0) {
-    throw new TypeTagParserError(typeStr, "no matching '>' for '<'" /* MissingTypeArgumentClose */);
-  }
-  switch (curTypes.length) {
-    case 0:
-      return parseTypeTagInner(currentStr, innerTypes, allowGenerics);
-    case 1:
-      if (currentStr === "") {
-        return curTypes[0];
-      }
-      throw new TypeTagParserError(typeStr, "unexpected ','" /* UnexpectedComma */);
-    default:
-      throw new TypeTagParserError(typeStr, "unexpected whitespace character" /* UnexpectedWhitespaceCharacter */);
-  }
-}
-function parseTypeTagInner(str, types, allowGenerics) {
-  const trimmedStr = str.trim();
-  const lowerCaseTrimmed = trimmedStr.toLowerCase();
-  if (isPrimitive(lowerCaseTrimmed)) {
-    if (types.length > 0) {
-      throw new TypeTagParserError(str, "primitive types not expected to have type arguments" /* UnexpectedPrimitiveTypeArguments */);
-    }
-  }
-  switch (trimmedStr.toLowerCase()) {
-    case "signer":
-      return new TypeTagSigner();
-    case "bool":
-      return new TypeTagBool();
-    case "address":
-      return new TypeTagAddress();
-    case "u8":
-      return new TypeTagU8();
-    case "u16":
-      return new TypeTagU16();
-    case "u32":
-      return new TypeTagU32();
-    case "u64":
-      return new TypeTagU64();
-    case "u128":
-      return new TypeTagU128();
-    case "u256":
-      return new TypeTagU256();
-    case "vector":
-      if (types.length !== 1) {
-        throw new TypeTagParserError(str, "vector type expected to have exactly one type argument" /* UnexpectedVectorTypeArgumentCount */);
-      }
-      return new TypeTagVector(types[0]);
-    default:
-      if (isRef(trimmedStr)) {
-        const actualType = trimmedStr.substring(1);
-        return new TypeTagReference(parseTypeTagInner(actualType, types, allowGenerics));
-      }
-      if (isGeneric(trimmedStr)) {
-        if (allowGenerics) {
-          return new TypeTagGeneric(Number(trimmedStr.split("T")[1]));
-        }
-        throw new TypeTagParserError(str, "unexpected generic type" /* UnexpectedGenericType */);
-      }
-      if (!trimmedStr.match(/:/)) {
-        throw new TypeTagParserError(str, "unknown type" /* InvalidTypeTag */);
-      }
-      const structParts = trimmedStr.split("::");
-      if (structParts.length !== 3) {
-        throw new TypeTagParserError(str, "unexpected struct format, must be of the form 0xaddress::module_name::struct_name" /* UnexpectedStructFormat */);
-      }
-      let address;
-      try {
-        address = AccountAddress.fromString(structParts[0]);
-      } catch (error) {
-        throw new TypeTagParserError(str, "struct address must be valid" /* InvalidAddress */);
-      }
-      if (!isValidIdentifier(structParts[1])) {
-        throw new TypeTagParserError(str, "module name must only contain alphanumeric or '_' characters" /* InvalidModuleNameCharacter */);
-      }
-      if (!isValidIdentifier(structParts[2])) {
-        throw new TypeTagParserError(str, "struct name must only contain alphanumeric or '_' characters" /* InvalidStructNameCharacter */);
-      }
-      return new TypeTagStruct(
-        new StructTag(address, new Identifier(structParts[1]), new Identifier(structParts[2]), types)
-      );
-  }
-}
-
-export {
-  TypeTagParserErrorType,
-  TypeTagParserError,
-  parseTypeTag
-};
-//# sourceMappingURL=chunk-BMM72IIP.mjs.map