@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-CXUGZXED.mjs

@@ -1,307 +0,0 @@
-import {
-  parseTypeTag
-} from "./chunk-DNPMS2OF.mjs";
-import {
-  findFirstNonSignerArg,
-  isBcsAddress,
-  isBcsBool,
-  isBcsString,
-  isBcsU128,
-  isBcsU16,
-  isBcsU256,
-  isBcsU32,
-  isBcsU64,
-  isBcsU8,
-  isBool,
-  isEncodedEntryFunctionArgument,
-  isLargeNumber,
-  isNull,
-  isNumber,
-  isString,
-  throwTypeMismatch
-} from "./chunk-ZMFKQUHL.mjs";
-import {
-  getModule
-} from "./chunk-Y2LV3S5W.mjs";
-import {
-  TypeTagStruct
-} from "./chunk-7FO3S6IZ.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  MoveOption,
-  MoveString,
-  MoveVector
-} from "./chunk-AR7X6GWQ.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-WK5ZSNE2.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);
-    }
-    throwTypeMismatch("boolean", position);
-  }
-  if (param.isAddress()) {
-    if (isString(arg)) {
-      return AccountAddress.fromString(arg);
-    }
-    throwTypeMismatch("string | AccountAddress", position);
-  }
-  if (param.isU8()) {
-    if (isNumber(arg)) {
-      return new U8(arg);
-    }
-    throwTypeMismatch("number", position);
-  }
-  if (param.isU16()) {
-    if (isNumber(arg)) {
-      return new U16(arg);
-    }
-    throwTypeMismatch("number", position);
-  }
-  if (param.isU32()) {
-    if (isNumber(arg)) {
-      return new U32(arg);
-    }
-    throwTypeMismatch("number", 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 (isNull(arg)) {
-        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-CXUGZXED.mjs.map

package/dist/esm/chunk-D2BVBXWO.mjs

@@ -1,7 +0,0 @@
-// src/version.ts
-var VERSION = "1.14.0-zeta.1";
-
-export {
-  VERSION
-};
-//# sourceMappingURL=chunk-D2BVBXWO.mjs.map