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

package/dist/esm/chunk-6OFCIXWS.mjs

@@ -1,379 +0,0 @@
-import {
-  parseTypeTag
-} from "./chunk-BMM72IIP.mjs";
-import {
-  convertNumber,
-  findFirstNonSignerArg,
-  isBcsAddress,
-  isBcsBool,
-  isBcsString,
-  isBcsU128,
-  isBcsU16,
-  isBcsU256,
-  isBcsU32,
-  isBcsU64,
-  isBcsU8,
-  isBool,
-  isEmptyOption,
-  isEncodedEntryFunctionArgument,
-  isLargeNumber,
-  isString,
-  throwTypeMismatch
-} from "./chunk-JQIRRM7G.mjs";
-import {
-  getModule
-} from "./chunk-FRLS4GRM.mjs";
-import {
-  TypeTagAddress,
-  TypeTagBool,
-  TypeTagStruct,
-  TypeTagU128,
-  TypeTagU16,
-  TypeTagU256,
-  TypeTagU32,
-  TypeTagU64,
-  TypeTagU8
-} from "./chunk-DDZGHA66.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveOption,
-  MoveString,
-  MoveVector
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-QSYWLSSN.mjs";
-import {
-  CallArgument
-} from "./chunk-G4NBRMZ2.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 fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig) {
-  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
-  if (!functionAbi) {
-    throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
-  }
-  const params = [];
-  for (let i = 0; i < functionAbi.params.length; i += 1) {
-    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
-  }
-  return {
-    typeParameters: functionAbi.generic_type_params,
-    parameters: params
-  };
-}
-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 convertCallArgument(argument, functionName, functionAbi, position, genericTypeParams) {
-  if (argument instanceof CallArgument) {
-    return argument;
-  }
-  return CallArgument.newBytes(
-    convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes()
-  );
-}
-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 (isString(arg)) {
-      if (arg.startsWith("[")) {
-        return checkOrConvertArgument(JSON.parse(arg), param, position, genericTypeParams);
-      }
-    }
-    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,
-  fetchMoveFunctionAbi,
-  fetchEntryFunctionAbi,
-  fetchViewFunctionAbi,
-  convertCallArgument,
-  convertArgument,
-  checkOrConvertArgument
-};
-//# sourceMappingURL=chunk-6OFCIXWS.mjs.map

