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

package/dist/esm/chunk-TLNHRJB2.mjs

@@ -1,155 +0,0 @@
-import {
-  KeylessPublicKey,
-  KeylessSignature
-} from "./chunk-4OYYOYSO.mjs";
-import {
-  Secp256k1PublicKey,
-  Secp256k1Signature
-} from "./chunk-DIYZRGR6.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.mjs";
-
-// src/core/crypto/singleKey.ts
-var AnyPublicKey = class _AnyPublicKey extends AccountPublicKey {
-  // region Constructors
-  constructor(publicKey) {
-    super();
-    this.publicKey = publicKey;
-    if (publicKey instanceof Ed25519PublicKey) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (publicKey instanceof Secp256k1PublicKey) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (publicKey instanceof KeylessPublicKey) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported public key type");
-    }
-  }
-  // endregion
-  // region AccountPublicKey
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!(signature instanceof AnySignature)) {
-      return false;
-    }
-    return this.publicKey.verifySignature({
-      message,
-      signature: signature.signature
-    });
-  }
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: this.toUint8Array()
-    });
-  }
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.publicKey.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let publicKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        publicKey = Ed25519PublicKey.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        publicKey = Secp256k1PublicKey.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        publicKey = KeylessPublicKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
-    }
-    return new _AnyPublicKey(publicKey);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof AnyPublicKey` instead.
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _AnyPublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Ed25519PublicKey` instead.
-   */
-  isEd25519() {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-  /**
-   * @deprecated use `publicKey instanceof Secp256k1PublicKey` instead.
-   */
-  isSecp256k1PublicKey() {
-    return this.publicKey instanceof Secp256k1PublicKey;
-  }
-};
-var AnySignature = class _AnySignature extends Signature {
-  // region Constructors
-  constructor(signature) {
-    super();
-    this.signature = signature;
-    if (signature instanceof Ed25519Signature) {
-      this.variant = 0 /* Ed25519 */;
-    } else if (signature instanceof Secp256k1Signature) {
-      this.variant = 1 /* Secp256k1 */;
-    } else if (signature instanceof KeylessSignature) {
-      this.variant = 3 /* Keyless */;
-    } else {
-      throw new Error("Unsupported signature type");
-    }
-  }
-  // endregion
-  // region AccountSignature
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let signature;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        signature = Ed25519Signature.deserialize(deserializer);
-        break;
-      case 1 /* Secp256k1 */:
-        signature = Secp256k1Signature.deserialize(deserializer);
-        break;
-      case 3 /* Keyless */:
-        signature = KeylessSignature.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
-    }
-    return new _AnySignature(signature);
-  }
-  // endregion
-};
-
-export {
-  AnyPublicKey,
-  AnySignature
-};
-//# sourceMappingURL=chunk-TLNHRJB2.mjs.map

package/dist/esm/chunk-U3IUCR2G.mjs

@@ -1,54 +0,0 @@
-import {
-  RawTransaction
-} from "./chunk-2OQW7BMN.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/instances/multiAgentTransaction.ts
-var MultiAgentTransaction = class _MultiAgentTransaction extends Serializable {
-  /**
-   * SimpleTransaction represents a simple transaction type of a single signer that
-   * can be submitted to Aptos chain for execution.
-   *
-   * SimpleTransaction metadata contains the Raw Transaction and an optional
-   * sponsor Account Address to pay the gas fees.
-   *
-   * @param rawTransaction The Raw Tranasaction
-   * @param feePayerAddress The sponsor Account Address
-   */
-  constructor(rawTransaction, secondarySignerAddresses, feePayerAddress) {
-    super();
-    this.rawTransaction = rawTransaction;
-    this.feePayerAddress = feePayerAddress;
-    this.secondarySignerAddresses = secondarySignerAddresses;
-  }
-  serialize(serializer) {
-    this.rawTransaction.serialize(serializer);
-    serializer.serializeVector(this.secondarySignerAddresses);
-    if (this.feePayerAddress === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.feePayerAddress.serialize(serializer);
-    }
-  }
-  static deserialize(deserializer) {
-    const rawTransaction = RawTransaction.deserialize(deserializer);
-    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
-    const feepayerPresent = deserializer.deserializeBool();
-    let feePayerAddress;
-    if (feepayerPresent) {
-      feePayerAddress = AccountAddress.deserialize(deserializer);
-    }
-    return new _MultiAgentTransaction(rawTransaction, secondarySignerAddresses, feePayerAddress);
-  }
-};
-
-export {
-  MultiAgentTransaction
-};
-//# sourceMappingURL=chunk-U3IUCR2G.mjs.map

