@aptos-labs/ts-sdk 1.13.3 → 1.14.0-zeta.1

package/dist/esm/chunk-U7QBZ6PP.mjs

@@ -0,0 +1,400 @@
+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-U7QBZ6PP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/transactionBuilder/transactionBuilder.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file handles the transaction creation lifecycle.\n * It holds different operations to generate a transaction payload, a raw transaction,\n * and a signed transaction that can be simulated, signed and submitted to chain.\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput, Hex, PublicKey } from \"../../core\";\nimport { AnyPublicKey, AnySignature, Secp256k1PublicKey, Secp256k1Signature } from \"../../core/crypto\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"../../core/crypto/ed25519\";\nimport { getInfo } from \"../../internal/account\";\nimport { getLedgerInfo } from \"../../internal/general\";\nimport { getGasPriceEstimation } from \"../../internal/transaction\";\nimport { NetworkToChainId } from \"../../utils/apiEndpoints\";\nimport { DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW } from \"../../utils/const\";\nimport { normalizeBundle } from \"../../utils/normalizeBundle\";\nimport {\n  AccountAuthenticator,\n  AccountAuthenticatorEd25519,\n  AccountAuthenticatorSingleKey,\n} from \"../authenticator/account\";\nimport {\n  TransactionAuthenticator,\n  TransactionAuthenticatorEd25519,\n  TransactionAuthenticatorFeePayer,\n  TransactionAuthenticatorMultiAgent,\n  TransactionAuthenticatorSingleSender,\n} from \"../authenticator/transaction\";\nimport {\n  ChainId,\n  EntryFunction,\n  FeePayerRawTransaction,\n  MultiAgentRawTransaction,\n  MultiSig,\n  MultiSigTransactionPayload,\n  RawTransaction,\n  Script,\n  TransactionPayloadEntryFunction,\n  TransactionPayloadMultiSig,\n  TransactionPayloadScript,\n} from \"../instances\";\nimport { SignedTransaction } from \"../instances/signedTransaction\";\nimport {\n  AnyRawTransaction,\n  AnyTransactionPayloadInstance,\n  EntryFunctionArgumentTypes,\n  InputGenerateMultiAgentRawTransactionArgs,\n  InputGenerateRawTransactionArgs,\n  InputGenerateSingleSignerRawTransactionArgs,\n  InputGenerateTransactionOptions,\n  InputScriptData,\n  InputSimulateTransactionData,\n  InputMultiSigDataWithRemoteABI,\n  InputEntryFunctionDataWithRemoteABI,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputSubmitTransactionData,\n  InputGenerateTransactionPayloadDataWithABI,\n  InputEntryFunctionDataWithABI,\n  InputMultiSigDataWithABI,\n  InputViewFunctionDataWithRemoteABI,\n  InputViewFunctionDataWithABI,\n  FunctionABI,\n} from \"../types\";\nimport { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from \"./remoteAbi\";\nimport { memoizeAsync } from \"../../utils/memoize\";\nimport { getFunctionParts, isScriptDataInput } from \"./helpers\";\nimport { SimpleTransaction } from \"../instances/simpleTransaction\";\nimport { MultiAgentTransaction } from \"../instances/multiAgentTransaction\";\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for our `generateTransactionPayload` function.\n * When we call our `generateTransactionPayload` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n */\nexport async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;\nexport async function generateTransactionPayload(\n  args: InputEntryFunctionDataWithRemoteABI,\n): Promise<TransactionPayloadEntryFunction>;\nexport async function generateTransactionPayload(\n  args: InputMultiSigDataWithRemoteABI,\n): Promise<TransactionPayloadMultiSig>;\n\n/**\n * Builds a transaction payload based on the data argument and returns\n * a transaction payload - TransactionPayloadScript | TransactionPayloadMultiSig | TransactionPayloadEntryFunction\n *\n * This uses the RemoteABI by default, and the remote ABI can be skipped by using generateTransactionPayloadWithABI\n *\n * @param args.data GenerateTransactionPayloadData\n *\n * @return TransactionPayload\n */\nexport async function generateTransactionPayload(\n  args: InputGenerateTransactionPayloadDataWithRemoteABI,\n): Promise<AnyTransactionPayloadInstance> {\n  if (isScriptDataInput(args)) {\n    return generateTransactionPayloadScript(args);\n  }\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  const functionAbi = await fetchAbi({\n    key: \"entry-function\",\n    moduleAddress,\n    moduleName,\n    functionName,\n    aptosConfig: args.aptosConfig,\n    abi: args.abi,\n    fetch: fetchEntryFunctionAbi,\n  });\n\n  // Fill in the ABI\n  return generateTransactionPayloadWithABI({ ...args, abi: functionAbi });\n}\n\nexport function generateTransactionPayloadWithABI(args: InputEntryFunctionDataWithABI): TransactionPayloadEntryFunction;\nexport function generateTransactionPayloadWithABI(args: InputMultiSigDataWithABI): TransactionPayloadMultiSig;\nexport function generateTransactionPayloadWithABI(\n  args: InputGenerateTransactionPayloadDataWithABI,\n): AnyTransactionPayloadInstance {\n  const functionAbi = args.abi;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // Ensure that all type arguments are typed properly\n  const typeArguments = standardizeTypeTags(args.typeArguments);\n\n  // Check the type argument count against the ABI\n  if (typeArguments.length !== functionAbi.typeParameters.length) {\n    throw new Error(\n      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n    );\n  }\n\n  // Check all BCS types, and convert any non-BCS types\n  const functionArguments: Array<EntryFunctionArgumentTypes> = args.functionArguments.map((arg, i) =>\n    convertArgument(args.function, functionAbi, arg, i, typeArguments),\n  );\n\n  // Check that all arguments are accounted for\n  if (functionArguments.length !== functionAbi.parameters.length) {\n    throw new Error(\n      // eslint-disable-next-line max-len\n      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,\n    );\n  }\n\n  // Generate entry function payload\n  const entryFunctionPayload = EntryFunction.build(\n    `${moduleAddress}::${moduleName}`,\n    functionName,\n    typeArguments,\n    functionArguments,\n  );\n\n  // Send it as multi sig if it's a multisig payload\n  if (\"multisigAddress\" in args) {\n    const multisigAddress = AccountAddress.from(args.multisigAddress);\n    return new TransactionPayloadMultiSig(\n      new MultiSig(multisigAddress, new MultiSigTransactionPayload(entryFunctionPayload)),\n    );\n  }\n\n  // Otherwise send as an entry function\n  return new TransactionPayloadEntryFunction(entryFunctionPayload);\n}\n\nexport async function generateViewFunctionPayload(args: InputViewFunctionDataWithRemoteABI): Promise<EntryFunction> {\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  const functionAbi = await fetchAbi({\n    key: \"view-function\",\n    moduleAddress,\n    moduleName,\n    functionName,\n    aptosConfig: args.aptosConfig,\n    abi: args.abi,\n    fetch: fetchViewFunctionAbi,\n  });\n\n  // Fill in the ABI\n  return generateViewFunctionPayloadWithABI({ abi: functionAbi, ...args });\n}\n\nexport function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWithABI): EntryFunction {\n  const functionAbi = args.abi;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // Ensure that all type arguments are typed properly\n  const typeArguments = standardizeTypeTags(args.typeArguments);\n\n  // Check the type argument count against the ABI\n  if (typeArguments.length !== functionAbi.typeParameters.length) {\n    throw new Error(\n      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n    );\n  }\n\n  // Check all BCS types, and convert any non-BCS types\n  const functionArguments: Array<EntryFunctionArgumentTypes> =\n    args?.functionArguments?.map((arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments)) ?? [];\n\n  // Check that all arguments are accounted for\n  if (functionArguments.length !== functionAbi.parameters.length) {\n    throw new Error(\n      // eslint-disable-next-line max-len\n      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,\n    );\n  }\n\n  // Generate entry function payload\n  return EntryFunction.build(`${moduleAddress}::${moduleName}`, functionName, typeArguments, functionArguments);\n}\n\nfunction generateTransactionPayloadScript(args: InputScriptData) {\n  return new TransactionPayloadScript(\n    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), args.typeArguments ?? [], args.functionArguments),\n  );\n}\n\n/**\n * Generates a raw transaction\n *\n * @param args.aptosConfig AptosConfig\n * @param args.sender The transaction's sender account address as a hex input\n * @param args.payload The transaction payload - can create by using generateTransactionPayload()\n *\n * @returns RawTransaction\n */\nexport async function generateRawTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  payload: AnyTransactionPayloadInstance;\n  options?: InputGenerateTransactionOptions;\n  feePayerAddress?: AccountAddressInput;\n}): Promise<RawTransaction> {\n  const { aptosConfig, sender, payload, options, feePayerAddress } = args;\n\n  const getChainId = async () => {\n    if (NetworkToChainId[aptosConfig.network]) {\n      return { chainId: NetworkToChainId[aptosConfig.network] };\n    }\n    const info = await getLedgerInfo({ aptosConfig });\n    return { chainId: info.chain_id };\n  };\n\n  const getGasUnitPrice = async () => {\n    if (options?.gasUnitPrice) {\n      return { gasEstimate: options.gasUnitPrice };\n    }\n    const estimation = await getGasPriceEstimation({ aptosConfig });\n    return { gasEstimate: estimation.gas_estimate };\n  };\n\n  const getSequenceNumberForAny = async () => {\n    const getSequenceNumber = async () => {\n      if (options?.accountSequenceNumber !== undefined) {\n        return options.accountSequenceNumber;\n      }\n\n      return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;\n    };\n\n    /**\n     * Check if is sponsored transaction to honor AIP-52\n     * {@link https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-52.md}\n     */\n    if (feePayerAddress && AccountAddress.from(feePayerAddress).equals(AccountAddress.ZERO)) {\n      // Handle sponsored transaction generation with the option that\n      // the main signer has not been created on chain\n      try {\n        // Check if main signer has been created on chain, if not assign sequence number 0\n        return await getSequenceNumber();\n      } catch (e: any) {\n        return 0;\n      }\n    } else {\n      return getSequenceNumber();\n    }\n  };\n  const [{ chainId }, { gasEstimate }, sequenceNumber] = await Promise.all([\n    getChainId(),\n    getGasUnitPrice(),\n    getSequenceNumberForAny(),\n  ]);\n\n  const { maxGasAmount, gasUnitPrice, expireTimestamp } = {\n    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),\n    gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),\n    expireTimestamp: options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + DEFAULT_TXN_EXP_SEC_FROM_NOW),\n  };\n\n  return new RawTransaction(\n    AccountAddress.from(sender),\n    BigInt(sequenceNumber),\n    payload,\n    BigInt(maxGasAmount),\n    BigInt(gasUnitPrice),\n    BigInt(expireTimestamp),\n    new ChainId(chainId),\n  );\n}\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for our `generateTransaction` function.\n * When we call our `generateTransaction` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n */\nexport async function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<SimpleTransaction>;\nexport async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;\n\n/**\n * Generates a transaction based on the provided arguments\n *\n * Note: we can start with one function to support all different payload/transaction types,\n * and if to complex to use, we could have function for each type\n *\n * @param args.aptosConfig AptosConfig\n * @param args.sender The transaction's sender account address as a hex input\n * @param args.payload The transaction payload - can create by using generateTransactionPayload()\n * @param args.options optional. Transaction options object\n * @param args.secondarySignerAddresses optional. For when want to create a multi signers transaction\n * @param args.feePayerAddress optional. For when want to create a fee payer (aka sponsored) transaction\n *\n * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses\n * ```\n * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses? : Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n */\nexport async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction> {\n  const { aptosConfig, sender, payload, options, feePayerAddress } = args;\n  // generate raw transaction\n  const rawTxn = await generateRawTransaction({\n    aptosConfig,\n    sender,\n    payload,\n    options,\n    feePayerAddress,\n  });\n\n  // if multi agent transaction\n  if (\"secondarySignerAddresses\" in args) {\n    const signers: Array<AccountAddress> =\n      args.secondarySignerAddresses?.map((signer) => AccountAddress.from(signer)) ?? [];\n\n    return new MultiAgentTransaction(\n      rawTxn,\n      signers,\n      args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,\n    );\n  }\n  // return the raw transaction\n  return new SimpleTransaction(rawTxn, args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined);\n}\n\n/**\n * Simulate a transaction before signing and submit to chain\n *\n * @param args.transaction A aptos transaction type to sign\n * @param args.signerPublicKey The signer public key\n * @param args.secondarySignersPublicKeys optional. The secondary signers public keys if multi signers transaction\n * @param args.feePayerPublicKey optional. The fee payer public key is a fee payer (aka sponsored) transaction\n * @param args.options optional. SimulateTransactionOptions\n *\n * @returns A signed serialized transaction that can be simulated\n */\nexport function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {\n  const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;\n\n  const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);\n\n  // fee payer transaction\n  if (transaction.feePayerAddress) {\n    const transactionToSign = new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n    if (secondarySignersPublicKeys) {\n      secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n        getAuthenticatorForSimulation(publicKey),\n      );\n    }\n    const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey!);\n\n    const transactionAuthenticator = new TransactionAuthenticatorFeePayer(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses ?? [],\n      secondaryAccountAuthenticators,\n      {\n        address: transaction.feePayerAddress,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // multi agent transaction\n  if (transaction.secondarySignerAddresses) {\n    const transactionToSign = new MultiAgentRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses,\n    );\n\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n\n    secondaryAccountAuthenticators = secondarySignersPublicKeys!.map((publicKey) =>\n      getAuthenticatorForSimulation(publicKey),\n    );\n\n    const transactionAuthenticator = new TransactionAuthenticatorMultiAgent(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses,\n      secondaryAccountAuthenticators,\n    );\n\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // single signer raw transaction\n  let transactionAuthenticator;\n  if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {\n    transactionAuthenticator = new TransactionAuthenticatorEd25519(\n      accountAuthenticator.public_key,\n      accountAuthenticator.signature,\n    );\n  } else if (accountAuthenticator instanceof AccountAuthenticatorSingleKey) {\n    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);\n  } else {\n    throw new Error(\"Invalid public key\");\n  }\n  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();\n}\n\nexport function getAuthenticatorForSimulation(publicKey: PublicKey) {\n  // TODO add support for AnyMultiKey\n  if (publicKey instanceof AnyPublicKey) {\n    if (publicKey.publicKey instanceof Ed25519PublicKey) {\n      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));\n    }\n    if (publicKey.publicKey instanceof Secp256k1PublicKey) {\n      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));\n    }\n  }\n\n  // legacy code\n  return new AccountAuthenticatorEd25519(\n    new Ed25519PublicKey(publicKey.toUint8Array()),\n    new Ed25519Signature(new Uint8Array(64)),\n  );\n}\n\n/**\n * Prepare a transaction to be submitted to chain\n *\n * @param args.transaction A aptos transaction type\n * @param args.senderAuthenticator The account authenticator of the transaction sender\n * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction\n *\n * @returns A SignedTransaction\n */\nexport function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array {\n  const { transaction, feePayerAuthenticator, additionalSignersAuthenticators } = args;\n  const senderAuthenticator = normalizeBundle(AccountAuthenticator, args.senderAuthenticator);\n\n  let txnAuthenticator: TransactionAuthenticator;\n  if (transaction.feePayerAddress) {\n    if (!feePayerAuthenticator) {\n      throw new Error(\"Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction\");\n    }\n    txnAuthenticator = new TransactionAuthenticatorFeePayer(\n      senderAuthenticator,\n      transaction.secondarySignerAddresses ?? [],\n      additionalSignersAuthenticators ?? [],\n      {\n        address: transaction.feePayerAddress,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n  } else if (transaction.secondarySignerAddresses) {\n    if (!additionalSignersAuthenticators) {\n      throw new Error(\n        \"Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction\",\n      );\n    }\n    txnAuthenticator = new TransactionAuthenticatorMultiAgent(\n      senderAuthenticator,\n      transaction.secondarySignerAddresses,\n      additionalSignersAuthenticators,\n    );\n  } else if (senderAuthenticator instanceof AccountAuthenticatorEd25519) {\n    txnAuthenticator = new TransactionAuthenticatorEd25519(\n      senderAuthenticator.public_key,\n      senderAuthenticator.signature,\n    );\n  } else {\n    txnAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);\n  }\n\n  return new SignedTransaction(transaction.rawTransaction, txnAuthenticator).bcsToBytes();\n}\n\n/**\n * Hashes the set of values with a SHA-3 256 hash\n * @param input array of UTF-8 strings or Uint8array byte arrays\n */\nexport function hashValues(input: (Uint8Array | string)[]): Uint8Array {\n  const hash = sha3Hash.create();\n  for (const item of input) {\n    hash.update(item);\n  }\n  return hash.digest();\n}\n\n/**\n * The domain separated prefix for hashing transacitons\n */\nconst TRANSACTION_PREFIX = hashValues([\"APTOS::Transaction\"]);\n\n/**\n * Generates a user transaction hash for the given transaction payload.  It must already have an authenticator\n * @param args InputSubmitTransactionData\n */\nexport function generateUserTransactionHash(args: InputSubmitTransactionData): string {\n  const signedTransaction = generateSignedTransaction(args);\n\n  // Transaction signature is defined as, the domain separated prefix based on struct (Transaction)\n  // Then followed by the type of the transaction for the enum, UserTransaction is 0\n  // Then followed by BCS encoded bytes of the signed transaction\n  return new Hex(hashValues([TRANSACTION_PREFIX, new Uint8Array([0]), signedTransaction])).toString();\n}\n\n/**\n * Fetches and caches ABIs with allowing for pass-through on provided ABIs\n * @param key\n * @param moduleAddress\n * @param moduleName\n * @param functionName\n * @param aptosConfig\n * @param abi\n * @param fetch\n */\nasync function fetchAbi<T extends FunctionABI>({\n  key,\n  moduleAddress,\n  moduleName,\n  functionName,\n  aptosConfig,\n  abi,\n  fetch,\n}: {\n  key: string;\n  moduleAddress: string;\n  moduleName: string;\n  functionName: string;\n  aptosConfig: AptosConfig;\n  abi?: T;\n  fetch: (moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig) => Promise<T>;\n}): Promise<T> {\n  if (abi !== undefined) {\n    return abi;\n  }\n\n  // We fetch the entry function ABI, and then pretend that we already had the ABI\n  return memoizeAsync(\n    async () => fetch(moduleAddress, moduleName, functionName, aptosConfig),\n    `${key}-${aptosConfig.network}-${moduleAddress}-${moduleName}-${functionName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n"],"mappings":"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","names":["transactionAuthenticator"]}