package/dist/esm/chunk-6OFCIXWS.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/transactionBuilder/remoteAbi.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { parseTypeTag } from \"../typeTag/parser\";\nimport {\n  TypeTag,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagStruct,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n} from \"../typeTag\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport {\n  EntryFunctionArgumentTypes,\n  SimpleEntryFunctionArgumentTypes,\n  EntryFunctionABI,\n  ViewFunctionABI,\n  FunctionABI,\n  TypeArgument,\n} from \"../types\";\nimport { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from \"../../bcs\";\nimport { AccountAddress } from \"../../core\";\nimport { getModule } from \"../../internal/utils\";\nimport {\n  findFirstNonSignerArg,\n  isBcsAddress,\n  isBcsBool,\n  isBcsString,\n  isBcsU128,\n  isBcsU16,\n  isBcsU256,\n  isBcsU32,\n  isBcsU64,\n  isBcsU8,\n  isBool,\n  isEncodedEntryFunctionArgument,\n  isLargeNumber,\n  isEmptyOption,\n  isString,\n  throwTypeMismatch,\n  convertNumber,\n} from \"./helpers\";\nimport { CallArgument, MoveFunction } from \"../../types\";\n\nconst TEXT_ENCODER = new TextEncoder();\n\n/**\n * Convert type arguments to only type tags, allowing for string representations of type tags.\n *\n * @param typeArguments - An optional array of type arguments that may include string representations.\n * @returns An array of TypeTag objects derived from the provided type arguments.\n * @group Implementation\n * @category Transactions\n */\nexport function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {\n  return (\n    typeArguments?.map((typeArg: TypeArgument): TypeTag => {\n      // Convert to TypeTag if it's a string representation\n      if (isString(typeArg)) {\n        return parseTypeTag(typeArg);\n      }\n      return typeArg;\n    }) ?? []\n  );\n}\n\n/**\n * Fetches the ABI of a specified function from the on-chain module ABI. This function allows you to access the details of a\n * specific function within a module.\n *\n * @param moduleAddress - The address of the module from which to fetch the function ABI.\n * @param moduleName - The name of the module containing the function.\n * @param functionName - The name of the function whose ABI is to be fetched.\n * @param aptosConfig - The configuration settings for Aptos.\n * @group Implementation\n * @category Transactions\n */\nexport async function fetchFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<MoveFunction | undefined> {\n  // This fetch from the API is currently cached\n  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });\n\n  if (module.abi) {\n    return module.abi.exposed_functions.find((func) => func.name === functionName);\n  }\n\n  return undefined;\n}\n\n/**\n * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.\n * @param moduleAddress\n * @param moduleName\n * @param functionName\n * @param aptosConfig\n */\nexport async function fetchMoveFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<FunctionABI> {\n  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);\n  if (!functionAbi) {\n    throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);\n  }\n  const params: TypeTag[] = [];\n  for (let i = 0; i < functionAbi.params.length; i += 1) {\n    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));\n  }\n\n  return {\n    typeParameters: functionAbi.generic_type_params,\n    parameters: params,\n  };\n}\n\n/**\n * Fetches the ABI for an entry function from the specified module address.\n * This function validates if the ABI corresponds to an entry function and retrieves its parameters.\n *\n * @param moduleAddress - The address of the module containing the entry function.\n * @param moduleName - The name of the module containing the entry function.\n * @param functionName - The name of the entry function to fetch the ABI for.\n * @param aptosConfig - The configuration settings for Aptos.\n * @returns An object containing the number of signers, type parameters, and function parameters.\n * @throws Error if the ABI cannot be found or if the function is not an entry function.\n * @group Implementation\n * @category Transactions\n */\nexport async function fetchEntryFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<EntryFunctionABI> {\n  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);\n\n  // If there's no ABI, then the function is invalid\n  if (!functionAbi) {\n    throw new Error(`Could not find entry function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);\n  }\n\n  // Non-entry functions also can't be used\n  if (!functionAbi.is_entry) {\n    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an entry function`);\n  }\n\n  // Remove the signer arguments\n  const numSigners = findFirstNonSignerArg(functionAbi);\n  const params: TypeTag[] = [];\n  for (let i = numSigners; i < functionAbi.params.length; i += 1) {\n    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));\n  }\n\n  return {\n    signers: numSigners,\n    typeParameters: functionAbi.generic_type_params,\n    parameters: params,\n  };\n}\n\n/**\n * Fetches the ABI for a view function from the specified module address.\n * This function ensures that the ABI is valid and retrieves the type parameters, parameters, and return types for the view function.\n *\n * @param moduleAddress - The address of the module containing the view function.\n * @param moduleName - The name of the module containing the view function.\n * @param functionName - The name of the view function for which to fetch the ABI.\n * @param aptosConfig - The configuration settings for Aptos.\n * @returns An object containing the type parameters, parameters, and return types of the view function.\n * @throws Error if the ABI cannot be found or if the function is not a view function.\n * @group Implementation\n * @category Transactions\n */\nexport async function fetchViewFunctionAbi(\n  moduleAddress: string,\n  moduleName: string,\n  functionName: string,\n  aptosConfig: AptosConfig,\n): Promise<ViewFunctionABI> {\n  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);\n\n  // If there's no ABI, then the function is invalid\n  if (!functionAbi) {\n    throw new Error(`Could not find view function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);\n  }\n\n  // Non-view functions can't be used\n  if (!functionAbi.is_view) {\n    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an view function`);\n  }\n\n  // Type tag parameters for the function\n  const params: TypeTag[] = [];\n  for (let i = 0; i < functionAbi.params.length; i += 1) {\n    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));\n  }\n\n  // The return types of the view function\n  const returnTypes: TypeTag[] = [];\n  for (let i = 0; i < functionAbi.return.length; i += 1) {\n    returnTypes.push(parseTypeTag(functionAbi.return[i], { allowGenerics: true }));\n  }\n\n  return {\n    typeParameters: functionAbi.generic_type_params,\n    parameters: params,\n    returnTypes,\n  };\n}\n\n/**\n * Converts a entry function argument into CallArgument, if necessary.\n * This function checks the provided argument against the expected parameter type and converts it accordingly.\n *\n * @param functionName - The name of the function for which the argument is being converted.\n * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.\n * @param argument - The argument to be converted, which can be of various types. If the argument is already\n *                   CallArgument returned from TransactionComposer it would be returned immediately.\n * @param position - The index of the argument in the function's parameter list.\n * @param genericTypeParams - An array of type tags for any generic type parameters.\n */\nexport function convertCallArgument(\n  argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n  functionName: string,\n  functionAbi: FunctionABI,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n): CallArgument {\n  if (argument instanceof CallArgument) {\n    return argument;\n  }\n  return CallArgument.newBytes(\n    convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes(),\n  );\n}\n\n/**\n * Converts a non-BCS encoded argument into BCS encoded, if necessary.\n * This function checks the provided argument against the expected parameter type and converts it accordingly.\n *\n * @param functionName - The name of the function for which the argument is being converted.\n * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.\n * @param arg - The argument to be converted, which can be of various types.\n * @param position - The index of the argument in the function's parameter list.\n * @param genericTypeParams - An array of type tags for any generic type parameters.\n * @group Implementation\n * @category Transactions\n */\nexport function convertArgument(\n  functionName: string,\n  functionAbi: FunctionABI,\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n) {\n  // Ensure not too many arguments\n  if (position >= functionAbi.parameters.length) {\n    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);\n  }\n\n  const param = functionAbi.parameters[position];\n  return checkOrConvertArgument(arg, param, position, genericTypeParams);\n}\n\n/**\n * Checks if the provided argument is BCS encoded and converts it if necessary, ensuring type compatibility with the ABI.\n * This function helps in validating and converting arguments for entry functions based on their expected types.\n *\n * @param arg - The argument to check or convert, which can be either a simple or entry function argument type.\n * @param param - The expected type tag for the argument.\n * @param position - The position of the argument in the function call.\n * @param genericTypeParams - An array of generic type parameters that may be used for conversion.\n * @group Implementation\n * @category Transactions\n */\nexport function checkOrConvertArgument(\n  arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,\n  param: TypeTag,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n) {\n  // If the argument is bcs encoded, we can just use it directly\n  if (isEncodedEntryFunctionArgument(arg)) {\n    // Ensure the type matches the ABI\n\n    /**\n     * Checks the type of the provided argument against the expected type.\n     * This function helps validate that the argument conforms to the specified type requirements.\n     *\n     * @param typeArgs - The expected type arguments.\n     * @param arg - The argument to be checked.\n     * @param position - The position of the argument in the context of the check.\n     * @group Implementation\n     * @category Transactions\n     */\n    checkType(param, arg, position);\n    return arg;\n  }\n\n  // If it is not BCS encoded, we will need to convert it with the ABI\n  return parseArg(arg, param, position, genericTypeParams);\n}\n\n/**\n * Parses a non-BCS encoded argument into a BCS encoded argument recursively.\n * This function helps convert various types of input arguments into their corresponding BCS encoded formats based on the\n * specified parameter type.\n *\n * @param arg - The argument to be parsed, which can be of various types.\n * @param param - The type tag that defines the expected type of the argument.\n * @param position - The position of the argument in the function call, used for error reporting.\n * @param genericTypeParams - An array of type tags for generic type parameters, used when the parameter type is generic.\n * @group Implementation\n * @category Transactions\n */\nfunction parseArg(\n  arg: SimpleEntryFunctionArgumentTypes,\n  param: TypeTag,\n  position: number,\n  genericTypeParams: Array<TypeTag>,\n): EntryFunctionArgumentTypes {\n  if (param.isBool()) {\n    if (isBool(arg)) {\n      return new Bool(arg);\n    }\n    if (isString(arg)) {\n      if (arg === \"true\") return new Bool(true);\n      if (arg === \"false\") return new Bool(false);\n    }\n\n    /**\n     * Throws a type mismatch error for the specified move option.\n     *\n     * @param moveOption - The name of the move option that caused the type mismatch.\n     * @param position - The position where the error occurred.\n     * @group Implementation\n     * @category Transactions\n     */\n    throwTypeMismatch(\"boolean\", position);\n  }\n  // TODO: support uint8array?\n  if (param.isAddress()) {\n    if (isString(arg)) {\n      return AccountAddress.fromString(arg);\n    }\n    throwTypeMismatch(\"string | AccountAddress\", position);\n  }\n  if (param.isU8()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U8(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU16()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U16(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU32()) {\n    const num = convertNumber(arg);\n    if (num !== undefined) {\n      return new U32(num);\n    }\n    throwTypeMismatch(\"number | string\", position);\n  }\n  if (param.isU64()) {\n    if (isLargeNumber(arg)) {\n      return new U64(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n  if (param.isU128()) {\n    if (isLargeNumber(arg)) {\n      return new U128(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n  if (param.isU256()) {\n    if (isLargeNumber(arg)) {\n      return new U256(BigInt(arg));\n    }\n    throwTypeMismatch(\"bigint | number | string\", position);\n  }\n\n  // Generic needs to use the subtype\n  if (param.isGeneric()) {\n    const genericIndex = param.value;\n    if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {\n      throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);\n    }\n\n    return checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams);\n  }\n\n  // We have to special case some vectors for Vector<u8>\n  if (param.isVector()) {\n    // Check special case for Vector<u8>\n    if (param.value.isU8()) {\n      // We don't allow vector<u8>, but we convert strings to UTF8 Uint8Array\n      // This is legacy behavior from the original SDK\n      if (isString(arg)) {\n        return MoveVector.U8(TEXT_ENCODER.encode(arg));\n      }\n      if (arg instanceof Uint8Array) {\n        return MoveVector.U8(arg);\n      }\n      if (arg instanceof ArrayBuffer) {\n        return MoveVector.U8(new Uint8Array(arg));\n      }\n    }\n\n    if (isString(arg)) {\n      // In a web env, arguments are passing as strings\n      if (arg.startsWith(\"[\")) {\n        return checkOrConvertArgument(JSON.parse(arg), param, position, genericTypeParams);\n      }\n    }\n\n    // TODO: Support Uint16Array, Uint32Array, BigUint64Array?\n\n    if (Array.isArray(arg)) {\n      return new MoveVector(arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams)));\n    }\n\n    throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);\n  }\n\n  // Handle structs as they're more complex\n  if (param.isStruct()) {\n    if (param.isString()) {\n      if (isString(arg)) {\n        return new MoveString(arg);\n      }\n      throwTypeMismatch(\"string\", position);\n    }\n    if (param.isObject()) {\n      // The inner type of Object doesn't matter, since it's just syntactic sugar\n      if (isString(arg)) {\n        return AccountAddress.fromString(arg);\n      }\n      throwTypeMismatch(\"string | AccountAddress\", position);\n    }\n\n    if (param.isOption()) {\n      if (isEmptyOption(arg)) {\n        // Here we attempt to reconstruct the underlying type\n        // Note, for some reason the `isBool` etc. does not work with the compiler\n        const innerParam = param.value.typeArgs[0];\n        if (innerParam instanceof TypeTagBool) {\n          return new MoveOption<Bool>(null);\n        }\n        if (innerParam instanceof TypeTagAddress) {\n          return new MoveOption<AccountAddress>(null);\n        }\n        if (innerParam instanceof TypeTagU8) {\n          return new MoveOption<U8>(null);\n        }\n        if (innerParam instanceof TypeTagU16) {\n          return new MoveOption<U16>(null);\n        }\n        if (innerParam instanceof TypeTagU32) {\n          return new MoveOption<U32>(null);\n        }\n        if (innerParam instanceof TypeTagU64) {\n          return new MoveOption<U64>(null);\n        }\n        if (innerParam instanceof TypeTagU128) {\n          return new MoveOption<U128>(null);\n        }\n        if (innerParam instanceof TypeTagU256) {\n          return new MoveOption<U256>(null);\n        }\n\n        // In all other cases, we will use a placeholder, it doesn't actually matter what the type is, but it will be obvious\n        // Note: This is a placeholder U8 type, and does not match the actual type, as that can't be dynamically grabbed\n        return new MoveOption<MoveString>(null);\n      }\n\n      return new MoveOption(checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams));\n    }\n\n    throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);\n  }\n\n  throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);\n}\n\n/**\n * Checks that the type of the BCS encoded argument matches the ABI\n * @param param\n * @param arg\n * @param position\n * @group Implementation\n * @category Transactions\n */\nfunction checkType(param: TypeTag, arg: EntryFunctionArgumentTypes, position: number) {\n  if (param.isBool()) {\n    if (isBcsBool(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"Bool\", position);\n  }\n  if (param.isAddress()) {\n    if (isBcsAddress(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"AccountAddress\", position);\n  }\n  if (param.isU8()) {\n    if (isBcsU8(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U8\", position);\n  }\n  if (param.isU16()) {\n    if (isBcsU16(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U16\", position);\n  }\n  if (param.isU32()) {\n    if (isBcsU32(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U32\", position);\n  }\n  if (param.isU64()) {\n    if (isBcsU64(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U64\", position);\n  }\n  if (param.isU128()) {\n    if (isBcsU128(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U128\", position);\n  }\n  if (param.isU256()) {\n    if (isBcsU256(arg)) {\n      return;\n    }\n    throwTypeMismatch(\"U256\", position);\n  }\n  if (param.isVector()) {\n    if (arg instanceof MoveVector) {\n      // If there's anything in it, check that the inner types match\n      // Note that since it's typed, the first item should be the same as the rest\n      if (arg.values.length > 0) {\n        checkType(param.value, arg.values[0], position);\n      }\n\n      return;\n    }\n    throwTypeMismatch(\"MoveVector\", position);\n  }\n\n  // Handle structs as they're more complex\n  if (param instanceof TypeTagStruct) {\n    if (param.isString()) {\n      if (isBcsString(arg)) {\n        return;\n      }\n      throwTypeMismatch(\"MoveString\", position);\n    }\n    if (param.isObject()) {\n      if (isBcsAddress(arg)) {\n        return;\n      }\n      throwTypeMismatch(\"AccountAddress\", position);\n    }\n    if (param.isOption()) {\n      if (arg instanceof MoveOption) {\n        // If there's a value, we can check the inner type (otherwise it doesn't really matter)\n        if (arg.value !== undefined) {\n          checkType(param.value.typeArgs[0], arg.value, position);\n        }\n        return;\n      }\n      throwTypeMismatch(\"MoveOption\", position);\n    }\n  }\n\n  throw new Error(`Type mismatch for argument ${position}, expected '${param.toString()}'`);\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-6SNGKTWE.mjs

