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

package/dist/esm/chunk-OL2YPOXZ.mjs

@@ -1,349 +0,0 @@
-import {
-  parseTypeTag
-} from "./chunk-PLUMRBKI.mjs";
-import {
-  convertNumber,
-  findFirstNonSignerArg,
-  isBcsAddress,
-  isBcsBool,
-  isBcsString,
-  isBcsU128,
-  isBcsU16,
-  isBcsU256,
-  isBcsU32,
-  isBcsU64,
-  isBcsU8,
-  isBool,
-  isEmptyOption,
-  isEncodedEntryFunctionArgument,
-  isLargeNumber,
-  isString,
-  throwTypeMismatch
-} from "./chunk-DXGNWBVW.mjs";
-import {
-  getModule
-} from "./chunk-JRVQNM7A.mjs";
-import {
-  TypeTagAddress,
-  TypeTagBool,
-  TypeTagStruct,
-  TypeTagU128,
-  TypeTagU16,
-  TypeTagU256,
-  TypeTagU32,
-  TypeTagU64,
-  TypeTagU8
-} from "./chunk-P3RTJ6VC.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  MoveOption,
-  MoveString,
-  MoveVector
-} from "./chunk-PSW5OBY2.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-GWS7OLIU.mjs";
-
-// src/transactions/transactionBuilder/remoteAbi.ts
-var TEXT_ENCODER = new TextEncoder();
-function standardizeTypeTags(typeArguments) {
-  return typeArguments?.map((typeArg) => {
-    if (isString(typeArg)) {
-      return parseTypeTag(typeArg);
-    }
-    return typeArg;
-  }) ?? [];
-}
-async function fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig) {
-  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
-  if (module.abi) {
-    return module.abi.exposed_functions.find((func) => func.name === functionName);
-  }
-  return void 0;
-}
-async function fetchEntryFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig) {
-  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
-  if (!functionAbi) {
-    throw new Error(`Could not find entry function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
-  }
-  if (!functionAbi.is_entry) {
-    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an entry function`);
-  }
-  const numSigners = findFirstNonSignerArg(functionAbi);
-  const params = [];
-  for (let i = numSigners; i < functionAbi.params.length; i += 1) {
-    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
-  }
-  return {
-    signers: numSigners,
-    typeParameters: functionAbi.generic_type_params,
-    parameters: params
-  };
-}
-async function fetchViewFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig) {
-  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
-  if (!functionAbi) {
-    throw new Error(`Could not find view function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
-  }
-  if (!functionAbi.is_view) {
-    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an view function`);
-  }
-  const params = [];
-  for (let i = 0; i < functionAbi.params.length; i += 1) {
-    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
-  }
-  const returnTypes = [];
-  for (let i = 0; i < functionAbi.return.length; i += 1) {
-    returnTypes.push(parseTypeTag(functionAbi.return[i], { allowGenerics: true }));
-  }
-  return {
-    typeParameters: functionAbi.generic_type_params,
-    parameters: params,
-    returnTypes
-  };
-}
-function convertArgument(functionName, functionAbi, arg, position, genericTypeParams) {
-  if (position >= functionAbi.parameters.length) {
-    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);
-  }
-  const param = functionAbi.parameters[position];
-  return checkOrConvertArgument(arg, param, position, genericTypeParams);
-}
-function checkOrConvertArgument(arg, param, position, genericTypeParams) {
-  if (isEncodedEntryFunctionArgument(arg)) {
-    checkType(param, arg, position);
-    return arg;
-  }
-  return parseArg(arg, param, position, genericTypeParams);
-}
-function parseArg(arg, param, position, genericTypeParams) {
-  if (param.isBool()) {
-    if (isBool(arg)) {
-      return new Bool(arg);
-    }
-    if (isString(arg)) {
-      if (arg === "true")
-        return new Bool(true);
-      if (arg === "false")
-        return new Bool(false);
-    }
-    throwTypeMismatch("boolean", position);
-  }
-  if (param.isAddress()) {
-    if (isString(arg)) {
-      return AccountAddress.fromString(arg);
-    }
-    throwTypeMismatch("string | AccountAddress", position);
-  }
-  if (param.isU8()) {
-    const num = convertNumber(arg);
-    if (num !== void 0) {
-      return new U8(num);
-    }
-    throwTypeMismatch("number | string", position);
-  }
-  if (param.isU16()) {
-    const num = convertNumber(arg);
-    if (num !== void 0) {
-      return new U16(num);
-    }
-    throwTypeMismatch("number | string", position);
-  }
-  if (param.isU32()) {
-    const num = convertNumber(arg);
-    if (num !== void 0) {
-      return new U32(num);
-    }
-    throwTypeMismatch("number | string", position);
-  }
-  if (param.isU64()) {
-    if (isLargeNumber(arg)) {
-      return new U64(BigInt(arg));
-    }
-    throwTypeMismatch("bigint | number | string", position);
-  }
-  if (param.isU128()) {
-    if (isLargeNumber(arg)) {
-      return new U128(BigInt(arg));
-    }
-    throwTypeMismatch("bigint | number | string", position);
-  }
-  if (param.isU256()) {
-    if (isLargeNumber(arg)) {
-      return new U256(BigInt(arg));
-    }
-    throwTypeMismatch("bigint | number | string", position);
-  }
-  if (param.isGeneric()) {
-    const genericIndex = param.value;
-    if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {
-      throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);
-    }
-    return checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams);
-  }
-  if (param.isVector()) {
-    if (param.value.isU8()) {
-      if (isString(arg)) {
-        return MoveVector.U8(TEXT_ENCODER.encode(arg));
-      }
-      if (arg instanceof Uint8Array) {
-        return MoveVector.U8(arg);
-      }
-      if (arg instanceof ArrayBuffer) {
-        return MoveVector.U8(new Uint8Array(arg));
-      }
-    }
-    if (Array.isArray(arg)) {
-      return new MoveVector(arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams)));
-    }
-    throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
-  }
-  if (param.isStruct()) {
-    if (param.isString()) {
-      if (isString(arg)) {
-        return new MoveString(arg);
-      }
-      throwTypeMismatch("string", position);
-    }
-    if (param.isObject()) {
-      if (isString(arg)) {
-        return AccountAddress.fromString(arg);
-      }
-      throwTypeMismatch("string | AccountAddress", position);
-    }
-    if (param.isOption()) {
-      if (isEmptyOption(arg)) {
-        const innerParam = param.value.typeArgs[0];
-        if (innerParam instanceof TypeTagBool) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagAddress) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU8) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU16) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU32) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU64) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU128) {
-          return new MoveOption(null);
-        }
-        if (innerParam instanceof TypeTagU256) {
-          return new MoveOption(null);
-        }
-        return new MoveOption(null);
-      }
-      return new MoveOption(checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams));
-    }
-    throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);
-  }
-  throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
-}
-function checkType(param, arg, position) {
-  if (param.isBool()) {
-    if (isBcsBool(arg)) {
-      return;
-    }
-    throwTypeMismatch("Bool", position);
-  }
-  if (param.isAddress()) {
-    if (isBcsAddress(arg)) {
-      return;
-    }
-    throwTypeMismatch("AccountAddress", position);
-  }
-  if (param.isU8()) {
-    if (isBcsU8(arg)) {
-      return;
-    }
-    throwTypeMismatch("U8", position);
-  }
-  if (param.isU16()) {
-    if (isBcsU16(arg)) {
-      return;
-    }
-    throwTypeMismatch("U16", position);
-  }
-  if (param.isU32()) {
-    if (isBcsU32(arg)) {
-      return;
-    }
-    throwTypeMismatch("U32", position);
-  }
-  if (param.isU64()) {
-    if (isBcsU64(arg)) {
-      return;
-    }
-    throwTypeMismatch("U64", position);
-  }
-  if (param.isU128()) {
-    if (isBcsU128(arg)) {
-      return;
-    }
-    throwTypeMismatch("U128", position);
-  }
-  if (param.isU256()) {
-    if (isBcsU256(arg)) {
-      return;
-    }
-    throwTypeMismatch("U256", position);
-  }
-  if (param.isVector()) {
-    if (arg instanceof MoveVector) {
-      if (arg.values.length > 0) {
-        checkType(param.value, arg.values[0], position);
-      }
-      return;
-    }
-    throwTypeMismatch("MoveVector", position);
-  }
-  if (param instanceof TypeTagStruct) {
-    if (param.isString()) {
-      if (isBcsString(arg)) {
-        return;
-      }
-      throwTypeMismatch("MoveString", position);
-    }
-    if (param.isObject()) {
-      if (isBcsAddress(arg)) {
-        return;
-      }
-      throwTypeMismatch("AccountAddress", position);
-    }
-    if (param.isOption()) {
-      if (arg instanceof MoveOption) {
-        if (arg.value !== void 0) {
-          checkType(param.value.typeArgs[0], arg.value, position);
-        }
-        return;
-      }
-      throwTypeMismatch("MoveOption", position);
-    }
-  }
-  throw new Error(`Type mismatch for argument ${position}, expected '${param.toString()}'`);
-}
-
-export {
-  standardizeTypeTags,
-  fetchFunctionAbi,
-  fetchEntryFunctionAbi,
-  fetchViewFunctionAbi,
-  convertArgument,
-  checkOrConvertArgument
-};
-//# sourceMappingURL=chunk-OL2YPOXZ.mjs.map

