@aptos-labs/ts-sdk 1.27.1-zeta.0 → 1.28.0-zeta.0

package/dist/esm/chunk-PLUMRBKI.mjs

@@ -1,241 +0,0 @@
-import {
-  StructTag,
-  TypeTagAddress,
-  TypeTagBool,
-  TypeTagGeneric,
-  TypeTagReference,
-  TypeTagSigner,
-  TypeTagStruct,
-  TypeTagU128,
-  TypeTagU16,
-  TypeTagU256,
-  TypeTagU32,
-  TypeTagU64,
-  TypeTagU8,
-  TypeTagVector
-} from "./chunk-P3RTJ6VC.mjs";
-import {
-  Identifier
-} from "./chunk-YQPKNTIN.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.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 {
-  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-PLUMRBKI.mjs.map

package/dist/esm/chunk-PNGNBHMD.mjs

@@ -1,44 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  MoveString,
-  MoveVector
-} from "./chunk-PSW5OBY2.mjs";
-import {
-  U64
-} from "./chunk-GWS7OLIU.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/instances/rotationProofChallenge.ts
-var RotationProofChallenge = class extends Serializable {
-  constructor(args) {
-    super();
-    // Resource account address
-    this.accountAddress = AccountAddress.ONE;
-    // Module name, i.e: 0x1::account
-    this.moduleName = new MoveString("account");
-    // The rotation proof challenge struct name that live under the module
-    this.structName = new MoveString("RotationProofChallenge");
-    this.sequenceNumber = new U64(args.sequenceNumber);
-    this.originator = args.originator;
-    this.currentAuthKey = args.currentAuthKey;
-    this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());
-  }
-  serialize(serializer) {
-    serializer.serialize(this.accountAddress);
-    serializer.serialize(this.moduleName);
-    serializer.serialize(this.structName);
-    serializer.serialize(this.sequenceNumber);
-    serializer.serialize(this.originator);
-    serializer.serialize(this.currentAuthKey);
-    serializer.serialize(this.newPublicKey);
-  }
-};
-
-export {
-  RotationProofChallenge
-};
-//# sourceMappingURL=chunk-PNGNBHMD.mjs.map

package/dist/esm/chunk-PSRD6U34.mjs

@@ -1,19 +0,0 @@
-import {
-  waitForIndexer
-} from "./chunk-UZLU45X7.mjs";
-
-// src/api/utils.ts
-async function waitForIndexerOnVersion(args) {
-  if (args.minimumLedgerVersion !== void 0) {
-    await waitForIndexer({
-      aptosConfig: args.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: args.processorType
-    });
-  }
-}
-
-export {
-  waitForIndexerOnVersion
-};
-//# sourceMappingURL=chunk-PSRD6U34.mjs.map

package/dist/esm/chunk-PSW5OBY2.mjs

