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

package/dist/esm/chunk-AKXCFBYF.mjs

@@ -1,49 +0,0 @@
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/abstraction.ts
-var AbstractSignature = class _AbstractSignature extends Signature {
-  constructor(value) {
-    super();
-    this.value = Hex.fromHexInput(value);
-  }
-  serialize(serializer) {
-    serializer.serializeBytes(this.value.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    return new _AbstractSignature(deserializer.deserializeBytes());
-  }
-};
-var AbstractPublicKey = class extends AccountPublicKey {
-  constructor(accountAddress) {
-    super();
-    this.accountAddress = accountAddress;
-  }
-  authKey() {
-    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
-  }
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args) {
-    throw new Error("This function is not implemented for AbstractPublicKey.");
-  }
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  serialize(serializer) {
-    throw new Error("This function is not implemented for AbstractPublicKey.");
-  }
-};
-
-export {
-  AbstractSignature,
-  AbstractPublicKey
-};
-//# sourceMappingURL=chunk-AKXCFBYF.mjs.map

package/dist/esm/chunk-AKXCFBYF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/abstraction.ts"],"sourcesContent":["import { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput } from \"../../types\";\nimport { AccountAddress } from \"../accountAddress\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { Hex } from \"../hex\";\nimport { AccountPublicKey, VerifySignatureArgs } from \"./publicKey\";\nimport { Signature } from \"./signature\";\n\nexport class AbstractSignature extends Signature {\n  readonly value: Hex;\n\n  constructor(value: HexInput) {\n    super();\n    this.value = Hex.fromHexInput(value);\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.value.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): AbstractSignature {\n    return new AbstractSignature(deserializer.deserializeBytes());\n  }\n}\n\nexport class AbstractPublicKey extends AccountPublicKey {\n  readonly accountAddress: AccountAddress;\n\n  constructor(accountAddress: AccountAddress) {\n    super();\n    this.accountAddress = accountAddress;\n  }\n\n  authKey(): AuthenticationKey {\n    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  verifySignature(args: VerifySignatureArgs): boolean {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n\n  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars\n  serialize(serializer: Serializer): void {\n    throw new Error(\"This function is not implemented for AbstractPublicKey.\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAQO,IAAM,oBAAN,MAAM,2BAA0B,UAAU;AAAA,EAG/C,YAAY,OAAiB;AAC3B,UAAM;AACN,SAAK,QAAQ,IAAI,aAAa,KAAK;AAAA,EACrC;AAAA,EAEA,UAAU,YAA8B;AACtC,eAAW,eAAe,KAAK,MAAM,aAAa,CAAC;AAAA,EACrD;AAAA,EAEA,OAAO,YAAY,cAA+C;AAChE,WAAO,IAAI,mBAAkB,aAAa,iBAAiB,CAAC;AAAA,EAC9D;AACF;AAEO,IAAM,oBAAN,cAAgC,iBAAiB;AAAA,EAGtD,YAAY,gBAAgC;AAC1C,UAAM;AACN,SAAK,iBAAiB;AAAA,EACxB;AAAA,EAEA,UAA6B;AAC3B,WAAO,IAAI,kBAAkB,EAAE,MAAM,KAAK,eAAe,aAAa,EAAE,CAAC;AAAA,EAC3E;AAAA;AAAA,EAGA,gBAAgB,MAAoC;AAClD,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAAA;AAAA,EAGA,UAAU,YAA8B;AACtC,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACF;","names":[]}

package/dist/esm/chunk-APM7OSLS.mjs

@@ -1,122 +0,0 @@
-// src/core/crypto/poseidon.ts
-import {
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-} from "poseidon-lite";
-var numInputsToPoseidonFunc = [
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-];
-var BYTES_PACKED_PER_SCALAR = 31;
-var MAX_NUM_INPUT_SCALARS = 16;
-var MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
-function hashStrToField(str, maxSizeBytes) {
-  const textEncoder = new TextEncoder();
-  const strBytes = textEncoder.encode(str);
-  return hashBytesWithLen(strBytes, maxSizeBytes);
-}
-function hashBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
-  return poseidonHash(packed);
-}
-function padAndPackBytesNoLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
-  return packBytes(paddedStrBytes);
-}
-function padAndPackBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
-}
-function packBytes(bytes) {
-  if (bytes.length > MAX_NUM_INPUT_BYTES) {
-    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
-  }
-  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
-}
-function chunkUint8Array(array, chunkSize) {
-  const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.subarray(i, i + chunkSize));
-  }
-  return result;
-}
-function bytesToBigIntLE(bytes) {
-  let result = BigInt(0);
-  for (let i = bytes.length - 1; i >= 0; i -= 1) {
-    result = result << BigInt(8) | BigInt(bytes[i]);
-  }
-  return result;
-}
-function bigIntToBytesLE(value, length) {
-  let val = BigInt(value);
-  const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i += 1) {
-    bytes[i] = Number(val & BigInt(255));
-    val >>= BigInt(8);
-  }
-  return bytes;
-}
-function padUint8ArrayWithZeros(inputArray, paddedSize) {
-  if (paddedSize < inputArray.length) {
-    throw new Error("Padded size must be greater than or equal to the input array size.");
-  }
-  const paddedArray = new Uint8Array(paddedSize);
-  paddedArray.set(inputArray);
-  for (let i = inputArray.length; i < paddedSize; i += 1) {
-    paddedArray[i] = 0;
-  }
-  return paddedArray;
-}
-function poseidonHash(inputs) {
-  if (inputs.length > numInputsToPoseidonFunc.length) {
-    throw new Error(
-      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`
-    );
-  }
-  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
-}
-
-export {
-  hashStrToField,
-  padAndPackBytesWithLen,
-  bytesToBigIntLE,
-  bigIntToBytesLE,
-  poseidonHash
-};
-//# sourceMappingURL=chunk-APM7OSLS.mjs.map

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