@@ -1,91 +0,0 @@
-import {
-  KeylessPublicKey
-} from "./chunk-T573PCIR.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Serializer
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/core/crypto/federatedKeyless.ts
-var FederatedKeylessPublicKey = class _FederatedKeylessPublicKey extends AccountPublicKey {
-  constructor(jwkAddress, keylessPublicKey) {
-    super();
-    this.jwkAddress = AccountAddress.from(jwkAddress);
-    this.keylessPublicKey = keylessPublicKey;
-  }
-  /**
-   * Get the authentication key for the federated keyless public key
-   *
-   * @returns AuthenticationKey
-   * @group Implementation
-   * @category Serialization
-   */
-  authKey() {
-    const serializer = new Serializer();
-    serializer.serializeU32AsUleb128(4 /* FederatedKeyless */);
-    serializer.serializeFixedBytes(this.bcsToBytes());
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: serializer.toUint8Array()
-    });
-  }
-  /**
-   * Verifies a signed data with a public key
-   *
-   * @param args.message message
-   * @param args.signature The signature
-   * @returns true if the signature is valid
-   * @group Implementation
-   * @category Serialization
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args) {
-    throw new Error("Not yet implemented");
-  }
-  serialize(serializer) {
-    this.jwkAddress.serialize(serializer);
-    this.keylessPublicKey.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const jwkAddress = AccountAddress.deserialize(deserializer);
-    const keylessPublicKey = KeylessPublicKey.deserialize(deserializer);
-    return new _FederatedKeylessPublicKey(jwkAddress, keylessPublicKey);
-  }
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _FederatedKeylessPublicKey;
-  }
-  /**
-   * Creates a FederatedKeylessPublicKey from the JWT components plus pepper
-   *
-   * @param args.iss the iss of the identity
-   * @param args.uidKey the key to use to get the uidVal in the JWT token
-   * @param args.uidVal the value of the uidKey in the JWT token
-   * @param args.aud the client ID of the application
-   * @param args.pepper The pepper used to maintain privacy of the account
-   * @returns FederatedKeylessPublicKey
-   * @group Implementation
-   * @category Serialization
-   */
-  static create(args) {
-    return new _FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.create(args));
-  }
-  static fromJwtAndPepper(args) {
-    return new _FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.fromJwtAndPepper(args));
-  }
-  static isInstance(publicKey) {
-    return "jwkAddress" in publicKey && publicKey.jwkAddress instanceof AccountAddress && "keylessPublicKey" in publicKey && publicKey.keylessPublicKey instanceof KeylessPublicKey;
-  }
-};
-
-export {
-  FederatedKeylessPublicKey
-};
-//# sourceMappingURL=chunk-6SNGKTWE.mjs.map