@@ -1,359 +0,0 @@
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-GWS7OLIU.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/bcs/serializable/moveStructs.ts
-var MoveVector = class _MoveVector extends Serializable {
-  constructor(values) {
-    super();
-    this.values = values;
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  /**
-   * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
-   * @param serializer
-   */
-  serializeForScriptFunction(serializer) {
-    const isU8 = this.values[0] instanceof U8;
-    if (!isU8 && this.values[0] !== void 0) {
-      throw new Error("Script function arguments only accept u8 vectors");
-    }
-    serializer.serializeU32AsUleb128(4 /* U8Vector */);
-    serializer.serialize(this);
-  }
-  /**
-   * Factory method to generate a MoveVector of U8s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U8([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U8s
-   * @returns a `MoveVector<U8>`
-   */
-  static U8(values) {
-    let numbers;
-    if (Array.isArray(values) && values.length === 0) {
-      numbers = [];
-    } else if (Array.isArray(values) && typeof values[0] === "number") {
-      numbers = values;
-    } else if (typeof values === "string") {
-      const hex = Hex.fromHexInput(values);
-      numbers = Array.from(hex.toUint8Array());
-    } else if (values instanceof Uint8Array) {
-      numbers = Array.from(values);
-    } else {
-      throw new Error("Invalid input type, must be an number[], Uint8Array, or hex string");
-    }
-    return new _MoveVector(numbers.map((v) => new U8(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U16s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U16([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U16s
-   * @returns a `MoveVector<U16>`
-   */
-  static U16(values) {
-    return new _MoveVector(values.map((v) => new U16(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U32s from an array of numbers.
-   *
-   * @example
-   * const v = MoveVector.U32([1, 2, 3, 4]);
-   * @params values: an array of `numbers` to convert to U32s
-   * @returns a `MoveVector<U32>`
-   */
-  static U32(values) {
-    return new _MoveVector(values.map((v) => new U32(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U64s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U64([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U64s
-   * @returns a `MoveVector<U64>`
-   */
-  static U64(values) {
-    return new _MoveVector(values.map((v) => new U64(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U128s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U128([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U128s
-   * @returns a `MoveVector<U128>`
-   */
-  static U128(values) {
-    return new _MoveVector(values.map((v) => new U128(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of U256s from an array of numbers or bigints.
-   *
-   * @example
-   * const v = MoveVector.U256([1, 2, 3, 4]);
-   * @params values: an array of numbers of type `number | bigint` to convert to U256s
-   * @returns a `MoveVector<U256>`
-   */
-  static U256(values) {
-    return new _MoveVector(values.map((v) => new U256(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of Bools from an array of booleans.
-   *
-   * @example
-   * const v = MoveVector.Bool([true, false, true, false]);
-   * @params values: an array of `bools` to convert to Bools
-   * @returns a `MoveVector<Bool>`
-   */
-  static Bool(values) {
-    return new _MoveVector(values.map((v) => new Bool(v)));
-  }
-  /**
-   * Factory method to generate a MoveVector of MoveStrings from an array of strings.
-   *
-   * @example
-   * const v = MoveVector.MoveString(["hello", "world"]);
-   * @params values: an array of `strings` to convert to MoveStrings
-   * @returns a `MoveVector<MoveString>`
-   */
-  static MoveString(values) {
-    return new _MoveVector(values.map((v) => new MoveString(v)));
-  }
-  serialize(serializer) {
-    serializer.serializeVector(this.values);
-  }
-  /**
-   * Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.
-   *
-   * NOTE: This only works with a depth of one. Generics will not work.
-   *
-   * NOTE: This will not work with types that aren't of the Serializable class.
-   *
-   * If you're looking for a more flexible deserialization function, you can use the deserializeVector function
-   * in the Deserializer class.
-   *
-   * @example
-   * const vec = MoveVector.deserialize(deserializer, U64);
-   * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.
-   * cls: the class to typecast the input values to, must be a Serializable and Deserializable type.
-   * @returns a MoveVector of the corresponding class T
-   * *
-   */
-  static deserialize(deserializer, cls) {
-    const length = deserializer.deserializeUleb128AsU32();
-    const values = new Array();
-    for (let i = 0; i < length; i += 1) {
-      values.push(cls.deserialize(deserializer));
-    }
-    return new _MoveVector(values);
-  }
-};
-var MoveString = class _MoveString extends Serializable {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  serialize(serializer) {
-    serializer.serializeStr(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  serializeForScriptFunction(serializer) {
-    const textEncoder = new TextEncoder();
-    const fixedStringBytes = textEncoder.encode(this.value);
-    const vectorU8 = MoveVector.U8(fixedStringBytes);
-    vectorU8.serializeForScriptFunction(serializer);
-  }
-  static deserialize(deserializer) {
-    return new _MoveString(deserializer.deserializeStr());
-  }
-};
-var MoveOption = class _MoveOption extends Serializable {
-  constructor(value) {
-    super();
-    if (typeof value !== "undefined" && value !== null) {
-      this.vec = new MoveVector([value]);
-    } else {
-      this.vec = new MoveVector([]);
-    }
-    [this.value] = this.vec.values;
-  }
-  serializeForEntryFunction(serializer) {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
-  }
-  /**
-   * Retrieves the inner value of the MoveOption.
-   *
-   * This method is inspired by Rust's `Option<T>.unwrap()`.
-   * In Rust, attempting to unwrap a `None` value results in a panic.
-   *
-   * Similarly, this method will throw an error if the value is not present.
-   *
-   * @example
-   * const option = new MoveOption<Bool>(new Bool(true));
-   * const value = option.unwrap();  // Returns the Bool instance
-   *
-   * @throws {Error} Throws an error if the MoveOption does not contain a value.
-   *
-   * @returns {T} The contained value if present.
-   */
-  unwrap() {
-    if (!this.isSome()) {
-      throw new Error("Called unwrap on a MoveOption with no value");
-    } else {
-      return this.vec.values[0];
-    }
-  }
-  // Check if the MoveOption has a value.
-  isSome() {
-    return this.vec.values.length === 1;
-  }
-  serialize(serializer) {
-    this.vec.serialize(serializer);
-  }
-  /**
-   * Factory method to generate a MoveOption<U8> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U8(1).isSome() === true;
-   * MoveOption.U8().isSome() === false;
-   * MoveOption.U8(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U8> with an inner value `value`
-   */
-  static U8(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U8(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U16> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U16(1).isSome() === true;
-   * MoveOption.U16().isSome() === false;
-   * MoveOption.U16(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U16> with an inner value `value`
-   */
-  static U16(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U16(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U32> from a `number` or `undefined`.
-   *
-   * @example
-   * MoveOption.U32(1).isSome() === true;
-   * MoveOption.U32().isSome() === false;
-   * MoveOption.U32(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U32> with an inner value `value`
-   */
-  static U32(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U32(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U64> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U64(1).isSome() === true;
-   * MoveOption.U64().isSome() === false;
-   * MoveOption.U64(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U64> with an inner value `value`
-   */
-  static U64(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U64(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U128> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U128(1).isSome() === true;
-   * MoveOption.U128().isSome() === false;
-   * MoveOption.U128(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U128> with an inner value `value`
-   */
-  static U128(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U128(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<U256> from a `number` or a `bigint` or `undefined`.
-   *
-   * @example
-   * MoveOption.U256(1).isSome() === true;
-   * MoveOption.U256().isSome() === false;
-   * MoveOption.U256(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<U256> with an inner value `value`
-   */
-  static U256(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new U256(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<Bool> from a `boolean` or `undefined`.
-   *
-   * @example
-   * MoveOption.Bool(true).isSome() === true;
-   * MoveOption.Bool().isSome() === false;
-   * MoveOption.Bool(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<Bool> with an inner value `value`
-   */
-  static Bool(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new Bool(value) : void 0);
-  }
-  /**
-   * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
-   *
-   * @example
-   * MoveOption.MoveString("hello").isSome() === true;
-   * MoveOption.MoveString("").isSome() === true;
-   * MoveOption.MoveString().isSome() === false;
-   * MoveOption.MoveString(undefined).isSome() === false;
-   * @params value: the value used to fill the MoveOption. If `value` is undefined
-   * the resulting MoveOption's .isSome() method will return false.
-   * @returns a MoveOption<MoveString> with an inner value `value`
-   */
-  static MoveString(value) {
-    return new _MoveOption(value !== null && value !== void 0 ? new MoveString(value) : void 0);
-  }
-  static deserialize(deserializer, cls) {
-    const vector = MoveVector.deserialize(deserializer, cls);
-    return new _MoveOption(vector.values[0]);
-  }
-};
-
-export {
-  MoveVector,
-  MoveString,
-  MoveOption
-};
-//# sourceMappingURL=chunk-PSW5OBY2.mjs.map