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

package/dist/esm/chunk-JQIRRM7G.mjs

@@ -1,195 +0,0 @@
-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 {
-  FixedBytes
-} from "./chunk-Y3ENAKRC.mjs";
-
-// src/transactions/transactionBuilder/helpers.ts
-function isBool(arg) {
-  return typeof arg === "boolean";
-}
-function isString(arg) {
-  return typeof arg === "string";
-}
-function isNumber(arg) {
-  return typeof arg === "number";
-}
-function convertNumber(arg) {
-  if (isNumber(arg)) {
-    return arg;
-  }
-  if (isString(arg) && arg !== "") {
-    return Number.parseInt(arg, 10);
-  }
-  return void 0;
-}
-function isLargeNumber(arg) {
-  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
-}
-function isEmptyOption(arg) {
-  return arg === null || arg === void 0;
-}
-function isEncodedEntryFunctionArgument(arg) {
-  return (
-    /**
-     * Determines if the provided argument is an instance of the Bool class.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsBool(arg) || /**
-     * Determines if the provided argument is an instance of U8.
-     * This function helps validate the type of the argument passed to ensure it is a U8 type.
-     *
-     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU8(arg) || /**
-     * Determines if the provided argument is an instance of U16.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU16(arg) || /**
-     * Determines if the provided argument is an instance of U32.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @returns A boolean indicating whether the argument is a U32 instance.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU32(arg) || /**
-     * Determine if the provided argument is an instance of U64.
-     * This function helps validate that the argument conforms to the expected U64 type.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU64(arg) || /**
-     * Determines if the provided argument is an instance of U128.
-     * This function helps validate the type of the argument passed to ensure it is a U128 type.
-     *
-     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU128(arg) || /**
-     * Determines if the provided argument is an instance of U256.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @returns A boolean indicating whether the argument is a U256 instance.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU256(arg) || /**
-     * Determines if the provided argument is an instance of AccountAddress.
-     * This function helps validate whether a given input corresponds to a valid BCS address type.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsAddress(arg) || /**
-     * Determine if the provided argument is an instance of MoveString.
-     *
-     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsString(arg) || /**
-     * Determine if the provided argument is an instance of FixedBytes.
-     * This function helps to validate the type of the argument being passed.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption
-  );
-}
-function isBcsBool(arg) {
-  return arg instanceof Bool;
-}
-function isBcsAddress(arg) {
-  return arg instanceof AccountAddress;
-}
-function isBcsString(arg) {
-  return arg instanceof MoveString;
-}
-function isBcsFixedBytes(arg) {
-  return arg instanceof FixedBytes;
-}
-function isBcsU8(arg) {
-  return arg instanceof U8;
-}
-function isBcsU16(arg) {
-  return arg instanceof U16;
-}
-function isBcsU32(arg) {
-  return arg instanceof U32;
-}
-function isBcsU64(arg) {
-  return arg instanceof U64;
-}
-function isBcsU128(arg) {
-  return arg instanceof U128;
-}
-function isBcsU256(arg) {
-  return arg instanceof U256;
-}
-function isScriptDataInput(arg) {
-  return "bytecode" in arg;
-}
-function throwTypeMismatch(expectedType, position) {
-  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
-}
-function findFirstNonSignerArg(functionAbi) {
-  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
-  if (index < 0) {
-    return functionAbi.params.length;
-  }
-  return index;
-}
-
-export {
-  isBool,
-  isString,
-  isNumber,
-  convertNumber,
-  isLargeNumber,
-  isEmptyOption,
-  isEncodedEntryFunctionArgument,
-  isBcsBool,
-  isBcsAddress,
-  isBcsString,
-  isBcsFixedBytes,
-  isBcsU8,
-  isBcsU16,
-  isBcsU32,
-  isBcsU64,
-  isBcsU128,
-  isBcsU256,
-  isScriptDataInput,
-  throwTypeMismatch,
-  findFirstNonSignerArg
-};
-//# sourceMappingURL=chunk-JQIRRM7G.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/transactions/transactionBuilder/helpers.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  EntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputScriptData,\n  SimpleEntryFunctionArgumentTypes,\n} from \"../types\";\nimport { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from \"../../bcs\";\nimport { AccountAddress } from \"../../core\";\nimport { MoveFunction } from \"../../types\";\n\n/**\n * Determines if the provided argument is of type boolean.\n * This can help in validating input types before processing them further.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a boolean.\n * @group Implementation\n * @category Transactions\n */\nexport function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {\n  return typeof arg === \"boolean\";\n}\n\n/**\n * Checks if the provided argument is of type string.\n *\n * @param arg - The value to be checked for string type.\n * @returns A boolean indicating whether the argument is a string.\n * @group Implementation\n * @category Transactions\n */\nexport function isString(arg: any): arg is string {\n  return typeof arg === \"string\";\n}\n\n/**\n * Determines if the provided argument is of type number.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a number.\n * @group Implementation\n * @category Transactions\n */\nexport function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {\n  return typeof arg === \"number\";\n}\n\n/**\n * Converts a number or a string representation of a number into a number type.\n * This function is useful for ensuring that the input is in a consistent numeric format,\n * which can help prevent type mismatches in further processing.\n *\n * @param arg - The input value to be converted. This can be a number, a string representing a number, or any other type.\n * @returns Returns the converted number if the input is valid; otherwise, it returns undefined.\n * @group Implementation\n * @category Transactions\n */\nexport function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | undefined {\n  if (isNumber(arg)) {\n    return arg;\n  }\n  if (isString(arg) && arg !== \"\") {\n    return Number.parseInt(arg, 10);\n  }\n\n  return undefined;\n}\n\n/**\n * Determines if the provided argument is a large number, which can be a number, bigint, or string representation of a number.\n *\n * @param arg - The argument to check, which can be of type number, bigint, or string.\n * @group Implementation\n * @category Transactions\n */\nexport function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {\n  return typeof arg === \"number\" || typeof arg === \"bigint\" || typeof arg === \"string\";\n}\n\n/**\n * Checks if the provided argument is empty, meaning it is either null or undefined.\n *\n * @param arg - The argument to check for emptiness.\n * @returns A boolean indicating whether the argument is empty.\n * @group Implementation\n * @category Transactions\n */\nexport function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {\n  return arg === null || arg === undefined;\n}\n\n/**\n * Determines if the provided argument is a valid encoded entry function argument type.\n * This function helps validate that the argument conforms to the expected types for entry function parameters.\n *\n * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n * @group Implementation\n * @category Transactions\n */\nexport function isEncodedEntryFunctionArgument(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is EntryFunctionArgumentTypes {\n  return (\n    /**\n     * Determines if the provided argument is an instance of the Bool class.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsBool(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U8.\n     * This function helps validate the type of the argument passed to ensure it is a U8 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU8(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U16.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU16(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U32.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U32 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU32(arg) ||\n    /**\n     * Determine if the provided argument is an instance of U64.\n     * This function helps validate that the argument conforms to the expected U64 type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU64(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U128.\n     * This function helps validate the type of the argument passed to ensure it is a U128 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU128(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U256.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U256 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU256(arg) ||\n    /**\n     * Determines if the provided argument is an instance of AccountAddress.\n     * This function helps validate whether a given input corresponds to a valid BCS address type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsAddress(arg) ||\n    /**\n     * Determine if the provided argument is an instance of MoveString.\n     *\n     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsString(arg) ||\n    /**\n     * Determine if the provided argument is an instance of FixedBytes.\n     * This function helps to validate the type of the argument being passed.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsFixedBytes(arg) ||\n    arg instanceof MoveVector ||\n    arg instanceof MoveOption\n  );\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool {\n  return arg instanceof Bool;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsAddress(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is AccountAddress {\n  return arg instanceof AccountAddress;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString {\n  return arg instanceof MoveString;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes {\n  return arg instanceof FixedBytes;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8 {\n  return arg instanceof U8;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16 {\n  return arg instanceof U16;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32 {\n  return arg instanceof U32;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64 {\n  return arg instanceof U64;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128 {\n  return arg instanceof U128;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {\n  return arg instanceof U256;\n}\n\n/**\n * Determines if the provided argument contains script data input by checking for the presence of bytecode.\n *\n * @param arg - The input data to be checked, which can either be a payload with remote ABI or a standard payload.\n * @param arg.bytecode - The bytecode of the script, present if the input is script data.\n * @param arg.function - The function associated with the transaction, which is relevant for standard payloads.\n * @param arg.args - The arguments for the function, applicable in the context of standard payloads.\n * @group Implementation\n * @category Transactions\n */\nexport function isScriptDataInput(\n  arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,\n): arg is InputScriptData {\n  return \"bytecode\" in arg;\n}\n\n/**\n * Throws an error indicating a type mismatch for a specified argument position.\n * This function helps in debugging by providing clear feedback on expected types.\n *\n * @param expectedType - The type that was expected for the argument.\n * @param position - The position of the argument that caused the type mismatch.\n * @group Implementation\n * @category Transactions\n */\nexport function throwTypeMismatch(expectedType: string, position: number) {\n  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);\n}\n\n/**\n * Finds the index of the first non-signer argument in the function ABI parameters.\n *\n * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in\n * by signatures and not by the caller. This function helps identify the position of the first argument that\n * can be provided by the caller, allowing for easier handling of function parameters.\n *\n * @param functionAbi - The ABI of the function to analyze.\n * @returns The index of the first non-signer argument, or the length of the parameters array if none are found.\n * @group Implementation\n * @category Transactions\n */\nexport function findFirstNonSignerArg(functionAbi: MoveFunction): number {\n  const index = functionAbi.params.findIndex((param) => param !== \"signer\" && param !== \"&signer\");\n  if (index < 0) {\n    return functionAbi.params.length;\n  }\n  return index;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBO,SAAS,OAAO,KAAuD;AAC5E,SAAO,OAAO,QAAQ;AACxB;AAUO,SAAS,SAAS,KAAyB;AAChD,SAAO,OAAO,QAAQ;AACxB;AAUO,SAAS,SAAS,KAAsD;AAC7E,SAAO,OAAO,QAAQ;AACxB;AAYO,SAAS,cAAc,KAA2D;AACvF,MAAI,SAAS,GAAG,GAAG;AACjB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,GAAG,KAAK,QAAQ,IAAI;AAC/B,WAAO,OAAO,SAAS,KAAK,EAAE;AAAA,EAChC;AAEA,SAAO;AACT;AASO,SAAS,cAAc,KAAwE;AACpG,SAAO,OAAO,QAAQ,YAAY,OAAO,QAAQ,YAAY,OAAO,QAAQ;AAC9E;AAUO,SAAS,cAAc,KAAgE;AAC5F,SAAO,QAAQ,QAAQ,QAAQ;AACjC;AAUO,SAAS,+BACd,KACmC;AACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQE,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,QAAQ,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQX,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,aAAa,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQhB,YAAY,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASf,gBAAgB,GAAG,KACnB,eAAe,cACf,eAAe;AAAA;AAEnB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAKO,SAAS,aACd,KACuB;AACvB,SAAO,eAAe;AACxB;AAKO,SAAS,YAAY,KAAuF;AACjH,SAAO,eAAe;AACxB;AAKO,SAAS,gBAAgB,KAAuF;AACrH,SAAO,eAAe;AACxB;AAKO,SAAS,QAAQ,KAA+E;AACrG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAYO,SAAS,kBACd,KACwB;AACxB,SAAO,cAAc;AACvB;AAWO,SAAS,kBAAkB,cAAsB,UAAkB;AACxE,QAAM,IAAI,MAAM,8BAA8B,QAAQ,eAAe,YAAY,GAAG;AACtF;AAcO,SAAS,sBAAsB,aAAmC;AACvE,QAAM,QAAQ,YAAY,OAAO,UAAU,CAAC,UAAU,UAAU,YAAY,UAAU,SAAS;AAC/F,MAAI,QAAQ,GAAG;AACb,WAAO,YAAY,OAAO;AAAA,EAC5B;AACA,SAAO;AACT;","names":[]}

package/dist/esm/chunk-JXCZTOYC.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-JXCZTOYC.mjs.map

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

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

package/dist/esm/chunk-K5OCDM3W.mjs

@@ -1,207 +0,0 @@
-import {
-  AbstractKeylessAccount
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  SingleKeyAccount
-} from "./chunk-G7BB6K4B.mjs";
-import {
-  Ed25519Account
-} from "./chunk-62LC4PPC.mjs";
-import {
-  AccountAuthenticatorMultiKey
-} from "./chunk-AGKEC2IM.mjs";
-import {
-  MultiKey,
-  MultiKeySignature
-} from "./chunk-DMFRIING.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-
-// src/account/MultiKeyAccount.ts
-var MultiKeyAccount = class _MultiKeyAccount {
-  /**
-   * Constructs a MultiKeyAccount instance, which requires multiple signatures for transactions.
-   *
-   * @param args - The arguments for creating a MultiKeyAccount.
-   * @param args.multiKey - The multikey of the account consisting of N public keys and a number M representing the required signatures.
-   * @param args.signers - An array of M signers that will be used to sign the transaction.
-   * @param args.address - An optional account address input. If not provided, the derived address from the public key will be used.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  constructor(args) {
-    /**
-     * Signing scheme used to sign transactions
-     * @group Implementation
-     * @category Account (On-Chain Model)
-     */
-    this.signingScheme = 3 /* MultiKey */;
-    const { multiKey, address } = args;
-    const signers = args.signers.map(
-      (signer) => signer instanceof Ed25519Account ? SingleKeyAccount.fromEd25519Account(signer) : signer
-    );
-    if (multiKey.signaturesRequired > signers.length) {
-      throw new Error(
-        // eslint-disable-next-line max-len
-        `Not enough signers provided to satisfy the required signatures. Need ${multiKey.signaturesRequired} signers, but only ${signers.length} provided`
-      );
-    } else if (multiKey.signaturesRequired < signers.length) {
-      throw new Error(
-        // eslint-disable-next-line max-len
-        `More signers provided than required. Need ${multiKey.signaturesRequired} signers, but ${signers.length} provided`
-      );
-    }
-    this.publicKey = multiKey;
-    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
-    const bitPositions = [];
-    for (const signer of signers) {
-      bitPositions.push(this.publicKey.getIndex(signer.getAnyPublicKey()));
-    }
-    const signersAndBitPosition = signers.map((signer, index) => [signer, bitPositions[index]]);
-    signersAndBitPosition.sort((a, b) => a[1] - b[1]);
-    this.signers = signersAndBitPosition.map((value) => value[0]);
-    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);
-    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
-  }
-  /**
-   * Static constructor to create a MultiKeyAccount using the provided public keys and signers.
-   *
-   * @param args - The arguments for creating a MultiKeyAccount.
-   * @param args.publicKeys - The N public keys of the MultiKeyAccount.
-   * @param args.signaturesRequired - The number of signatures required to authorize a transaction.
-   * @param args.signers - An array of M signers that will be used to sign the transaction.
-   * @returns MultiKeyAccount - The newly created MultiKeyAccount.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static fromPublicKeysAndSigners(args) {
-    const { address, publicKeys, signaturesRequired, signers } = args;
-    const multiKey = new MultiKey({ publicKeys, signaturesRequired });
-    return new _MultiKeyAccount({ multiKey, signers, address });
-  }
-  /**
-   * Determines if the provided account is a multi-key account.
-   *
-   * @param account - The account to check.
-   * @returns A boolean indicating whether the account is a multi-key account.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static isMultiKeySigner(account) {
-    return account instanceof _MultiKeyAccount;
-  }
-  /**
-   * Sign a message using the account's signers and return an AccountAuthenticator containing the signature along with the
-   * account's public key.
-   * @param message - The signing message, represented as binary input in hexadecimal format.
-   * @returns An instance of AccountAuthenticatorMultiKey that includes the signature and the public key.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signWithAuthenticator(message) {
-    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));
-  }
-  /**
-   * Sign a transaction using the account's signers, returning an AccountAuthenticator that contains the signature and the
-   * account's public key.
-   * @param transaction - The raw transaction to be signed.
-   * @returns An AccountAuthenticatorMultiKey containing the signature of the transaction along with the account's public key.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signTransactionWithAuthenticator(transaction) {
-    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
-  }
-  /**
-   * Waits for any proofs on KeylessAccount signers to be fetched. This ensures that signing with the KeylessAccount does not
-   * fail due to missing proofs.
-   * @return {Promise<void>} A promise that resolves when all proofs have been fetched.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  async waitForProofFetch() {
-    const keylessSigners = this.signers.filter(
-      (signer) => signer instanceof AbstractKeylessAccount
-    );
-    const promises = keylessSigners.map(async (signer) => signer.waitForProofFetch());
-    await Promise.all(promises);
-  }
-  /**
-   * Validates that the Keyless Account can be used to sign transactions.
-   * @return
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  async checkKeylessAccountValidity(aptosConfig) {
-    const keylessSigners = this.signers.filter(
-      (signer) => signer instanceof AbstractKeylessAccount
-    );
-    const promises = keylessSigners.map((signer) => signer.checkKeylessAccountValidity(aptosConfig));
-    await Promise.all(promises);
-  }
-  /**
-   * Sign the given message using the MultiKeyAccount's signers
-   * @param data - The data to be signed in HexInput format.
-   * @returns MultiKeySignature
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  sign(data) {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.sign(data));
-    }
-    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-  /**
-   * Sign the given transaction using the MultiKeyAccount's signers.
-   * This function aggregates signatures from all signers associated with the MultiKeyAccount.
-   *
-   * @param transaction - The transaction to be signed.
-   * @returns MultiKeySignature - An object containing the aggregated signatures and a bitmap of the signatures.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signTransaction(transaction) {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.signTransaction(transaction));
-    }
-    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-  /**
-   * Verify the given message and signature with the public keys.
-   *
-   * This function checks if the provided signatures are valid for the given message using the corresponding public keys.
-   *
-   * @param args - The arguments for verifying the signature.
-   * @param args.message - The raw message data in HexInput format.
-   * @param args.signature - The signed message MultiKeySignature containing multiple signatures.
-   * @returns A boolean indicating whether the signatures are valid for the message.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    const isSignerIndicesSorted = this.signerIndicies.every(
-      (value, i) => i === 0 || value >= this.signerIndicies[i - 1]
-    );
-    if (!isSignerIndicesSorted) {
-      return false;
-    }
-    for (let i = 0; i < signature.signatures.length; i += 1) {
-      const singleSignature = signature.signatures[i];
-      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];
-      if (!publicKey.verifySignature({ message, signature: singleSignature })) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-export {
-  MultiKeyAccount
-};
-//# sourceMappingURL=chunk-K5OCDM3W.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/account/MultiKeyAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Account } from \"./Account\";\nimport { MultiKey, MultiKeySignature, PublicKey } from \"../core/crypto\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport { AccountAuthenticatorMultiKey } from \"../transactions/authenticator/account\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { AbstractKeylessAccount, KeylessSigner } from \"./AbstractKeylessAccount\";\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { SingleKeyAccount, SingleKeySigner, SingleKeySignerOrLegacyEd25519Account } from \"./SingleKeyAccount\";\nimport { Ed25519Account } from \"./Ed25519Account\";\n\n/**\n * Arguments required to verify a multi-key signature against a given message.\n *\n * @param message - The original message that was signed.\n * @param signature - The multi-key signature to be verified.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport interface VerifyMultiKeySignatureArgs {\n  message: HexInput;\n  signature: MultiKeySignature;\n}\n\n/**\n * Signer implementation for the MultiKey authentication scheme.\n *\n * This account utilizes an M of N signing scheme, where M and N are specified in the {@link MultiKey}.\n * It signs messages using an array of M accounts, each corresponding to a public key in the {@link MultiKey}.\n *\n * Note: Generating a signer instance does not create the account on-chain.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class MultiKeyAccount implements Account, KeylessSigner {\n  /**\n   * Public key associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: MultiKey;\n\n  /**\n   * Account address associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly accountAddress: AccountAddress;\n\n  /**\n   * Signing scheme used to sign transactions\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signingScheme: SigningScheme = SigningScheme.MultiKey;\n\n  /**\n   * The signers used to sign messages.  These signers should correspond to public keys in the\n   * MultiKeyAccount's public key.  The number of signers should be equal to this.publicKey.signaturesRequired.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signers: Account[];\n\n  /**\n   * An array of indices where for signer[i], signerIndicies[i] is the index of the corresponding public key in\n   * publicKey.publicKeys.  Used to derive the right public key to use for verification.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  // TODO: Rename Indicies to Indices\n  readonly signerIndicies: number[];\n\n  readonly signaturesBitmap: Uint8Array;\n\n  /**\n   * Constructs a MultiKeyAccount instance, which requires multiple signatures for transactions.\n   *\n   * @param args - The arguments for creating a MultiKeyAccount.\n   * @param args.multiKey - The multikey of the account consisting of N public keys and a number M representing the required signatures.\n   * @param args.signers - An array of M signers that will be used to sign the transaction.\n   * @param args.address - An optional account address input. If not provided, the derived address from the public key will be used.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    multiKey: MultiKey;\n    signers: SingleKeySignerOrLegacyEd25519Account[];\n    address?: AccountAddressInput;\n  }) {\n    const { multiKey, address } = args;\n\n    const signers: SingleKeySigner[] = args.signers.map((signer) =>\n      signer instanceof Ed25519Account ? SingleKeyAccount.fromEd25519Account(signer) : signer,\n    );\n\n    if (multiKey.signaturesRequired > signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `Not enough signers provided to satisfy the required signatures. Need ${multiKey.signaturesRequired} signers, but only ${signers.length} provided`,\n      );\n    } else if (multiKey.signaturesRequired < signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `More signers provided than required. Need ${multiKey.signaturesRequired} signers, but ${signers.length} provided`,\n      );\n    }\n\n    this.publicKey = multiKey;\n\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n\n    // For each signer, find its corresponding position in the MultiKey's public keys array\n    const bitPositions: number[] = [];\n    for (const signer of signers) {\n      bitPositions.push(this.publicKey.getIndex(signer.getAnyPublicKey()));\n    }\n\n    // Create pairs of [signer, position] and sort them by position\n    // This sorting is critical because:\n    // 1. The on-chain verification expects signatures to be in ascending order by bit position\n    // 2. The bitmap must match the order of signatures when verifying\n    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);\n    signersAndBitPosition.sort((a, b) => a[1] - b[1]);\n\n    // Extract the sorted signers and their positions into separate arrays\n    this.signers = signersAndBitPosition.map((value) => value[0]);\n    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);\n\n    // Create a bitmap representing which public keys from the MultiKey are being used\n    // This bitmap is used during signature verification to identify which public keys\n    // should be used to verify each signature\n    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });\n  }\n\n  /**\n   * Static constructor to create a MultiKeyAccount using the provided public keys and signers.\n   *\n   * @param args - The arguments for creating a MultiKeyAccount.\n   * @param args.publicKeys - The N public keys of the MultiKeyAccount.\n   * @param args.signaturesRequired - The number of signatures required to authorize a transaction.\n   * @param args.signers - An array of M signers that will be used to sign the transaction.\n   * @returns MultiKeyAccount - The newly created MultiKeyAccount.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static fromPublicKeysAndSigners(args: {\n    address?: AccountAddressInput;\n    publicKeys: PublicKey[];\n    signaturesRequired: number;\n    signers: SingleKeySignerOrLegacyEd25519Account[];\n  }): MultiKeyAccount {\n    const { address, publicKeys, signaturesRequired, signers } = args;\n    const multiKey = new MultiKey({ publicKeys, signaturesRequired });\n    return new MultiKeyAccount({ multiKey, signers, address });\n  }\n\n  /**\n   * Determines if the provided account is a multi-key account.\n   *\n   * @param account - The account to check.\n   * @returns A boolean indicating whether the account is a multi-key account.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static isMultiKeySigner(account: Account): account is MultiKeyAccount {\n    return account instanceof MultiKeyAccount;\n  }\n\n  /**\n   * Sign a message using the account's signers and return an AccountAuthenticator containing the signature along with the\n   * account's public key.\n   * @param message - The signing message, represented as binary input in hexadecimal format.\n   * @returns An instance of AccountAuthenticatorMultiKey that includes the signature and the public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));\n  }\n\n  /**\n   * Sign a transaction using the account's signers, returning an AccountAuthenticator that contains the signature and the\n   * account's public key.\n   * @param transaction - The raw transaction to be signed.\n   * @returns An AccountAuthenticatorMultiKey containing the signature of the transaction along with the account's public key.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {\n    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Waits for any proofs on KeylessAccount signers to be fetched. This ensures that signing with the KeylessAccount does not\n   * fail due to missing proofs.\n   * @return {Promise<void>} A promise that resolves when all proofs have been fetched.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  async waitForProofFetch(): Promise<void> {\n    const keylessSigners = this.signers.filter(\n      (signer) => signer instanceof AbstractKeylessAccount,\n    ) as AbstractKeylessAccount[];\n    const promises = keylessSigners.map(async (signer) => signer.waitForProofFetch());\n    await Promise.all(promises);\n  }\n\n  /**\n   * Validates that the Keyless Account can be used to sign transactions.\n   * @return\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  async checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void> {\n    const keylessSigners = this.signers.filter(\n      (signer) => signer instanceof AbstractKeylessAccount,\n    ) as AbstractKeylessAccount[];\n    const promises = keylessSigners.map((signer) => signer.checkKeylessAccountValidity(aptosConfig));\n    await Promise.all(promises);\n  }\n\n  /**\n   * Sign the given message using the MultiKeyAccount's signers\n   * @param data - The data to be signed in HexInput format.\n   * @returns MultiKeySignature\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  sign(data: HexInput): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.sign(data));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Sign the given transaction using the MultiKeyAccount's signers.\n   * This function aggregates signatures from all signers associated with the MultiKeyAccount.\n   *\n   * @param transaction - The transaction to be signed.\n   * @returns MultiKeySignature - An object containing the aggregated signatures and a bitmap of the signatures.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  signTransaction(transaction: AnyRawTransaction): MultiKeySignature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.signTransaction(transaction));\n    }\n    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Verify the given message and signature with the public keys.\n   *\n   * This function checks if the provided signatures are valid for the given message using the corresponding public keys.\n   *\n   * @param args - The arguments for verifying the signature.\n   * @param args.message - The raw message data in HexInput format.\n   * @param args.signature - The signed message MultiKeySignature containing multiple signatures.\n   * @returns A boolean indicating whether the signatures are valid for the message.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {\n    const { message, signature } = args;\n    const isSignerIndicesSorted = this.signerIndicies.every(\n      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],\n    );\n    if (!isSignerIndicesSorted) {\n      return false;\n    }\n    for (let i = 0; i < signature.signatures.length; i += 1) {\n      const singleSignature = signature.signatures[i];\n      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];\n      if (!publicKey.verifySignature({ message, signature: singleSignature })) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-KLUO6XPE.mjs

@@ -1,33 +0,0 @@
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/signature.ts
-var Signature = class extends Serializable {
-  /**
-   * Get the raw signature bytes
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
-   * @returns The hex string representation of the signature.
-   * @group Implementation
-   * @category Serialization
-   */
-  toString() {
-    const bytes = this.toUint8Array();
-    return Hex.fromHexInput(bytes).toString();
-  }
-};
-
-export {
-  Signature
-};
-//# sourceMappingURL=chunk-KLUO6XPE.mjs.map