package/dist/esm/chunk-6SNGKTWE.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/core/crypto/federatedKeyless.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountPublicKey, PublicKey } from \"./publicKey\";\nimport { Deserializer, Serializer } from \"../../bcs\";\nimport { HexInput, AnyPublicKeyVariant, SigningScheme } from \"../../types\";\nimport { AuthenticationKey } from \"../authenticationKey\";\nimport { AccountAddress, AccountAddressInput } from \"../accountAddress\";\nimport { KeylessPublicKey, KeylessSignature } from \"./keyless\";\n\n/**\n * Represents the FederatedKeylessPublicKey public key\n *\n * These keys use an on-chain address as a source of truth for the JWK used to verify signatures.\n *\n * FederatedKeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.\n * @group Implementation\n * @category Serialization\n */\nexport class FederatedKeylessPublicKey extends AccountPublicKey {\n  /**\n   * The address that contains the JWK set to be used for verification.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly jwkAddress: AccountAddress;\n\n  /**\n   * The inner public key which contains the standard Keyless public key.\n   * @group Implementation\n   * @category Serialization\n   */\n  readonly keylessPublicKey: KeylessPublicKey;\n\n  constructor(jwkAddress: AccountAddressInput, keylessPublicKey: KeylessPublicKey) {\n    super();\n    this.jwkAddress = AccountAddress.from(jwkAddress);\n    this.keylessPublicKey = keylessPublicKey;\n  }\n\n  /**\n   * Get the authentication key for the federated keyless public key\n   *\n   * @returns AuthenticationKey\n   * @group Implementation\n   * @category Serialization\n   */\n  authKey(): AuthenticationKey {\n    const serializer = new Serializer();\n    serializer.serializeU32AsUleb128(AnyPublicKeyVariant.FederatedKeyless);\n    serializer.serializeFixedBytes(this.bcsToBytes());\n    return AuthenticationKey.fromSchemeAndBytes({\n      scheme: SigningScheme.SingleKey,\n      input: serializer.toUint8Array(),\n    });\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   * @group Implementation\n   * @category Serialization\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this\n  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {\n    throw new Error(\"Not yet implemented\");\n  }\n\n  serialize(serializer: Serializer): void {\n    this.jwkAddress.serialize(serializer);\n    this.keylessPublicKey.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): FederatedKeylessPublicKey {\n    const jwkAddress = AccountAddress.deserialize(deserializer);\n    const keylessPublicKey = KeylessPublicKey.deserialize(deserializer);\n    return new FederatedKeylessPublicKey(jwkAddress, keylessPublicKey);\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is FederatedKeylessPublicKey {\n    return publicKey instanceof FederatedKeylessPublicKey;\n  }\n\n  /**\n   * Creates a FederatedKeylessPublicKey from the JWT components plus pepper\n   *\n   * @param args.iss the iss of the identity\n   * @param args.uidKey the key to use to get the uidVal in the JWT token\n   * @param args.uidVal the value of the uidKey in the JWT token\n   * @param args.aud the client ID of the application\n   * @param args.pepper The pepper used to maintain privacy of the account\n   * @returns FederatedKeylessPublicKey\n   * @group Implementation\n   * @category Serialization\n   */\n  static create(args: {\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.create(args));\n  }\n\n  static fromJwtAndPepper(args: {\n    jwt: string;\n    pepper: HexInput;\n    jwkAddress: AccountAddressInput;\n    uidKey?: string;\n  }): FederatedKeylessPublicKey {\n    return new FederatedKeylessPublicKey(args.jwkAddress, KeylessPublicKey.fromJwtAndPepper(args));\n  }\n\n  static isInstance(publicKey: PublicKey) {\n    return (\n      \"jwkAddress\" in publicKey &&\n      publicKey.jwkAddress instanceof AccountAddress &&\n      \"keylessPublicKey\" in publicKey &&\n      publicKey.keylessPublicKey instanceof KeylessPublicKey\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBO,IAAM,4BAAN,MAAM,mCAAkC,iBAAiB;AAAA,EAe9D,YAAY,YAAiC,kBAAoC;AAC/E,UAAM;AACN,SAAK,aAAa,eAAe,KAAK,UAAU;AAChD,SAAK,mBAAmB;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,UAA6B;AAC3B,UAAM,aAAa,IAAI,WAAW;AAClC,eAAW,8CAA0D;AACrE,eAAW,oBAAoB,KAAK,WAAW,CAAC;AAChD,WAAO,kBAAkB,mBAAmB;AAAA,MAC1C;AAAA,MACA,OAAO,WAAW,aAAa;AAAA,IACjC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,gBAAgB,MAAmE;AACjF,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAAA,EAEA,UAAU,YAA8B;AACtC,SAAK,WAAW,UAAU,UAAU;AACpC,SAAK,iBAAiB,UAAU,UAAU;AAAA,EAC5C;AAAA,EAEA,OAAO,YAAY,cAAuD;AACxE,UAAM,aAAa,eAAe,YAAY,YAAY;AAC1D,UAAM,mBAAmB,iBAAiB,YAAY,YAAY;AAClE,WAAO,IAAI,2BAA0B,YAAY,gBAAgB;AAAA,EACnE;AAAA,EAEA,OAAO,YAAY,WAA8D;AAC/E,WAAO,qBAAqB;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAO,OAAO,MAOgB;AAC5B,WAAO,IAAI,2BAA0B,KAAK,YAAY,iBAAiB,OAAO,IAAI,CAAC;AAAA,EACrF;AAAA,EAEA,OAAO,iBAAiB,MAKM;AAC5B,WAAO,IAAI,2BAA0B,KAAK,YAAY,iBAAiB,iBAAiB,IAAI,CAAC;AAAA,EAC/F;AAAA,EAEA,OAAO,WAAW,WAAsB;AACtC,WACE,gBAAgB,aAChB,UAAU,sBAAsB,kBAChC,sBAAsB,aACtB,UAAU,4BAA4B;AAAA,EAE1C;AACF;","names":[]}