package/dist/esm/chunk-UEBBLQJ5.mjs

@@ -0,0 +1,94 @@
+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

package/dist/esm/{chunk-NPFNYP75.mjs.map → chunk-UEBBLQJ5.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/authenticationKey.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"./accountAddress\";\nimport type { AccountPublicKey } from \"./crypto\";\nimport { Hex } from \"./hex\";\nimport { AuthenticationKeyScheme, HexInput } from \"../types\";\nimport { Serializable, Serializer } from \"../bcs/serializer\";\nimport { Deserializer } from \"../bcs/deserializer\";\n\n/**\n * Each account stores an authentication key. Authentication key enables account owners to rotate\n * their private key(s) associated with the account without changing the address that hosts their account.\n * @see {@link https://aptos.dev/concepts/accounts | Account Basics}\n *\n * Account addresses can be derived from AuthenticationKey\n */\nexport class AuthenticationKey extends Serializable {\n  /**\n   * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.\n   *\n   * The data to hash depends on the underlying public key type and the derivation scheme.\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The raw bytes of the authentication key.\n   */\n  public readonly data: Hex;\n\n  constructor(args: { data: HexInput }) {\n    super();\n    const { data } = args;\n    const hex = Hex.fromHexInput(data);\n    if (hex.toUint8Array().length !== AuthenticationKey.LENGTH) {\n      throw new Error(`Authentication Key length should be ${AuthenticationKey.LENGTH}`);\n    }\n    this.data = hex;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data.toUint8Array());\n  }\n\n  /**\n   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.\n   * @param deserializer The deserializer to deserialize the AuthenticationKey from.\n   * @returns An instance of AuthenticationKey.\n   */\n  static deserialize(deserializer: Deserializer): AuthenticationKey {\n    const bytes = deserializer.deserializeFixedBytes(AuthenticationKey.LENGTH);\n    return new AuthenticationKey({ data: bytes });\n  }\n\n  toString(): string {\n    return this.data.toString();\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  static fromSchemeAndBytes(args: { scheme: AuthenticationKeyScheme; input: HexInput }): AuthenticationKey {\n    const { scheme, input } = args;\n    const inputBytes = Hex.fromHexInput(input).toUint8Array();\n    const hashInput = new Uint8Array([...inputBytes, scheme]);\n    const hash = sha3Hash.create();\n    hash.update(hashInput);\n    const hashDigest = hash.digest();\n    return new AuthenticationKey({ data: hashDigest });\n  }\n\n  /**\n   * @deprecated Use `fromPublicKey` instead\n   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.\n   *\n   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.\n   *\n   * @param args - the public key and scheme to use for the derivation\n   */\n  public static fromPublicKeyAndScheme(args: { publicKey: AccountPublicKey; scheme: AuthenticationKeyScheme }) {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the\n   * instance of the PublicKey type passed in.\n   *\n   * @param args.publicKey\n   * @returns AuthenticationKey\n   */\n  static fromPublicKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,\n   * the AuthenticationKey bytes are directly translated to an AccountAddress.\n   *\n   * @returns AccountAddress\n   */\n  derivedAddress(): AccountAddress {\n    return new AccountAddress(this.data.toUint8Array());\n  }\n}\n"],"mappings":"2HAGA,OAAS,YAAYA,MAAgB,qBAe9B,IAAMC,EAAN,MAAMA,UAA0BC,CAAa,CAalD,YAAYC,EAA0B,CACpC,MAAM,EACN,GAAM,CAAE,KAAAC,CAAK,EAAID,EACXE,EAAMC,EAAI,aAAaF,CAAI,EACjC,GAAIC,EAAI,aAAa,EAAE,SAAWJ,EAAkB,OAClD,MAAM,IAAI,MAAM,uCAAuCA,EAAkB,MAAM,EAAE,EAEnF,KAAK,KAAOI,CACd,CAEA,UAAUE,EAA8B,CACtCA,EAAW,oBAAoB,KAAK,KAAK,aAAa,CAAC,CACzD,CAOA,OAAO,YAAYC,EAA+C,CAChE,IAAMC,EAAQD,EAAa,sBAAsBP,EAAkB,MAAM,EACzE,OAAO,IAAIA,EAAkB,CAAE,KAAMQ,CAAM,CAAC,CAC9C,CAEA,UAAmB,CACjB,OAAO,KAAK,KAAK,SAAS,CAC5B,CAEA,cAA2B,CACzB,OAAO,KAAK,KAAK,aAAa,CAChC,CAEA,OAAO,mBAAmBN,EAA+E,CACvG,GAAM,CAAE,OAAAO,EAAQ,MAAAC,CAAM,EAAIR,EACpBS,EAAaN,EAAI,aAAaK,CAAK,EAAE,aAAa,EAClDE,EAAY,IAAI,WAAW,CAAC,GAAGD,EAAYF,CAAM,CAAC,EAClDI,EAAOC,EAAS,OAAO,EAC7BD,EAAK,OAAOD,CAAS,EACrB,IAAMG,EAAaF,EAAK,OAAO,EAC/B,OAAO,IAAIb,EAAkB,CAAE,KAAMe,CAAW,CAAC,CACnD,CAUA,OAAc,uBAAuBb,EAAwE,CAC3G,GAAM,CAAE,UAAAc,CAAU,EAAId,EACtB,OAAOc,EAAU,QAAQ,CAC3B,CASA,OAAO,cAAcd,EAA0D,CAC7E,GAAM,CAAE,UAAAc,CAAU,EAAId,EACtB,OAAOc,EAAU,QAAQ,CAC3B,CAQA,gBAAiC,CAC/B,OAAO,IAAIC,EAAe,KAAK,KAAK,aAAa,CAAC,CACpD,CACF,EAzFajB,EAMK,OAAiB,GAN5B,IAAMkB,EAANlB","names":["sha3Hash","_AuthenticationKey","Serializable","args","data","hex","Hex","serializer","deserializer","bytes","scheme","input","inputBytes","hashInput","hash","sha3Hash","hashDigest","publicKey","AccountAddress","AuthenticationKey"]}
+{"version":3,"sources":["../../src/core/authenticationKey.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AccountAddress } from \"./accountAddress\";\nimport type { AccountPublicKey } from \"./crypto\";\nimport { Hex } from \"./hex\";\nimport { AuthenticationKeyScheme, HexInput } from \"../types\";\nimport { Serializable, Serializer } from \"../bcs/serializer\";\nimport { Deserializer } from \"../bcs/deserializer\";\n\n/**\n * Each account stores an authentication key. Authentication key enables account owners to rotate\n * their private key(s) associated with the account without changing the address that hosts their account.\n * @see {@link https://aptos.dev/concepts/accounts | Account Basics}\n *\n * Account addresses can be derived from AuthenticationKey\n */\nexport class AuthenticationKey extends Serializable {\n  /**\n   * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.\n   *\n   * The data to hash depends on the underlying public key type and the derivation scheme.\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The raw bytes of the authentication key.\n   */\n  public readonly data: Hex;\n\n  constructor(args: { data: HexInput }) {\n    super();\n    const { data } = args;\n    const hex = Hex.fromHexInput(data);\n    if (hex.toUint8Array().length !== AuthenticationKey.LENGTH) {\n      throw new Error(`Authentication Key length should be ${AuthenticationKey.LENGTH}`);\n    }\n    this.data = hex;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeFixedBytes(this.data.toUint8Array());\n  }\n\n  /**\n   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.\n   * @param deserializer The deserializer to deserialize the AuthenticationKey from.\n   * @returns An instance of AuthenticationKey.\n   */\n  static deserialize(deserializer: Deserializer): AuthenticationKey {\n    const bytes = deserializer.deserializeFixedBytes(AuthenticationKey.LENGTH);\n    return new AuthenticationKey({ data: bytes });\n  }\n\n  toString(): string {\n    return this.data.toString();\n  }\n\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  static fromSchemeAndBytes(args: { scheme: AuthenticationKeyScheme; input: HexInput }): AuthenticationKey {\n    const { scheme, input } = args;\n    const inputBytes = Hex.fromHexInput(input).toUint8Array();\n    const hashInput = new Uint8Array([...inputBytes, scheme]);\n    const hash = sha3Hash.create();\n    hash.update(hashInput);\n    const hashDigest = hash.digest();\n    return new AuthenticationKey({ data: hashDigest });\n  }\n\n  /**\n   * @deprecated Use `fromPublicKey` instead\n   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.\n   *\n   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.\n   *\n   * @param args - the public key and scheme to use for the derivation\n   */\n  public static fromPublicKeyAndScheme(args: { publicKey: AccountPublicKey; scheme: AuthenticationKeyScheme }) {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the\n   * instance of the PublicKey type passed in.\n   *\n   * @param args.publicKey\n   * @returns AuthenticationKey\n   */\n  static fromPublicKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {\n    const { publicKey } = args;\n    return publicKey.authKey();\n  }\n\n  /**\n   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,\n   * the AuthenticationKey bytes are directly translated to an AccountAddress.\n   *\n   * @returns AccountAddress\n   */\n  derivedAddress(): AccountAddress {\n    return new AccountAddress(this.data.toUint8Array());\n  }\n}\n"],"mappings":";;;;;;;;;;;AAGA,SAAS,YAAY,gBAAgB;AAe9B,IAAM,qBAAN,MAAM,2BAA0B,aAAa;AAAA,EAalD,YAAY,MAA0B;AACpC,UAAM;AACN,UAAM,EAAE,KAAK,IAAI;AACjB,UAAM,MAAM,IAAI,aAAa,IAAI;AACjC,QAAI,IAAI,aAAa,EAAE,WAAW,mBAAkB,QAAQ;AAC1D,YAAM,IAAI,MAAM,uCAAuC,mBAAkB,MAAM,EAAE;AAAA,IACnF;AACA,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,UAAU,YAA8B;AACtC,eAAW,oBAAoB,KAAK,KAAK,aAAa,CAAC;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,YAAY,cAA+C;AAChE,UAAM,QAAQ,aAAa,sBAAsB,mBAAkB,MAAM;AACzE,WAAO,IAAI,mBAAkB,EAAE,MAAM,MAAM,CAAC;AAAA,EAC9C;AAAA,EAEA,WAAmB;AACjB,WAAO,KAAK,KAAK,SAAS;AAAA,EAC5B;AAAA,EAEA,eAA2B;AACzB,WAAO,KAAK,KAAK,aAAa;AAAA,EAChC;AAAA,EAEA,OAAO,mBAAmB,MAA+E;AACvG,UAAM,EAAE,QAAQ,MAAM,IAAI;AAC1B,UAAM,aAAa,IAAI,aAAa,KAAK,EAAE,aAAa;AACxD,UAAM,YAAY,IAAI,WAAW,CAAC,GAAG,YAAY,MAAM,CAAC;AACxD,UAAM,OAAO,SAAS,OAAO;AAC7B,SAAK,OAAO,SAAS;AACrB,UAAM,aAAa,KAAK,OAAO;AAC/B,WAAO,IAAI,mBAAkB,EAAE,MAAM,WAAW,CAAC;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,uBAAuB,MAAwE;AAC3G,UAAM,EAAE,UAAU,IAAI;AACtB,WAAO,UAAU,QAAQ;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAO,cAAc,MAA0D;AAC7E,UAAM,EAAE,UAAU,IAAI;AACtB,WAAO,UAAU,QAAQ;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiC;AAC/B,WAAO,IAAI,eAAe,KAAK,KAAK,aAAa,CAAC;AAAA,EACpD;AACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAzFa,mBAMK,SAAiB;AAN5B,IAAM,oBAAN;","names":[]}