package/dist/esm/chunk-U7QBZ6PP.mjs

@@ -1,400 +0,0 @@
-import {
-  convertArgument,
-  fetchEntryFunctionAbi,
-  fetchViewFunctionAbi,
-  standardizeTypeTags
-} from "./chunk-CXUGZXED.mjs";
-import {
-  getFunctionParts,
-  isScriptDataInput
-} from "./chunk-ZMFKQUHL.mjs";
-import {
-  getInfo
-} from "./chunk-Y2LV3S5W.mjs";
-import {
-  getGasPriceEstimation
-} from "./chunk-TBHU6ZW6.mjs";
-import {
-  memoizeAsync
-} from "./chunk-EYHRMZPO.mjs";
-import {
-  getLedgerInfo
-} from "./chunk-LYMY63SO.mjs";
-import {
-  normalizeBundle
-} from "./chunk-QBBTUC66.mjs";
-import {
-  NetworkToChainId
-} from "./chunk-7REUIYF4.mjs";
-import {
-  MultiAgentTransaction
-} from "./chunk-U3IUCR2G.mjs";
-import {
-  SignedTransaction
-} from "./chunk-ATVFVXR6.mjs";
-import {
-  SimpleTransaction
-} from "./chunk-VPWUODU4.mjs";
-import {
-  FeePayerRawTransaction,
-  MultiAgentRawTransaction,
-  RawTransaction
-} from "./chunk-2OQW7BMN.mjs";
-import {
-  EntryFunction,
-  MultiSig,
-  MultiSigTransactionPayload,
-  Script,
-  TransactionPayloadEntryFunction,
-  TransactionPayloadMultiSig,
-  TransactionPayloadScript
-} from "./chunk-QFOG4LIN.mjs";
-import {
-  TransactionAuthenticatorEd25519,
-  TransactionAuthenticatorFeePayer,
-  TransactionAuthenticatorMultiAgent,
-  TransactionAuthenticatorSingleSender
-} from "./chunk-ASF2VWOX.mjs";
-import {
-  AccountAuthenticator,
-  AccountAuthenticatorEd25519,
-  AccountAuthenticatorSingleKey
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  ChainId
-} from "./chunk-6MSZMIFW.mjs";
-import {
-  DEFAULT_MAX_GAS_AMOUNT,
-  DEFAULT_TXN_EXP_SEC_FROM_NOW
-} from "./chunk-NFJCQRVK.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-TLNHRJB2.mjs";
-import {
-  Secp256k1PublicKey,
-  Secp256k1Signature
-} from "./chunk-DIYZRGR6.mjs";
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/transactions/transactionBuilder/transactionBuilder.ts
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-async function generateTransactionPayload(args) {
-  if (isScriptDataInput(args)) {
-    return generateTransactionPayloadScript(args);
-  }
-  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
-  const functionAbi = await fetchAbi({
-    key: "entry-function",
-    moduleAddress,
-    moduleName,
-    functionName,
-    aptosConfig: args.aptosConfig,
-    abi: args.abi,
-    fetch: fetchEntryFunctionAbi
-  });
-  return generateTransactionPayloadWithABI({ ...args, abi: functionAbi });
-}
-function generateTransactionPayloadWithABI(args) {
-  const functionAbi = args.abi;
-  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
-  const typeArguments = standardizeTypeTags(args.typeArguments);
-  if (typeArguments.length !== functionAbi.typeParameters.length) {
-    throw new Error(
-      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
-    );
-  }
-  const functionArguments = args.functionArguments.map(
-    (arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments)
-  );
-  if (functionArguments.length !== functionAbi.parameters.length) {
-    throw new Error(
-      // eslint-disable-next-line max-len
-      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`
-    );
-  }
-  const entryFunctionPayload = EntryFunction.build(
-    `${moduleAddress}::${moduleName}`,
-    functionName,
-    typeArguments,
-    functionArguments
-  );
-  if ("multisigAddress" in args) {
-    const multisigAddress = AccountAddress.from(args.multisigAddress);
-    return new TransactionPayloadMultiSig(
-      new MultiSig(multisigAddress, new MultiSigTransactionPayload(entryFunctionPayload))
-    );
-  }
-  return new TransactionPayloadEntryFunction(entryFunctionPayload);
-}
-async function generateViewFunctionPayload(args) {
-  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
-  const functionAbi = await fetchAbi({
-    key: "view-function",
-    moduleAddress,
-    moduleName,
-    functionName,
-    aptosConfig: args.aptosConfig,
-    abi: args.abi,
-    fetch: fetchViewFunctionAbi
-  });
-  return generateViewFunctionPayloadWithABI({ abi: functionAbi, ...args });
-}
-function generateViewFunctionPayloadWithABI(args) {
-  const functionAbi = args.abi;
-  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
-  const typeArguments = standardizeTypeTags(args.typeArguments);
-  if (typeArguments.length !== functionAbi.typeParameters.length) {
-    throw new Error(
-      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
-    );
-  }
-  const functionArguments = args?.functionArguments?.map((arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments)) ?? [];
-  if (functionArguments.length !== functionAbi.parameters.length) {
-    throw new Error(
-      // eslint-disable-next-line max-len
-      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`
-    );
-  }
-  return EntryFunction.build(`${moduleAddress}::${moduleName}`, functionName, typeArguments, functionArguments);
-}
-function generateTransactionPayloadScript(args) {
-  return new TransactionPayloadScript(
-    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), args.typeArguments ?? [], args.functionArguments)
-  );
-}
-async function generateRawTransaction(args) {
-  const { aptosConfig, sender, payload, options, feePayerAddress } = args;
-  const getChainId = async () => {
-    if (NetworkToChainId[aptosConfig.network]) {
-      return { chainId: NetworkToChainId[aptosConfig.network] };
-    }
-    const info = await getLedgerInfo({ aptosConfig });
-    return { chainId: info.chain_id };
-  };
-  const getGasUnitPrice = async () => {
-    if (options?.gasUnitPrice) {
-      return { gasEstimate: options.gasUnitPrice };
-    }
-    const estimation = await getGasPriceEstimation({ aptosConfig });
-    return { gasEstimate: estimation.gas_estimate };
-  };
-  const getSequenceNumberForAny = async () => {
-    const getSequenceNumber = async () => {
-      if (options?.accountSequenceNumber !== void 0) {
-        return options.accountSequenceNumber;
-      }
-      return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;
-    };
-    if (feePayerAddress && AccountAddress.from(feePayerAddress).equals(AccountAddress.ZERO)) {
-      try {
-        return await getSequenceNumber();
-      } catch (e) {
-        return 0;
-      }
-    } else {
-      return getSequenceNumber();
-    }
-  };
-  const [{ chainId }, { gasEstimate }, sequenceNumber] = await Promise.all([
-    getChainId(),
-    getGasUnitPrice(),
-    getSequenceNumberForAny()
-  ]);
-  const { maxGasAmount, gasUnitPrice, expireTimestamp } = {
-    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),
-    gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),
-    expireTimestamp: options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_TXN_EXP_SEC_FROM_NOW)
-  };
-  return new RawTransaction(
-    AccountAddress.from(sender),
-    BigInt(sequenceNumber),
-    payload,
-    BigInt(maxGasAmount),
-    BigInt(gasUnitPrice),
-    BigInt(expireTimestamp),
-    new ChainId(chainId)
-  );
-}
-async function buildTransaction(args) {
-  const { aptosConfig, sender, payload, options, feePayerAddress } = args;
-  const rawTxn = await generateRawTransaction({
-    aptosConfig,
-    sender,
-    payload,
-    options,
-    feePayerAddress
-  });
-  if ("secondarySignerAddresses" in args) {
-    const signers = args.secondarySignerAddresses?.map((signer) => AccountAddress.from(signer)) ?? [];
-    return new MultiAgentTransaction(
-      rawTxn,
-      signers,
-      args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : void 0
-    );
-  }
-  return new SimpleTransaction(rawTxn, args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : void 0);
-}
-function generateSignedTransactionForSimulation(args) {
-  const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;
-  const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);
-  if (transaction.feePayerAddress) {
-    const transactionToSign = new FeePayerRawTransaction(
-      transaction.rawTransaction,
-      transaction.secondarySignerAddresses ?? [],
-      transaction.feePayerAddress
-    );
-    let secondaryAccountAuthenticators = [];
-    if (secondarySignersPublicKeys) {
-      secondaryAccountAuthenticators = secondarySignersPublicKeys.map(
-        (publicKey) => getAuthenticatorForSimulation(publicKey)
-      );
-    }
-    const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey);
-    const transactionAuthenticator2 = new TransactionAuthenticatorFeePayer(
-      accountAuthenticator,
-      transaction.secondarySignerAddresses ?? [],
-      secondaryAccountAuthenticators,
-      {
-        address: transaction.feePayerAddress,
-        authenticator: feePayerAuthenticator
-      }
-    );
-    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator2).bcsToBytes();
-  }
-  if (transaction.secondarySignerAddresses) {
-    const transactionToSign = new MultiAgentRawTransaction(
-      transaction.rawTransaction,
-      transaction.secondarySignerAddresses
-    );
-    let secondaryAccountAuthenticators = [];
-    secondaryAccountAuthenticators = secondarySignersPublicKeys.map(
-      (publicKey) => getAuthenticatorForSimulation(publicKey)
-    );
-    const transactionAuthenticator2 = new TransactionAuthenticatorMultiAgent(
-      accountAuthenticator,
-      transaction.secondarySignerAddresses,
-      secondaryAccountAuthenticators
-    );
-    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator2).bcsToBytes();
-  }
-  let transactionAuthenticator;
-  if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {
-    transactionAuthenticator = new TransactionAuthenticatorEd25519(
-      accountAuthenticator.public_key,
-      accountAuthenticator.signature
-    );
-  } else if (accountAuthenticator instanceof AccountAuthenticatorSingleKey) {
-    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);
-  } else {
-    throw new Error("Invalid public key");
-  }
-  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();
-}
-function getAuthenticatorForSimulation(publicKey) {
-  if (publicKey instanceof AnyPublicKey) {
-    if (publicKey.publicKey instanceof Ed25519PublicKey) {
-      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
-    }
-    if (publicKey.publicKey instanceof Secp256k1PublicKey) {
-      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
-    }
-  }
-  return new AccountAuthenticatorEd25519(
-    new Ed25519PublicKey(publicKey.toUint8Array()),
-    new Ed25519Signature(new Uint8Array(64))
-  );
-}
-function generateSignedTransaction(args) {
-  const { transaction, feePayerAuthenticator, additionalSignersAuthenticators } = args;
-  const senderAuthenticator = normalizeBundle(AccountAuthenticator, args.senderAuthenticator);
-  let txnAuthenticator;
-  if (transaction.feePayerAddress) {
-    if (!feePayerAuthenticator) {
-      throw new Error("Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction");
-    }
-    txnAuthenticator = new TransactionAuthenticatorFeePayer(
-      senderAuthenticator,
-      transaction.secondarySignerAddresses ?? [],
-      additionalSignersAuthenticators ?? [],
-      {
-        address: transaction.feePayerAddress,
-        authenticator: feePayerAuthenticator
-      }
-    );
-  } else if (transaction.secondarySignerAddresses) {
-    if (!additionalSignersAuthenticators) {
-      throw new Error(
-        "Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction"
-      );
-    }
-    txnAuthenticator = new TransactionAuthenticatorMultiAgent(
-      senderAuthenticator,
-      transaction.secondarySignerAddresses,
-      additionalSignersAuthenticators
-    );
-  } else if (senderAuthenticator instanceof AccountAuthenticatorEd25519) {
-    txnAuthenticator = new TransactionAuthenticatorEd25519(
-      senderAuthenticator.public_key,
-      senderAuthenticator.signature
-    );
-  } else {
-    txnAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);
-  }
-  return new SignedTransaction(transaction.rawTransaction, txnAuthenticator).bcsToBytes();
-}
-function hashValues(input) {
-  const hash = sha3Hash.create();
-  for (const item of input) {
-    hash.update(item);
-  }
-  return hash.digest();
-}
-var TRANSACTION_PREFIX = hashValues(["APTOS::Transaction"]);
-function generateUserTransactionHash(args) {
-  const signedTransaction = generateSignedTransaction(args);
-  return new Hex(hashValues([TRANSACTION_PREFIX, new Uint8Array([0]), signedTransaction])).toString();
-}
-async function fetchAbi({
-  key,
-  moduleAddress,
-  moduleName,
-  functionName,
-  aptosConfig,
-  abi,
-  fetch
-}) {
-  if (abi !== void 0) {
-    return abi;
-  }
-  return memoizeAsync(
-    async () => fetch(moduleAddress, moduleName, functionName, aptosConfig),
-    `${key}-${aptosConfig.network}-${moduleAddress}-${moduleName}-${functionName}`,
-    1e3 * 60 * 5
-    // 5 minutes
-  )();
-}
-
-export {
-  generateTransactionPayload,
-  generateTransactionPayloadWithABI,
-  generateViewFunctionPayload,
-  generateViewFunctionPayloadWithABI,
-  generateRawTransaction,
-  buildTransaction,
-  generateSignedTransactionForSimulation,
-  getAuthenticatorForSimulation,
-  generateSignedTransaction,
-  hashValues,
-  generateUserTransactionHash
-};
-//# sourceMappingURL=chunk-U7QBZ6PP.mjs.map