package/dist/esm/chunk-6T3V5LXK.mjs

@@ -1,119 +0,0 @@
-import {
-  aptosBinaryRequest,
-  aptosRequest
-} from "./chunk-G34CJDST.mjs";
-
-// src/client/post.ts
-async function post(options) {
-  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosRequest(
-    {
-      url,
-      method: "POST",
-      originMethod,
-      path,
-      body,
-      contentType,
-      acceptType,
-      params,
-      overrides
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function postBinary(options) {
-  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosBinaryRequest(
-    {
-      url,
-      method: "POST",
-      originMethod,
-      path,
-      body,
-      contentType,
-      acceptType,
-      params,
-      overrides
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function postAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return post({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function postBinaryAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return postBinary({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosIndexer(options) {
-  const { aptosConfig } = options;
-  return post({
-    ...options,
-    type: "Indexer" /* INDEXER */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.indexerConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.indexerConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosFaucet(options) {
-  const { aptosConfig } = options;
-  const modifiedAptosConfig = {
-    ...aptosConfig,
-    clientConfig: { ...aptosConfig.clientConfig }
-  };
-  delete modifiedAptosConfig?.clientConfig?.API_KEY;
-  return post({
-    ...options,
-    type: "Faucet" /* FAUCET */,
-    overrides: {
-      ...modifiedAptosConfig.clientConfig,
-      ...modifiedAptosConfig.faucetConfig,
-      ...options.overrides,
-      HEADERS: { ...modifiedAptosConfig.clientConfig?.HEADERS, ...modifiedAptosConfig.faucetConfig?.HEADERS }
-    }
-  });
-}
-async function postAptosPepperService(options) {
-  return post({ ...options, type: "Pepper" /* PEPPER */ });
-}
-async function postAptosProvingService(options) {
-  return post({ ...options, type: "Prover" /* PROVER */ });
-}
-
-export {
-  post,
-  postBinary,
-  postAptosFullNode,
-  postBinaryAptosFullNode,
-  postAptosIndexer,
-  postAptosFaucet,
-  postAptosPepperService,
-  postAptosProvingService
-};
-//# sourceMappingURL=chunk-6T3V5LXK.mjs.map