package/dist/esm/chunk-OR7TEZ25.mjs

@@ -1,16 +0,0 @@
-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;
-};
-
-export {
-  __decorateClass
-};
-//# sourceMappingURL=chunk-OR7TEZ25.mjs.map

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

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

package/dist/esm/chunk-P3RTJ6VC.mjs

@@ -1,324 +0,0 @@
-import {
-  Identifier
-} from "./chunk-YQPKNTIN.mjs";
-import {
-  AccountAddress
-} from "./chunk-IUC6XUYA.mjs";
-import {
-  Serializable
-} from "./chunk-UZXDD3QH.mjs";
-
-// src/transactions/typeTag/index.ts
-var TypeTag = class extends Serializable {
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Bool */:
-        return TypeTagBool.load(deserializer);
-      case 1 /* U8 */:
-        return TypeTagU8.load(deserializer);
-      case 2 /* U64 */:
-        return TypeTagU64.load(deserializer);
-      case 3 /* U128 */:
-        return TypeTagU128.load(deserializer);
-      case 4 /* Address */:
-        return TypeTagAddress.load(deserializer);
-      case 5 /* Signer */:
-        return TypeTagSigner.load(deserializer);
-      case 6 /* Vector */:
-        return TypeTagVector.load(deserializer);
-      case 7 /* Struct */:
-        return TypeTagStruct.load(deserializer);
-      case 8 /* U16 */:
-        return TypeTagU16.load(deserializer);
-      case 9 /* U32 */:
-        return TypeTagU32.load(deserializer);
-      case 10 /* U256 */:
-        return TypeTagU256.load(deserializer);
-      case 255 /* Generic */:
-        return TypeTagGeneric.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for TypeTag: ${index}`);
-    }
-  }
-  isBool() {
-    return this instanceof TypeTagBool;
-  }
-  isAddress() {
-    return this instanceof TypeTagAddress;
-  }
-  isGeneric() {
-    return this instanceof TypeTagGeneric;
-  }
-  isSigner() {
-    return this instanceof TypeTagSigner;
-  }
-  isVector() {
-    return this instanceof TypeTagVector;
-  }
-  isStruct() {
-    return this instanceof TypeTagStruct;
-  }
-  isU8() {
-    return this instanceof TypeTagU8;
-  }
-  isU16() {
-    return this instanceof TypeTagU16;
-  }
-  isU32() {
-    return this instanceof TypeTagU32;
-  }
-  isU64() {
-    return this instanceof TypeTagU64;
-  }
-  isU128() {
-    return this instanceof TypeTagU128;
-  }
-  isU256() {
-    return this instanceof TypeTagU256;
-  }
-};
-var TypeTagBool = class _TypeTagBool extends TypeTag {
-  toString() {
-    return "bool";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Bool */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagBool();
-  }
-};
-var TypeTagU8 = class _TypeTagU8 extends TypeTag {
-  toString() {
-    return "u8";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(1 /* U8 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU8();
-  }
-};
-var TypeTagU16 = class _TypeTagU16 extends TypeTag {
-  toString() {
-    return "u16";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(8 /* U16 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU16();
-  }
-};
-var TypeTagU32 = class _TypeTagU32 extends TypeTag {
-  toString() {
-    return "u32";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(9 /* U32 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU32();
-  }
-};
-var TypeTagU64 = class _TypeTagU64 extends TypeTag {
-  toString() {
-    return "u64";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* U64 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU64();
-  }
-};
-var TypeTagU128 = class _TypeTagU128 extends TypeTag {
-  toString() {
-    return "u128";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* U128 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU128();
-  }
-};
-var TypeTagU256 = class _TypeTagU256 extends TypeTag {
-  toString() {
-    return "u256";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(10 /* U256 */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagU256();
-  }
-};
-var TypeTagAddress = class _TypeTagAddress extends TypeTag {
-  toString() {
-    return "address";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(4 /* Address */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagAddress();
-  }
-};
-var TypeTagSigner = class _TypeTagSigner extends TypeTag {
-  toString() {
-    return "signer";
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(5 /* Signer */);
-  }
-  static load(_deserializer) {
-    return new _TypeTagSigner();
-  }
-};
-var TypeTagReference = class _TypeTagReference extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  toString() {
-    return `&${this.value.toString()}`;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(254 /* Reference */);
-  }
-  static load(deserializer) {
-    const value = TypeTag.deserialize(deserializer);
-    return new _TypeTagReference(value);
-  }
-};
-var TypeTagGeneric = class _TypeTagGeneric extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-    if (value < 0)
-      throw new Error("Generic type parameter index cannot be negative");
-  }
-  toString() {
-    return `T${this.value}`;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(255 /* Generic */);
-    serializer.serializeU32(this.value);
-  }
-  static load(deserializer) {
-    const value = deserializer.deserializeU32();
-    return new _TypeTagGeneric(value);
-  }
-};
-var TypeTagVector = class _TypeTagVector extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  toString() {
-    return `vector<${this.value.toString()}>`;
-  }
-  static u8() {
-    return new _TypeTagVector(new TypeTagU8());
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(6 /* Vector */);
-    this.value.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = TypeTag.deserialize(deserializer);
-    return new _TypeTagVector(value);
-  }
-};
-var TypeTagStruct = class _TypeTagStruct extends TypeTag {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  toString() {
-    let typePredicate = "";
-    if (this.value.typeArgs.length > 0) {
-      typePredicate = `<${this.value.typeArgs.map((typeArg) => typeArg.toString()).join(", ")}>`;
-    }
-    return `${this.value.address.toString()}::${this.value.moduleName.identifier}::${this.value.name.identifier}${typePredicate}`;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(7 /* Struct */);
-    this.value.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = StructTag.deserialize(deserializer);
-    return new _TypeTagStruct(value);
-  }
-  isTypeTag(address, moduleName, structName) {
-    return this.value.moduleName.identifier === moduleName && this.value.name.identifier === structName && this.value.address.equals(address);
-  }
-  isString() {
-    return this.isTypeTag(AccountAddress.ONE, "string", "String");
-  }
-  isOption() {
-    return this.isTypeTag(AccountAddress.ONE, "option", "Option");
-  }
-  isObject() {
-    return this.isTypeTag(AccountAddress.ONE, "object", "Object");
-  }
-};
-var StructTag = class _StructTag extends Serializable {
-  constructor(address, module_name, name, type_args) {
-    super();
-    this.address = address;
-    this.moduleName = module_name;
-    this.name = name;
-    this.typeArgs = type_args;
-  }
-  serialize(serializer) {
-    serializer.serialize(this.address);
-    serializer.serialize(this.moduleName);
-    serializer.serialize(this.name);
-    serializer.serializeVector(this.typeArgs);
-  }
-  static deserialize(deserializer) {
-    const address = AccountAddress.deserialize(deserializer);
-    const moduleName = Identifier.deserialize(deserializer);
-    const name = Identifier.deserialize(deserializer);
-    const typeArgs = deserializer.deserializeVector(TypeTag);
-    return new _StructTag(address, moduleName, name, typeArgs);
-  }
-};
-function aptosCoinStructTag() {
-  return new StructTag(AccountAddress.ONE, new Identifier("aptos_coin"), new Identifier("AptosCoin"), []);
-}
-function stringStructTag() {
-  return new StructTag(AccountAddress.ONE, new Identifier("string"), new Identifier("String"), []);
-}
-function optionStructTag(typeArg) {
-  return new StructTag(AccountAddress.ONE, new Identifier("option"), new Identifier("Option"), [typeArg]);
-}
-function objectStructTag(typeArg) {
-  return new StructTag(AccountAddress.ONE, new Identifier("object"), new Identifier("Object"), [typeArg]);
-}
-
-export {
-  TypeTag,
-  TypeTagBool,
-  TypeTagU8,
-  TypeTagU16,
-  TypeTagU32,
-  TypeTagU64,
-  TypeTagU128,
-  TypeTagU256,
-  TypeTagAddress,
-  TypeTagSigner,
-  TypeTagReference,
-  TypeTagGeneric,
-  TypeTagVector,
-  TypeTagStruct,
-  StructTag,
-  aptosCoinStructTag,
-  stringStructTag,
-  optionStructTag,
-  objectStructTag
-};
-//# sourceMappingURL=chunk-P3RTJ6VC.mjs.map