package/dist/esm/chunk-UEBBLQJ5.mjs

@@ -1,94 +0,0 @@
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/authenticationKey.ts
-import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
-var _AuthenticationKey = class _AuthenticationKey extends Serializable {
-  constructor(args) {
-    super();
-    const { data } = args;
-    const hex = Hex.fromHexInput(data);
-    if (hex.toUint8Array().length !== _AuthenticationKey.LENGTH) {
-      throw new Error(`Authentication Key length should be ${_AuthenticationKey.LENGTH}`);
-    }
-    this.data = hex;
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.data.toUint8Array());
-  }
-  /**
-   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
-   * @param deserializer The deserializer to deserialize the AuthenticationKey from.
-   * @returns An instance of AuthenticationKey.
-   */
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeFixedBytes(_AuthenticationKey.LENGTH);
-    return new _AuthenticationKey({ data: bytes });
-  }
-  toString() {
-    return this.data.toString();
-  }
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  static fromSchemeAndBytes(args) {
-    const { scheme, input } = args;
-    const inputBytes = Hex.fromHexInput(input).toUint8Array();
-    const hashInput = new Uint8Array([...inputBytes, scheme]);
-    const hash = sha3Hash.create();
-    hash.update(hashInput);
-    const hashDigest = hash.digest();
-    return new _AuthenticationKey({ data: hashDigest });
-  }
-  /**
-   * @deprecated Use `fromPublicKey` instead
-   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
-   *
-   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
-   *
-   * @param args - the public key and scheme to use for the derivation
-   */
-  static fromPublicKeyAndScheme(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the
-   * instance of the PublicKey type passed in.
-   *
-   * @param args.publicKey
-   * @returns AuthenticationKey
-   */
-  static fromPublicKey(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,
-   * the AuthenticationKey bytes are directly translated to an AccountAddress.
-   *
-   * @returns AccountAddress
-   */
-  derivedAddress() {
-    return new AccountAddress(this.data.toUint8Array());
-  }
-};
-/**
- * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
- *
- * The data to hash depends on the underlying public key type and the derivation scheme.
- */
-_AuthenticationKey.LENGTH = 32;
-var AuthenticationKey = _AuthenticationKey;
-
-export {
-  AuthenticationKey
-};
-//# sourceMappingURL=chunk-UEBBLQJ5.mjs.map