@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.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-JXCZTOYC.mjs

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

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-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