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

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

@@ -1 +0,0 @@
-{"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 {\n  AnyPublicKey,\n  AnySignature,\n  KeylessPublicKey,\n  KeylessSignature,\n  Secp256k1PublicKey,\n  FederatedKeylessPublicKey,\n  MultiKey,\n  MultiKeySignature,\n} 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  AccountAuthenticatorMultiEd25519,\n  AccountAuthenticatorMultiKey,\n  AccountAuthenticatorNoAccountAuthenticator,\n  AccountAuthenticatorSingleKey,\n} from \"../authenticator/account\";\nimport {\n  TransactionAuthenticator,\n  TransactionAuthenticatorEd25519,\n  TransactionAuthenticatorFeePayer,\n  TransactionAuthenticatorMultiAgent,\n  TransactionAuthenticatorMultiEd25519,\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 { isScriptDataInput } from \"./helpers\";\nimport { SimpleTransaction } from \"../instances/simpleTransaction\";\nimport { MultiAgentTransaction } from \"../instances/multiAgentTransaction\";\nimport { getFunctionParts } from \"../../utils/helpers\";\n\n/**\n * Builds a transaction payload based on the provided arguments and returns a transaction payload.\n * This function uses the RemoteABI by default, but can also utilize a specified ABI.\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 * @param args - The input data for generating the transaction payload.\n * @param args.function - The function to be called, specified in the format \"moduleAddress::moduleName::functionName\".\n * @param args.functionArguments - The arguments to pass to the function.\n * @param args.typeArguments - The type arguments for the function.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.abi - The ABI to use for the transaction, if not using the RemoteABI.\n *\n * @returns TransactionPayload - The generated transaction payload, which can be of type TransactionPayloadScript,\n * TransactionPayloadMultiSig, or TransactionPayloadEntryFunction.\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(\n  args: InputEntryFunctionDataWithRemoteABI,\n): Promise<TransactionPayloadEntryFunction>;\n/**\n * @group Implementation\n * @category Transactions\n */\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 * @group Implementation\n * @category Transactions\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\n/**\n * Generates a transaction payload using the provided ABI and function details.\n * This function helps create a properly structured transaction payload for executing a specific function on a module.\n *\n * @param args - The input data required to generate the transaction payload.\n * @param args.abi - The ABI of the function to be executed.\n * @param args.function - The fully qualified name of the function in the format `moduleAddress::moduleName::functionName`.\n * @param args.typeArguments - An array of type arguments that correspond to the function's type parameters.\n * @param args.functionArguments - An array of arguments to be passed to the function.\n * @param args.multisigAddress - (Optional) The address for a multisig transaction if applicable.\n *\n * @throws Error if the type argument count does not match the ABI or if the number of function arguments is incorrect.\n * @group Implementation\n * @category Transactions\n */\nexport function generateTransactionPayloadWithABI(args: InputEntryFunctionDataWithABI): TransactionPayloadEntryFunction;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function generateTransactionPayloadWithABI(args: InputMultiSigDataWithABI): TransactionPayloadMultiSig;\n/**\n * @group Implementation\n * @category Transactions\n */\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    /**\n     * Converts the argument for a specified function using its ABI and type arguments.\n     * This function helps ensure that the correct number of arguments is provided for the function call.\n     *\n     * @param args - The arguments for the function call.\n     * @param args.function - The specific function to be invoked.\n     * @param functionAbi - The ABI (Application Binary Interface) of the function, which includes parameter details.\n     * @param arg - The argument to be converted.\n     * @param i - The index of the argument in the function call.\n     * @param typeArguments - Additional type arguments that may be required for the conversion.\n     * @group Implementation\n     * @category Transactions\n     */\n    // TODO: Fix JSDoc\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\n/**\n * Generates the payload for a view function call using the provided arguments.\n * This function helps in preparing the necessary data to interact with a specific view function on the blockchain.\n *\n * @param args - The input data required to generate the view function payload.\n * @param args.function - The function identifier in the format \"moduleAddress::moduleName::functionName\".\n * @param args.aptosConfig - Configuration settings for the Aptos client.\n * @param args.abi - The ABI (Application Binary Interface) of the module.\n *\n * @returns The generated payload for the view function call.\n * @group Implementation\n * @category Transactions\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\n/**\n * Generates a payload for a view function call using the provided ABI and arguments.\n * This function ensures that the type arguments and function arguments are correctly formatted\n * and match the expected counts as defined in the ABI.\n *\n * @param args - The input data for generating the view function payload.\n * @param args.abi - The ABI of the function to be called.\n * @param args.function - The full name of the function in the format \"moduleAddress::moduleName::functionName\".\n * @param args.typeArguments - An array of type arguments to be used in the function call.\n * @param args.functionArguments - An array of arguments to be passed to the function.\n *\n * @throws Error if the type argument count does not match the ABI or if the function arguments\n * do not match the expected parameters defined in the ABI.\n * @group Implementation\n * @category Transactions\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\n/**\n * Generates a transaction payload script based on the provided input data.\n * This function helps in creating a structured script for transaction processing.\n *\n * @param args - The input data required to generate the transaction payload script.\n * @param args.bytecode - The bytecode to be converted into a Uint8Array.\n * @param args.typeArguments - The type arguments that will be standardized.\n * @param args.functionArguments - The arguments for the function being called.\n * @returns A new instance of TransactionPayloadScript.\n * @group Implementation\n * @category Transactions\n */\nfunction generateTransactionPayloadScript(args: InputScriptData) {\n  return new TransactionPayloadScript(\n    new Script(\n      Hex.fromHexInput(args.bytecode).toUint8Array(),\n      standardizeTypeTags(args.typeArguments),\n      args.functionArguments,\n    ),\n  );\n}\n\n/**\n * Generates a raw transaction that can be sent to the Aptos network.\n *\n * @param args - The arguments for generating the raw transaction.\n * @param args.aptosConfig - The configuration for the Aptos network.\n * @param args.sender - The transaction's sender account address as a hex input.\n * @param args.payload - The transaction payload, which can be created using generateTransactionPayload().\n * @param args.options - Optional parameters for transaction generation.\n * @param args.feePayerAddress - The address of the fee payer for sponsored transactions.\n *\n * @returns RawTransaction - The generated raw transaction.\n * @group Implementation\n * @category Transactions\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     * @group Implementation\n     * @category Transactions\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 * Generates a transaction based on the provided arguments.\n * This function can create both simple and multi-agent transactions, allowing for flexible transaction handling.\n *\n * @param args - The input arguments for generating the transaction.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.sender - The transaction's sender account address as a hex input.\n * @param args.payload - The transaction payload, which can be created using `generateTransactionPayload()`.\n * @param args.options - Optional. Transaction options object.\n * @param args.secondarySignerAddresses - Optional. An array of addresses for additional signers in a multi-signature transaction.\n * @param args.feePayerAddress - Optional. The address of the fee payer for sponsored transactions.\n * @returns An instance of a transaction, which may include secondary signer addresses and a fee payer address.\n * @group Implementation\n * @category Transactions\n */\nexport async function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<SimpleTransaction>;\n/**\n * @group Implementation\n * @category Transactions\n */\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 * @group Implementation\n * @category Transactions\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 * Generate a signed transaction for simulation before submitting it to the chain.\n * This function helps in preparing a transaction that can be simulated, allowing users to verify its validity and expected behavior.\n *\n * @param args - The input data required to generate the signed transaction for simulation.\n * @param args.transaction - An Aptos transaction type to sign.\n * @param args.signerPublicKey - The public key of the signer.\n * @param args.secondarySignersPublicKeys - Optional. The public keys of secondary signers if it is a multi-signer transaction.\n * @param args.feePayerPublicKey - Optional. The public key of the fee payer in a sponsored transaction.\n * @param args.options - Optional. Additional options for simulating the transaction.\n *\n * @returns A signed serialized transaction that can be simulated.\n * @group Implementation\n * @category Transactions\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 (transaction.secondarySignerAddresses) {\n      if (secondarySignersPublicKeys) {\n        secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n          getAuthenticatorForSimulation(publicKey),\n        );\n      } else {\n        secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>\n          getAuthenticatorForSimulation(undefined),\n        );\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    if (secondarySignersPublicKeys) {\n      secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n        getAuthenticatorForSimulation(publicKey),\n      );\n    } else {\n      secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>\n        getAuthenticatorForSimulation(undefined),\n      );\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 (\n    accountAuthenticator instanceof AccountAuthenticatorSingleKey ||\n    accountAuthenticator instanceof AccountAuthenticatorMultiKey\n  ) {\n    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);\n  } else if (accountAuthenticator instanceof AccountAuthenticatorNoAccountAuthenticator) {\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\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function getAuthenticatorForSimulation(publicKey?: PublicKey) {\n  if (!publicKey) {\n    return new AccountAuthenticatorNoAccountAuthenticator();\n  }\n\n  // Wrap the public key types below with AnyPublicKey as they are only support through single sender.\n  // Learn more about AnyPublicKey here - https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-55.md\n  const convertToAnyPublicKey =\n    KeylessPublicKey.isInstance(publicKey) ||\n    FederatedKeylessPublicKey.isInstance(publicKey) ||\n    Secp256k1PublicKey.isInstance(publicKey);\n  const accountPublicKey = convertToAnyPublicKey ? new AnyPublicKey(publicKey) : publicKey;\n\n  // No need to for the signature to be matching in scheme. All that matters for simulations is that it's not valid\n  const invalidSignature = new Ed25519Signature(new Uint8Array(64));\n\n  if (Ed25519PublicKey.isInstance(accountPublicKey)) {\n    return new AccountAuthenticatorEd25519(accountPublicKey, invalidSignature);\n  }\n\n  if (AnyPublicKey.isInstance(accountPublicKey)) {\n    if (KeylessPublicKey.isInstance(accountPublicKey.publicKey)) {\n      return new AccountAuthenticatorSingleKey(\n        accountPublicKey,\n        new AnySignature(KeylessSignature.getSimulationSignature()),\n      );\n    }\n    return new AccountAuthenticatorSingleKey(accountPublicKey, new AnySignature(invalidSignature));\n  }\n\n  if (MultiKey.isInstance(accountPublicKey)) {\n    return new AccountAuthenticatorMultiKey(\n      accountPublicKey,\n      new MultiKeySignature({\n        signatures: accountPublicKey.publicKeys.map(() => new AnySignature(invalidSignature)),\n        bitmap: accountPublicKey.createBitmap({\n          bits: Array(accountPublicKey.publicKeys.length)\n            .fill(0)\n            .map((_, i) => i),\n        }),\n      }),\n    );\n  }\n\n  throw new Error(\"Unsupported PublicKey used for simulations\");\n}\n\n/**\n * Generate a signed transaction ready for submission to the blockchain.\n * This function prepares the transaction by authenticating the sender and any additional signers based on the provided arguments.\n *\n * @param args - The input data required to generate the signed transaction.\n * @param args.transaction - An Aptos transaction type containing the details of the transaction.\n * @param args.senderAuthenticator - The account authenticator of the transaction sender.\n * @param args.feePayerAuthenticator - The authenticator for the fee payer, required if the transaction has a fee payer address.\n * @param args.additionalSignersAuthenticators - Optional authenticators for additional signers in a multi-signer transaction.\n *\n * @returns A Uint8Array representing the signed transaction in bytes.\n *\n * @throws Error if the feePayerAuthenticator is not provided for a fee payer transaction.\n * @throws Error if additionalSignersAuthenticators are not provided for a multi-signer transaction.\n * @group Implementation\n * @category Transactions\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 if (senderAuthenticator instanceof AccountAuthenticatorMultiEd25519) {\n    txnAuthenticator = new TransactionAuthenticatorMultiEd25519(\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 using a SHA-3 256 hash algorithm.\n * @param input - An array of UTF-8 strings or Uint8Array byte arrays to be hashed.\n * @group Implementation\n * @category Transactions\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 transactions\n * @group Implementation\n * @category Transactions\n */\nconst TRANSACTION_PREFIX = hashValues([\"APTOS::Transaction\"]);\n\n/**\n * Generates a user transaction hash for the provided transaction payload, which must already have an authenticator.\n * This function helps ensure the integrity and uniqueness of the transaction by producing a hash based on the signed transaction data.\n *\n * @param args - The input data required to submit the transaction.\n * @param args.authenticator - The authenticator for the transaction.\n * @param args.payload - The payload containing the transaction details.\n * @param args.sender - The address of the sender initiating the transaction.\n * @param args.sequenceNumber - The sequence number of the transaction for the sender.\n * @group Implementation\n * @category Transactions\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 while allowing for pass-through on provided ABIs.\n *\n * @param key - A unique identifier for the cached ABI.\n * @param moduleAddress - The address of the module from which to fetch the ABI.\n * @param moduleName - The name of the module containing the function.\n * @param functionName - The name of the function whose ABI is being fetched.\n * @param aptosConfig - Configuration settings for Aptos.\n * @param abi - An optional ABI to use if already available.\n * @param fetch - A function to fetch the ABI if it is not provided.\n * @group Implementation\n * @category Transactions\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-OOQS6BEP.mjs.map

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file contains the underlying implementations for exposed API surface in\n * the {@link api/account}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * account namespace and without having a dependency cycle error.\n * @group Implementation\n */\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { getAptosFullNode, paginateWithCursor, paginateWithObfuscatedCursor } from \"../client\";\nimport {\n  AccountData,\n  AnyPublicKeyVariant,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  GetMultiKeyForAuthKeyResponse,\n  GetObjectDataQueryResponse,\n  isEd25519Signature,\n  isMultiEd25519Signature,\n  isSingleSenderMultiKeySignature,\n  isSingleSenderSignature,\n  isSingleSenderSingleKeySignature,\n  isUserTransactionResponse,\n  LedgerVersionArg,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandardArg,\n  TransactionResponse,\n  WhereArg,\n} from \"../types\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { Account } from \"../account\";\nimport {\n  AbstractMultiKey,\n  AccountPublicKey,\n  AnyPublicKey,\n  Ed25519PublicKey,\n  FederatedKeylessPublicKey,\n  KeylessPublicKey,\n  MultiEd25519PublicKey,\n  MultiKey,\n  PrivateKey,\n  PublicKey,\n  Secp256k1PublicKey,\n} from \"../core/crypto\";\nimport { queryIndexer } from \"./general\";\nimport {\n  GetAccountCoinsCountQuery,\n  GetAccountCoinsDataQuery,\n  GetAccountCollectionsWithOwnedTokensQuery,\n  GetObjectDataQuery,\n  GetAccountOwnedTokensFromCollectionQuery,\n  GetAccountOwnedTokensQuery,\n  GetAccountTokensCountQuery,\n  GetAccountTransactionsCountQuery,\n  GetMultiKeyForAuthKeyQuery,\n  GetAuthKeysForPublicKeyQuery,\n  GetAccountAddressesForAuthKeyQuery,\n  GetSignaturesQuery,\n} from \"../types/generated/operations\";\nimport {\n  GetAccountCoinsCount,\n  GetAccountCoinsData,\n  GetAccountCollectionsWithOwnedTokens,\n  GetObjectData,\n  GetAccountOwnedTokens,\n  GetAccountOwnedTokensFromCollection,\n  GetAccountTokensCount,\n  GetAccountTransactionsCount,\n  GetMultiKeyForAuthKey,\n  GetAuthKeysForPublicKey,\n  GetAccountAddressesForAuthKey,\n  GetSignatures,\n} from \"../types/generated/queries\";\nimport { memoizeAsync } from \"../utils/memoize\";\nimport { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress, Hex } from \"../core\";\nimport { CurrentFungibleAssetBalancesBoolExp } from \"../types/generated/types\";\nimport { getTableItem } from \"./table\";\nimport { APTOS_COIN } from \"../utils\";\nimport { AptosApiError } from \"../errors\";\nimport { Deserializer } from \"../bcs\";\nimport { getTransactionByVersion } from \"./transaction\";\nimport { deriveKeylessAccount, DeriveKeylessAccountParams } from \"./keyless\";\n\n/**\n * Retrieves account information for a specified account address.\n *\n * @param args - The arguments for retrieving account information.\n * @param args.aptosConfig - The configuration object for Aptos.\n * @param args.accountAddress - The address of the account to retrieve information for.\n * @group Implementation\n */\nexport async function getInfo(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<AccountData> {\n  const { aptosConfig, accountAddress } = args;\n  const { data } = await getAptosFullNode<{}, AccountData>({\n    aptosConfig,\n    originMethod: \"getInfo\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,\n  });\n  return data;\n}\n\n/**\n * Retrieves the modules associated with a specified account address.\n *\n * @param args - The arguments for retrieving modules.\n * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.\n * @param args.accountAddress - The address of the account whose modules are to be retrieved.\n * @param args.options - Optional parameters for pagination and ledger version.\n * @param args.options.limit - The maximum number of modules to retrieve (default is 1000).\n * @param args.options.offset - The starting point for pagination.  Note, this is obfuscated and is not an index.\n * @param args.options.ledgerVersion - The specific ledger version to query.\n * @group Implementation\n */\nexport async function getModules(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & LedgerVersionArg;\n}): Promise<MoveModuleBytecode[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithObfuscatedCursor<{}, MoveModuleBytecode[]>({\n    aptosConfig,\n    originMethod: \"getModules\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,\n    params: {\n      ledger_version: options?.ledgerVersion,\n      offset: options?.offset,\n      limit: options?.limit ?? 1000,\n    },\n  });\n}\n\n/**\n * Queries for a move module given an account address and module name.\n * This function can help you retrieve the module's ABI and other relevant information.\n *\n * @param args - The arguments for retrieving the module.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.accountAddress - The account address in hex-encoded 32 byte format.\n * @param args.moduleName - The name of the module to retrieve.\n * @param args.options - Optional parameters for the request.\n * @param args.options.ledgerVersion - Specifies the ledger version of transactions. By default, the latest version will be used.\n * @returns The move module.\n * @group Implementation\n */\nexport async function getModule(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled\n  // by the developer directly\n  if (args.options?.ledgerVersion !== undefined) {\n    return getModuleInner(args);\n  }\n\n  return memoizeAsync(\n    async () => getModuleInner(args),\n    `module-${args.accountAddress}-${args.moduleName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n\n/**\n * Retrieves the bytecode of a specified module from a given account address.\n *\n * @param args - The parameters for retrieving the module bytecode.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.accountAddress - The address of the account from which to retrieve the module.\n * @param args.moduleName - The name of the module to retrieve.\n * @param args.options - Optional parameters for specifying the ledger version.\n * @param args.options.ledgerVersion - The specific ledger version to query.\n * @group Implementation\n */\nasync function getModuleInner(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  moduleName: string;\n  options?: LedgerVersionArg;\n}): Promise<MoveModuleBytecode> {\n  const { aptosConfig, accountAddress, moduleName, options } = args;\n\n  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({\n    aptosConfig,\n    originMethod: \"getModule\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n  return data;\n}\n\n/**\n * Retrieves a list of transactions associated with a specific account address.\n * This function allows you to paginate through the transactions for better performance and usability.\n *\n * @param args - The arguments for retrieving transactions.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.accountAddress - The account address for which to retrieve transactions.\n * @param args.options - Optional pagination parameters.\n * @param args.options.offset - The starting point for pagination.\n * @param args.options.limit - The maximum number of transactions to retrieve.\n * @group Implementation\n */\nexport async function getTransactions(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs;\n}): Promise<TransactionResponse[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithCursor<{}, TransactionResponse[]>({\n    aptosConfig,\n    originMethod: \"getTransactions\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/transactions`,\n    params: { start: options?.offset, limit: options?.limit },\n  });\n}\n\n/**\n * Retrieves a list of resources associated with a specific account address.\n *\n * @param args - The arguments for retrieving resources.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.accountAddress - The address of the account to fetch resources for.\n * @param args.options - Optional pagination and ledger version parameters.\n * @param args.options.offset - The starting point for pagination.  Note, this is obfuscated and is not an index.\n * @param args.options.limit - The maximum number of resources to retrieve (default is 999).\n * @param args.options.ledgerVersion - The specific ledger version to query.\n * @group Implementation\n */\nexport async function getResources(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & LedgerVersionArg;\n}): Promise<MoveResource[]> {\n  const { aptosConfig, accountAddress, options } = args;\n  return paginateWithObfuscatedCursor<{}, MoveResource[]>({\n    aptosConfig,\n    originMethod: \"getResources\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,\n    params: {\n      ledger_version: options?.ledgerVersion,\n      offset: options?.offset,\n      limit: options?.limit ?? 999,\n    },\n  });\n}\n\n/**\n * Retrieves a specific resource of a given type for the specified account address.\n *\n * @param args - The arguments for retrieving the resource.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.accountAddress - The address of the account from which to retrieve the resource.\n * @param args.resourceType - The type of the resource to retrieve, specified as a MoveStructId.\n * @param args.options - Optional parameters for specifying the ledger version.\n * @group Implementation\n */\nexport async function getResource<T extends {}>(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  resourceType: MoveStructId;\n  options?: LedgerVersionArg;\n}): Promise<T> {\n  const { aptosConfig, accountAddress, resourceType, options } = args;\n  const { data } = await getAptosFullNode<{}, MoveResource>({\n    aptosConfig,\n    originMethod: \"getResource\",\n    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,\n    params: { ledger_version: options?.ledgerVersion },\n  });\n  return data.data as T;\n}\n\n/**\n * Retrieves the original account address associated with a given authentication key, which is useful for handling key rotations.\n *\n * @param args - The arguments for the lookup.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.authenticationKey - The authentication key for which to look up the original address.\n * @param args.options - Optional parameters for specifying the ledger version.\n * @returns The original account address or the provided authentication key address if not found.\n * @throws Throws an error if the lookup fails for reasons other than the address not being found.\n * @group Implementation\n */\nexport async function lookupOriginalAccountAddress(args: {\n  aptosConfig: AptosConfig;\n  authenticationKey: AccountAddressInput;\n  options?: LedgerVersionArg;\n}): Promise<AccountAddress> {\n  const { aptosConfig, authenticationKey, options } = args;\n  type OriginatingAddress = {\n    address_map: { handle: string };\n  };\n  const resource = await getResource<OriginatingAddress>({\n    aptosConfig,\n    accountAddress: \"0x1\",\n    resourceType: \"0x1::account::OriginatingAddress\",\n    options,\n  });\n\n  const {\n    address_map: { handle },\n  } = resource;\n\n  const authKeyAddress = AccountAddress.from(authenticationKey);\n\n  // If the address is not found in the address map, which means its not rotated\n  // then return the address as is\n  try {\n    const originalAddress = await getTableItem<string>({\n      aptosConfig,\n      handle,\n      data: {\n        key: authKeyAddress.toString(),\n        key_type: \"address\",\n        value_type: \"address\",\n      },\n      options,\n    });\n\n    return AccountAddress.from(originalAddress);\n  } catch (err) {\n    if (err instanceof AptosApiError && err.data.error_code === \"table_item_not_found\") {\n      return authKeyAddress;\n    }\n\n    throw err;\n  }\n}\n\n/**\n * Retrieves the count of tokens owned by a specific account address.\n *\n * @param args - The arguments for retrieving the account tokens count.\n * @param args.aptosConfig - The configuration settings for the Aptos network.\n * @param args.accountAddress - The address of the account for which to count the tokens.\n * @returns The count of tokens owned by the specified account.\n * @group Implementation\n */\nexport async function getAccountTokensCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number } } = {\n    owner_address: { _eq: address },\n    amount: { _gt: 0 },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountTokensCount,\n    variables: { where_condition: whereCondition },\n  };\n\n  const data = await queryIndexer<GetAccountTokensCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountTokensCount\",\n  });\n\n  // commonjs (aka cjs) doesn't handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data.current_token_ownerships_v2_aggregate.aggregate\n    ? data.current_token_ownerships_v2_aggregate.aggregate.count\n    : 0;\n}\n\n/**\n * Retrieves the tokens owned by a specified account address.\n *\n * @param args - The arguments for retrieving the account's tokens.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.accountAddress - The address of the account whose tokens are being queried.\n * @param args.options - Optional parameters for filtering and pagination.\n * @param args.options.tokenStandard - The specific token standard to filter the results.\n * @param args.options.offset - The number of records to skip before starting to collect the result set.\n * @param args.options.limit - The maximum number of records to return.\n * @param args.options.orderBy - The criteria for ordering the results.\n * @returns A promise that resolves to the current token ownerships of the specified account.\n * @group Implementation\n */\nexport async function getAccountOwnedTokens(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;\n}): Promise<GetAccountOwnedTokensQueryResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number }; token_standard?: { _eq: string } } =\n    {\n      owner_address: { _eq: address },\n      amount: { _gt: 0 },\n    };\n\n  if (options?.tokenStandard) {\n    whereCondition.token_standard = { _eq: options?.tokenStandard };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountOwnedTokens,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountOwnedTokensQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountOwnedTokens\",\n  });\n\n  return data.current_token_ownerships_v2;\n}\n\n/**\n * Retrieves the tokens owned by a specific account from a particular collection address.\n *\n * @param args - The parameters required to fetch the owned tokens.\n * @param args.aptosConfig - The Aptos configuration object.\n * @param args.accountAddress - The address of the account whose tokens are being queried.\n * @param args.collectionAddress - The address of the collection from which tokens are being retrieved.\n * @param args.options - Optional parameters for filtering and pagination, including token standard, pagination arguments, and\n * order by options.\n * @group Implementation\n */\nexport async function getAccountOwnedTokensFromCollectionAddress(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  collectionAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;\n}): Promise<GetAccountOwnedTokensFromCollectionResponse> {\n  const { aptosConfig, accountAddress, collectionAddress, options } = args;\n  const ownerAddress = AccountAddress.from(accountAddress).toStringLong();\n  const collAddress = AccountAddress.from(collectionAddress).toStringLong();\n\n  const whereCondition: {\n    owner_address: { _eq: string };\n    current_token_data: { collection_id: { _eq: string } };\n    amount: { _gt: number };\n    token_standard?: { _eq: string };\n  } = {\n    owner_address: { _eq: ownerAddress },\n    current_token_data: { collection_id: { _eq: collAddress } },\n    amount: { _gt: 0 },\n  };\n\n  if (options?.tokenStandard) {\n    whereCondition.token_standard = { _eq: options?.tokenStandard };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountOwnedTokensFromCollection,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountOwnedTokensFromCollectionQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountOwnedTokensFromCollectionAddress\",\n  });\n\n  return data.current_token_ownerships_v2;\n}\n\n/**\n * Retrieves the collections owned by a specified account along with the tokens in those collections.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.accountAddress - The address of the account whose collections are being queried.\n * @param args.options - Optional parameters for filtering and pagination.\n * @param args.options.tokenStandard - An optional token standard to filter the collections.\n * @param args.options.offset - An optional offset for pagination.\n * @param args.options.limit - An optional limit for the number of results returned.\n * @param args.options.orderBy - An optional parameter to specify the order of the results.\n * @group Implementation\n */\nexport async function getAccountCollectionsWithOwnedTokens(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n}): Promise<GetAccountCollectionsWithOwnedTokenResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: {\n    owner_address: { _eq: string };\n    current_collection?: { token_standard: { _eq: string } };\n  } = {\n    owner_address: { _eq: address },\n  };\n\n  if (options?.tokenStandard) {\n    whereCondition.current_collection = {\n      token_standard: { _eq: options?.tokenStandard },\n    };\n  }\n\n  const graphqlQuery = {\n    query: GetAccountCollectionsWithOwnedTokens,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountCollectionsWithOwnedTokensQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCollectionsWithOwnedTokens\",\n  });\n\n  return data.current_collection_ownership_v2_view;\n}\n\n/**\n * Retrieves the count of transactions associated with a specified account.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.accountAddress - The address of the account for which to retrieve the transaction count.\n * @returns The number of transactions associated with the specified account.\n * @group Implementation\n */\nexport async function getAccountTransactionsCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const graphqlQuery = {\n    query: GetAccountTransactionsCount,\n    variables: { address },\n  };\n\n  const data = await queryIndexer<GetAccountTransactionsCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountTransactionsCount\",\n  });\n\n  // commonjs (aka cjs) doesn't handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data.account_transactions_aggregate.aggregate ? data.account_transactions_aggregate.aggregate.count : 0;\n}\n\n/**\n * Retrieves the amount of a specific coin held by an account.\n *\n * @param args - The parameters for the request.\n * @param args.aptosConfig - The Aptos configuration object.\n * @param args.accountAddress - The address of the account to query.\n * @param args.coinType - Optional; the type of coin to check the amount for.\n * @param args.faMetadataAddress - Optional; the address of the fungible asset metadata.\n * @returns The amount of the specified coin held by the account, or 0 if none is found.\n * @throws Error if neither coinType nor faMetadataAddress is provided.\n * @group Implementation\n */\nexport async function getAccountCoinAmount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  coinType?: MoveStructId;\n  faMetadataAddress?: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress, coinType, faMetadataAddress } = args;\n\n  let coinAssetType: string | undefined = coinType;\n  let faAddress: string;\n\n  if (coinType !== undefined && faMetadataAddress !== undefined) {\n    faAddress = AccountAddress.from(faMetadataAddress).toStringLong();\n  } else if (coinType !== undefined && faMetadataAddress === undefined) {\n    // TODO Move to a separate function as defined in the AIP for coin migration\n    if (coinType === APTOS_COIN) {\n      faAddress = AccountAddress.A.toStringLong();\n    } else {\n      faAddress = createObjectAddress(AccountAddress.A, coinType).toStringLong();\n    }\n  } else if (coinType === undefined && faMetadataAddress !== undefined) {\n    const addr = AccountAddress.from(faMetadataAddress);\n    faAddress = addr.toStringLong();\n    if (addr === AccountAddress.A) {\n      coinAssetType = APTOS_COIN;\n    }\n    // The paired CoinType should be populated outside of this function in another\n    // async call. We cannot do this internally due to dependency cycles issue.\n  } else {\n    throw new Error(\"Either coinType, fungibleAssetAddress, or both must be provided\");\n  }\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  // Search by fungible asset address, unless it has a coin it migrated from\n  let where: any = { asset_type: { _eq: faAddress } };\n  if (coinAssetType !== undefined) {\n    where = { asset_type: { _in: [coinAssetType, faAddress] } };\n  }\n\n  const data = await getAccountCoinsData({\n    aptosConfig,\n    accountAddress: address,\n    options: {\n      where,\n    },\n  });\n\n  // commonjs (aka cjs) doesn't handle Nullish Coalescing for some reason\n  // might be because of how ts infer the graphql generated scheme type\n  return data[0] ? data[0].amount : 0;\n}\n\n/**\n * Retrieves the current fungible asset balances for a specified account.\n *\n * @param args - The arguments for retrieving account coins data.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.accountAddress - The address of the account for which to retrieve coin data.\n * @param args.options - Optional parameters for pagination and filtering the results.\n * @param args.options.offset - The number of items to skip before starting to collect the result set.\n * @param args.options.limit - The maximum number of items to return.\n * @param args.options.orderBy - The criteria for ordering the results.\n * @param args.options.where - Conditions to filter the results based on the current fungible asset balances.\n * @group Implementation\n */\nexport async function getAccountCoinsData(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n}): Promise<GetAccountCoinsDataResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string } } = {\n    ...options?.where,\n    owner_address: { _eq: address },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountCoinsData,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n\n  const data = await queryIndexer<GetAccountCoinsDataQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCoinsData\",\n  });\n\n  return data.current_fungible_asset_balances;\n}\n\n/**\n * Retrieves the count of fungible asset coins held by a specified account.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration settings for the Aptos network.\n * @param args.accountAddress - The address of the account for which to retrieve the coin count.\n * @throws Error if the count of account coins cannot be retrieved.\n * @group Implementation\n */\nexport async function getAccountCoinsCount(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const graphqlQuery = {\n    query: GetAccountCoinsCount,\n    variables: { address },\n  };\n\n  const data = await queryIndexer<GetAccountCoinsCountQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountCoinsCount\",\n  });\n\n  if (!data.current_fungible_asset_balances_aggregate.aggregate) {\n    throw Error(\"Failed to get the count of account coins\");\n  }\n\n  return data.current_fungible_asset_balances_aggregate.aggregate.count;\n}\n\n/**\n * Retrieves the objects owned by a specified account.\n *\n * @param args - The parameters for the request.\n * @param args.aptosConfig - The configuration for the Aptos client.\n * @param args.accountAddress - The address of the account whose owned objects are to be retrieved.\n * @param args.options - Optional parameters for pagination and ordering of the results.\n * @param args.options.offset - The number of items to skip before starting to collect the result set.\n * @param args.options.limit - The maximum number of items to return.\n * @param args.options.orderBy - The criteria to order the results by.\n * @returns A promise that resolves to the current objects owned by the specified account.\n * @group Implementation\n */\nexport async function getAccountOwnedObjects(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;\n}): Promise<GetObjectDataQueryResponse> {\n  const { aptosConfig, accountAddress, options } = args;\n  const address = AccountAddress.from(accountAddress).toStringLong();\n\n  const whereCondition: { owner_address: { _eq: string } } = {\n    owner_address: { _eq: address },\n  };\n  const graphqlQuery = {\n    query: GetObjectData,\n    variables: {\n      where_condition: whereCondition,\n      offset: options?.offset,\n      limit: options?.limit,\n      order_by: options?.orderBy,\n    },\n  };\n  const data = await queryIndexer<GetObjectDataQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountOwnedObjects\",\n  });\n\n  return data.current_objects;\n}\n\n/**\n * Derives an account from the provided private key and Aptos configuration.\n * This function helps in obtaining the account details associated with a given private key,\n * considering both unified and legacy authentication schemes.\n *\n * NOTE: There is a potential issue once the unified single signer scheme is adopted by the community.\n * Because one could create two accounts with the same private key with this new authenticator type,\n * we’ll need to determine the order in which we look up the accounts: first unified scheme and then legacy scheme,\n * or first legacy scheme and then unified scheme.\n *\n * @param args - The arguments for deriving the account.\n * @param args.aptosConfig - The Aptos configuration used for account lookup.\n * @param args.privateKey - The private key used to derive the account.\n * @throws Error if the account cannot be derived from the private key.\n * @group Implementation\n */\nexport async function deriveAccountFromPrivateKey(args: {\n  aptosConfig: AptosConfig;\n  privateKey: PrivateKey;\n}): Promise<Account> {\n  const { aptosConfig, privateKey } = args;\n  const publicKey = new AnyPublicKey(privateKey.publicKey());\n\n  if (privateKey instanceof Secp256k1PrivateKey) {\n    // private key is secp256k1, therefore we know it for sure uses a single signer key\n    const authKey = AuthenticationKey.fromPublicKey({ publicKey });\n    const address = authKey.derivedAddress();\n    return Account.fromPrivateKey({ privateKey, address });\n  }\n\n  if (privateKey instanceof Ed25519PrivateKey) {\n    // lookup single sender ed25519\n    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKey({\n      publicKey,\n    });\n    const isSingleSenderTransactionAuthenticator = await isAccountExist({\n      authKey: singleSenderTransactionAuthenticatorAuthKey,\n      aptosConfig,\n    });\n    if (isSingleSenderTransactionAuthenticator) {\n      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();\n      return Account.fromPrivateKey({ privateKey, address, legacy: false });\n    }\n    // lookup legacy ed25519\n    const legacyAuthKey = AuthenticationKey.fromPublicKey({\n      publicKey: publicKey.publicKey as Ed25519PublicKey,\n    });\n    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });\n    if (isLegacyEd25519) {\n      const address = legacyAuthKey.derivedAddress();\n      return Account.fromPrivateKey({ privateKey, address, legacy: true });\n    }\n  }\n  // if we are here, it means we couldn't find an address with an\n  // auth key that matches the provided private key\n  throw new Error(`Can't derive account from private key ${privateKey}`);\n}\n\n/**\n * Checks if an account exists by verifying its information against the Aptos blockchain.\n *\n * @param args - The arguments for the function.\n * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.\n * @param args.authKey - The authentication key used to derive the account address.\n * @returns A promise that resolves to a boolean indicating whether the account exists.\n *\n * @throws Throws an Error if there is an issue while looking for account information.\n * @group Implementation\n */\nexport async function isAccountExist(args: { aptosConfig: AptosConfig; authKey: AuthenticationKey }): Promise<boolean> {\n  const { aptosConfig, authKey } = args;\n  const accountAddress = await lookupOriginalAccountAddress({\n    aptosConfig,\n    authenticationKey: authKey.derivedAddress(),\n  });\n\n  try {\n    await getInfo({\n      aptosConfig,\n      accountAddress,\n    });\n    return true;\n  } catch (error: any) {\n    // account not found\n    if (error.status === 404) {\n      return false;\n    }\n    throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);\n  }\n}\n\nasync function getMultiKeysForAuthenticationKeys(args: {\n  aptosConfig: AptosConfig;\n  authKeys: AuthenticationKey[];\n}): Promise<{ authKey: AuthenticationKey; publicKey: MultiKey | MultiEd25519PublicKey }[]> {\n  const { aptosConfig, authKeys } = args;\n  if (authKeys.length === 0) {\n    throw new Error(\"No authentication keys provided\");\n  }\n\n  const whereCondition: { auth_key: { _in: string[] } } = {\n    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },\n  };\n\n  const graphqlQuery = {\n    query: GetMultiKeyForAuthKey,\n    variables: {\n      where_condition: whereCondition,\n    },\n  };\n  const { auth_key_multikey_layout: data } = await queryIndexer<GetMultiKeyForAuthKeyQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getMultiKeysForAuthenticationKeys\",\n  });\n\n  const authKeyToMultiKey = new Map(data.map((entry) => [entry.auth_key, entry]));\n\n  const result: { authKey: AuthenticationKey; publicKey: MultiKey | MultiEd25519PublicKey }[] = [];\n  for (let i = 0; i < authKeys.length; i += 1) {\n    const entry = authKeyToMultiKey.get(authKeys[i].toString());\n    if (!entry) {\n      throw new Error(`Failed to find multikey for authentication key ${authKeys[i]}`);\n    }\n    const publicKey = extractMultiKeyFromData(entry);\n    result.push({ authKey: authKeys[i], publicKey });\n  }\n\n  return result;\n}\n\nfunction extractMultiKeyFromData(data: GetMultiKeyForAuthKeyResponse): MultiKey | MultiEd25519PublicKey {\n  const signaturesRequired = data.signatures_required;\n  const multikeyLayout = data.multikey_layout_with_prefixes;\n  const multikeyType = data.multikey_type;\n\n  if (multikeyType === \"multi_ed25519\") {\n    const ed25519PublicKeys: Array<Ed25519PublicKey> = [];\n    for (const key of multikeyLayout) {\n      ed25519PublicKeys.push(new Ed25519PublicKey(key));\n    }\n    return new MultiEd25519PublicKey({\n      publicKeys: ed25519PublicKeys,\n      threshold: signaturesRequired,\n    });\n  }\n  if (multikeyType === \"multi_key\") {\n    const publicKeys: Array<PublicKey> = [];\n    for (const key of multikeyLayout) {\n      const deserializer = Deserializer.fromHex(key);\n      const variantIndex = deserializer.deserializeUleb128AsU32();\n      let publicKey: PublicKey;\n      switch (variantIndex) {\n        case AnyPublicKeyVariant.Ed25519:\n          publicKey = new Ed25519PublicKey(deserializer.deserializeFixedBytes(32));\n          break;\n        case AnyPublicKeyVariant.Secp256k1:\n          publicKey = new Secp256k1PublicKey(deserializer.deserializeFixedBytes(65));\n          break;\n        case AnyPublicKeyVariant.Keyless:\n          publicKey = KeylessPublicKey.deserialize(deserializer);\n          break;\n        case AnyPublicKeyVariant.FederatedKeyless:\n          publicKey = FederatedKeylessPublicKey.deserialize(deserializer);\n          break;\n        default:\n          throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);\n      }\n      publicKeys.push(new AnyPublicKey(publicKey));\n    }\n    return new MultiKey({\n      publicKeys,\n      signaturesRequired,\n    });\n  }\n  throw new Error(\"Unknown multikey type\");\n}\n\nasync function getAuthKeysForPublicKey(args: {\n  aptosConfig: AptosConfig;\n  publicKey: Exclude<AccountPublicKey, AbstractMultiKey>;\n  options?: { verified?: boolean };\n}): Promise<AuthenticationKey[]> {\n  const { aptosConfig, publicKey, options } = args;\n  const verified = options?.verified ?? true;\n  let baseKey: PublicKey = publicKey;\n  if (publicKey instanceof AnyPublicKey) {\n    baseKey = publicKey.publicKey;\n  }\n  const whereCondition: any = {\n    public_key: { _eq: baseKey.toString() },\n    verified: { _eq: verified },\n  };\n  const graphqlQuery = {\n    query: GetAuthKeysForPublicKey,\n    variables: {\n      where_condition: whereCondition,\n    },\n  };\n  const { public_key_auth_keys: data } = await queryIndexer<GetAuthKeysForPublicKeyQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAuthKeysForPublicKey\",\n  });\n\n  const sortedData = data.sort((a, b) => Number(b.last_transaction_version) - Number(a.last_transaction_version));\n  const authKeys = sortedData.map((entry) => new AuthenticationKey({ data: entry.auth_key }));\n  return authKeys;\n}\n\nasync function getLastestTransactionVersionForAddress(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<number> {\n  const { aptosConfig, accountAddress } = args;\n  const address = AccountAddress.from(accountAddress).toString();\n\n  const whereCondition: any = {\n    signer: { _eq: accountAddress.toString() },\n  };\n\n  const graphqlQuery = {\n    query: GetSignatures,\n    variables: {\n      where_condition: whereCondition,\n      limit: 1,\n      order_by: { transaction_version: \"desc\" },\n    },\n  };\n\n  const { signatures: data } = await queryIndexer<GetSignaturesQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getSignatures\",\n  });\n\n  if (data.length !== 1) {\n    throw new Error(`Expected 1 account address for address ${address}, got ${data.length}`);\n  }\n  return Number(data[0].transaction_version);\n}\n\nasync function getAccountAddressesForAuthKeys(args: {\n  aptosConfig: AptosConfig;\n  authKeys: AuthenticationKey[];\n  options?: { verified?: boolean };\n}): Promise<\n  { authKey: AuthenticationKey; accountAddress: AccountAddress; verified: boolean; lastTransactionVersion: number }[]\n> {\n  const { aptosConfig, options, authKeys } = args;\n  const verified = options?.verified ?? true;\n  if (authKeys.length === 0) {\n    throw new Error(\"No authentication keys provided\");\n  }\n\n  const whereCondition: any = {\n    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },\n    verified: { _eq: verified },\n  };\n\n  const graphqlQuery = {\n    query: GetAccountAddressesForAuthKey,\n    variables: {\n      where_condition: whereCondition,\n    },\n  };\n  const { auth_key_account_addresses: data } = await queryIndexer<GetAccountAddressesForAuthKeyQuery>({\n    aptosConfig,\n    query: graphqlQuery,\n    originMethod: \"getAccountAddressesForAuthKeys\",\n  });\n  return data.map((entry) => ({\n    authKey: new AuthenticationKey({ data: entry.auth_key }),\n    accountAddress: new AccountAddress(Hex.hexInputToUint8Array(entry.address)),\n    verified: entry.verified,\n    lastTransactionVersion: Number(entry.last_transaction_version),\n  }));\n}\n\nexport async function getAccountsForPublicKey(args: {\n  aptosConfig: AptosConfig;\n  publicKey: AccountPublicKey;\n}): Promise<\n  { accountAddress: AccountAddress; publicKey: PublicKey; verified: boolean; lastTransactionVersion: number }[]\n> {\n  const { aptosConfig, publicKey } = args;\n\n  let baseKey: PublicKey = publicKey;\n  if (publicKey instanceof AnyPublicKey) {\n    baseKey = publicKey.publicKey;\n  }\n  const singleKeyPublicKeys: AccountPublicKey[] = [];\n  if (baseKey instanceof Ed25519PublicKey) {\n    singleKeyPublicKeys.push(baseKey);\n  }\n  const anyPublicKey = new AnyPublicKey(baseKey);\n  singleKeyPublicKeys.push(anyPublicKey);\n\n  const singleKeyAuthKeyPublicKeyPairs = singleKeyPublicKeys.map((pubKey) => {\n    const authKey = pubKey.authKey();\n    return { authKey, publicKey: pubKey };\n  });\n\n  const multiKeyAuthKeys = await getAuthKeysForPublicKey({ aptosConfig, publicKey });\n\n  const [multiKeyPairs, authKeyAccountAddressPairs] = await Promise.all([\n    getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: multiKeyAuthKeys }),\n    getAccountAddressesForAuthKeys({\n      aptosConfig,\n      authKeys: multiKeyAuthKeys.concat(singleKeyAuthKeyPublicKeyPairs.map((pair) => pair.publicKey.authKey())),\n    }),\n  ]);\n\n  const authKeyPublicKeyPairs = singleKeyAuthKeyPublicKeyPairs.concat(multiKeyPairs);\n\n  const result: {\n    accountAddress: AccountAddress;\n    publicKey: PublicKey;\n    verified: boolean;\n    lastTransactionVersion: number;\n  }[] = [];\n  const authKeyToPublicKey = new Map(authKeyPublicKeyPairs.map((pair) => [pair.authKey.toString(), pair.publicKey]));\n  for (const authKeyAccountAddressPair of authKeyAccountAddressPairs) {\n    if (!authKeyToPublicKey.has(authKeyAccountAddressPair.authKey.toString())) {\n      throw new Error(`No publicKey found for authentication key ${authKeyAccountAddressPair.authKey}.`);\n    }\n    result.push({\n      accountAddress: authKeyAccountAddressPair.accountAddress,\n      publicKey: authKeyToPublicKey.get(authKeyAccountAddressPair.authKey.toString()) as PublicKey,\n      verified: authKeyAccountAddressPair.verified,\n      lastTransactionVersion: authKeyAccountAddressPair.lastTransactionVersion,\n    });\n  }\n\n  return result;\n}\n\nexport async function getPublicKeyFromAccountAddress(args: {\n  aptosConfig: AptosConfig;\n  accountAddress: AccountAddressInput;\n}): Promise<PublicKey> {\n  const { aptosConfig, accountAddress } = args;\n\n  const accountData = await getInfo({ aptosConfig, accountAddress });\n\n  const lastTransactionVersion = await getLastestTransactionVersionForAddress({\n    aptosConfig,\n    accountAddress,\n  });\n  console.log(\"lastTransactionVersion\", lastTransactionVersion);\n\n  const transaction = await getTransactionByVersion({ aptosConfig, ledgerVersion: lastTransactionVersion });\n  if (!isUserTransactionResponse(transaction)) {\n    throw new Error(\"Transaction is not a user transaction\");\n  }\n\n  const { signature } = transaction;\n  if (!signature) {\n    throw new Error(\"Transaction has no signature\");\n  }\n\n  let publicKey: AccountPublicKey;\n  if (isEd25519Signature(signature)) {\n    publicKey = new Ed25519PublicKey(signature.public_key);\n  } else if (isMultiEd25519Signature(signature)) {\n    publicKey = new MultiEd25519PublicKey({\n      publicKeys: signature.public_keys.map((pk) => new Ed25519PublicKey(pk)),\n      threshold: signature.threshold,\n    });\n  } else if (isSingleSenderSingleKeySignature(signature)) {\n    publicKey = parsePublicKey(signature.public_key);\n  } else if (isSingleSenderMultiKeySignature(signature)) {\n    const publicKeys: Array<PublicKey> = [];\n    for (const pk of signature.public_keys) {\n      publicKeys.push(parsePublicKey(pk));\n    }\n    publicKey = new MultiKey({\n      publicKeys,\n      signaturesRequired: signature.signatures_required,\n    });\n  } else {\n    throw new Error(\"Unknown signature type\");\n  }\n  if (publicKey.authKey().toString() !== accountData.authentication_key) {\n    throw new Error(\n      \"Derived public key does not match authentication key. The most recent signature was likely a key rotation.\",\n    );\n  }\n  return publicKey;\n}\n\nexport async function getMultiKeyFromAuthenticationKey(args: {\n  aptosConfig: AptosConfig;\n  authKey: AuthenticationKey;\n}): Promise<MultiKey | MultiEd25519PublicKey> {\n  const { aptosConfig, authKey } = args;\n\n  const result = await getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: [authKey] });\n\n  if (result.length === 0) {\n    throw new Error(`No multikey found for the given authentication key ${authKey}`);\n  }\n  if (result.length > 1) {\n    // This should never happen. Rows are uniquely keyed by auth key.\n    throw new Error(`More than one multikey found for the given authentication key ${authKey}`);\n  }\n\n  return result[0].publicKey;\n}\n\n// export async function deriveAccount(\n//   args: { aptosConfig: AptosConfig } & (\n//     | { privateKey: PrivateKey }\n//     | DeriveKeylessAccountParams\n//     | { multiKeyDerivation: (PrivateKey | DeriveKeylessAccountParams)[] }\n//   ),\n// ): Promise<Account> {\n//   const { aptosConfig, ...rest } = args;\n//   if (\"privateKey\" in rest) {\n//     const accounts = await getAccountsForPublicKey({ aptosConfig, publicKey: rest.privateKey.publicKey() as AccountPublicKey });\n//     return deriveAccountFromPrivateKey({ aptosConfig, ...rest });\n//   } else if (\"jwt\" in rest) {\n//     return deriveKeylessAccount({ aptosConfig, ...rest });\n//   }\n//   const accounts: Account[] = [];\n//   for (const derivation of rest.multiKeyDerivation) { \n//     if (\"privateKey\" in derivation) {\n//       accounts.push(deriveAccountFromPrivateKey({ aptosConfig, ...derivation }));\n//     } else if (\"jwt\" in derivation) {\n//       accounts.push(deriveKeylessAccount({ aptosConfig, ...derivation }));\n//     }\n//   }\n//   return new MultiKey({\n//     publicKeys: accounts.map((account) => account.publicKey),\n//     threshold: rest.multiKeyDerivation.length,\n//   });\n// } \n\ntype AccountDerivationParams = { privateKey: PrivateKey } | DeriveKeylessAccountParams;\n\nfunction parsePublicKey(data: { value: string; type: string }): AnyPublicKey {\n  if (data.type === \"keyless\") {\n    const deserializer = Deserializer.fromHex(data.value);\n    return new AnyPublicKey(KeylessPublicKey.deserialize(deserializer));\n  }\n  if (data.type === \"ed25519\") {\n    return new AnyPublicKey(new Ed25519PublicKey(data.value));\n  }\n  if (data.type === \"secp256k1_ecdsa\") {\n    return new AnyPublicKey(new Secp256k1PublicKey(data.value));\n  }\n  throw new Error(\"Unknown public key type\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,eAAsB,QAAQ,MAGL;AACvB,QAAM,EAAE,aAAa,eAAe,IAAI;AACxC,QAAM,EAAE,KAAK,IAAI,MAAM,iBAAkC;AAAA,IACvD;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC;AAAA,EAClE,CAAC;AACD,SAAO;AACT;AAcA,eAAsB,WAAW,MAIC;AAChC,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,SAAO,6BAAuD;AAAA,IAC5D;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC;AAAA,IAChE,QAAQ;AAAA,MACN,gBAAgB,SAAS;AAAA,MACzB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS,SAAS;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAeA,eAAsB,UAAU,MAKA;AAG9B,MAAI,KAAK,SAAS,kBAAkB,QAAW;AAC7C,WAAO,eAAe,IAAI;AAAA,EAC5B;AAEA,SAAO;AAAA,IACL,YAAY,eAAe,IAAI;AAAA,IAC/B,UAAU,KAAK,cAAc,IAAI,KAAK,UAAU;AAAA,IAChD,MAAO,KAAK;AAAA;AAAA,EACd,EAAE;AACJ;AAaA,eAAe,eAAe,MAKE;AAC9B,QAAM,EAAE,aAAa,gBAAgB,YAAY,QAAQ,IAAI;AAE7D,QAAM,EAAE,KAAK,IAAI,MAAM,iBAAyC;AAAA,IAC9D;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC,WAAW,UAAU;AAAA,IACrF,QAAQ,EAAE,gBAAgB,SAAS,cAAc;AAAA,EACnD,CAAC;AACD,SAAO;AACT;AAcA,eAAsB,gBAAgB,MAIH;AACjC,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,SAAO,mBAA8C;AAAA,IACnD;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC;AAAA,IAChE,QAAQ,EAAE,OAAO,SAAS,QAAQ,OAAO,SAAS,MAAM;AAAA,EAC1D,CAAC;AACH;AAcA,eAAsB,aAAa,MAIP;AAC1B,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,SAAO,6BAAiD;AAAA,IACtD;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC;AAAA,IAChE,QAAQ;AAAA,MACN,gBAAgB,SAAS;AAAA,MACzB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS,SAAS;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAYA,eAAsB,YAA0B,MAKjC;AACb,QAAM,EAAE,aAAa,gBAAgB,cAAc,QAAQ,IAAI;AAC/D,QAAM,EAAE,KAAK,IAAI,MAAM,iBAAmC;AAAA,IACxD;AAAA,IACA,cAAc;AAAA,IACd,MAAM,YAAY,eAAe,KAAK,cAAc,EAAE,SAAS,CAAC,aAAa,YAAY;AAAA,IACzF,QAAQ,EAAE,gBAAgB,SAAS,cAAc;AAAA,EACnD,CAAC;AACD,SAAO,KAAK;AACd;AAaA,eAAsB,6BAA6B,MAIvB;AAC1B,QAAM,EAAE,aAAa,mBAAmB,QAAQ,IAAI;AAIpD,QAAM,WAAW,MAAM,YAAgC;AAAA,IACrD;AAAA,IACA,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd;AAAA,EACF,CAAC;AAED,QAAM;AAAA,IACJ,aAAa,EAAE,OAAO;AAAA,EACxB,IAAI;AAEJ,QAAM,iBAAiB,eAAe,KAAK,iBAAiB;AAI5D,MAAI;AACF,UAAM,kBAAkB,MAAM,aAAqB;AAAA,MACjD;AAAA,MACA;AAAA,MACA,MAAM;AAAA,QACJ,KAAK,eAAe,SAAS;AAAA,QAC7B,UAAU;AAAA,QACV,YAAY;AAAA,MACd;AAAA,MACA;AAAA,IACF,CAAC;AAED,WAAO,eAAe,KAAK,eAAe;AAAA,EAC5C,SAAS,KAAK;AACZ,QAAI,eAAe,iBAAiB,IAAI,KAAK,eAAe,wBAAwB;AAClF,aAAO;AAAA,IACT;AAEA,UAAM;AAAA,EACR;AACF;AAWA,eAAsB,sBAAsB,MAGxB;AAClB,QAAM,EAAE,aAAa,eAAe,IAAI;AAExC,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBAA8E;AAAA,IAClF,eAAe,EAAE,KAAK,QAAQ;AAAA,IAC9B,QAAQ,EAAE,KAAK,EAAE;AAAA,EACnB;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW,EAAE,iBAAiB,eAAe;AAAA,EAC/C;AAEA,QAAM,OAAO,MAAM,aAAyC;AAAA,IAC1D;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAID,SAAO,KAAK,sCAAsC,YAC9C,KAAK,sCAAsC,UAAU,QACrD;AACN;AAgBA,eAAsB,sBAAsB,MAII;AAC9C,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBACJ;AAAA,IACE,eAAe,EAAE,KAAK,QAAQ;AAAA,IAC9B,QAAQ,EAAE,KAAK,EAAE;AAAA,EACnB;AAEF,MAAI,SAAS,eAAe;AAC1B,mBAAe,iBAAiB,EAAE,KAAK,SAAS,cAAc;AAAA,EAChE;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,aAAyC;AAAA,IAC1D;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;AAaA,eAAsB,2CAA2C,MAKR;AACvD,QAAM,EAAE,aAAa,gBAAgB,mBAAmB,QAAQ,IAAI;AACpE,QAAM,eAAe,eAAe,KAAK,cAAc,EAAE,aAAa;AACtE,QAAM,cAAc,eAAe,KAAK,iBAAiB,EAAE,aAAa;AAExE,QAAM,iBAKF;AAAA,IACF,eAAe,EAAE,KAAK,aAAa;AAAA,IACnC,oBAAoB,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE;AAAA,IAC1D,QAAQ,EAAE,KAAK,EAAE;AAAA,EACnB;AAEA,MAAI,SAAS,eAAe;AAC1B,mBAAe,iBAAiB,EAAE,KAAK,SAAS,cAAc;AAAA,EAChE;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,aAAuD;AAAA,IACxE;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;AAeA,eAAsB,qCAAqC,MAIF;AACvD,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBAGF;AAAA,IACF,eAAe,EAAE,KAAK,QAAQ;AAAA,EAChC;AAEA,MAAI,SAAS,eAAe;AAC1B,mBAAe,qBAAqB;AAAA,MAClC,gBAAgB,EAAE,KAAK,SAAS,cAAc;AAAA,IAChD;AAAA,EACF;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,aAAwD;AAAA,IACzE;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;AAWA,eAAsB,4BAA4B,MAG9B;AAClB,QAAM,EAAE,aAAa,eAAe,IAAI;AAExC,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW,EAAE,QAAQ;AAAA,EACvB;AAEA,QAAM,OAAO,MAAM,aAA+C;AAAA,IAChE;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAID,SAAO,KAAK,+BAA+B,YAAY,KAAK,+BAA+B,UAAU,QAAQ;AAC/G;AAcA,eAAsB,qBAAqB,MAKvB;AAClB,QAAM,EAAE,aAAa,gBAAgB,UAAU,kBAAkB,IAAI;AAErE,MAAI,gBAAoC;AACxC,MAAI;AAEJ,MAAI,aAAa,UAAa,sBAAsB,QAAW;AAC7D,gBAAY,eAAe,KAAK,iBAAiB,EAAE,aAAa;AAAA,EAClE,WAAW,aAAa,UAAa,sBAAsB,QAAW;AAEpE,QAAI,aAAa,YAAY;AAC3B,kBAAY,eAAe,EAAE,aAAa;AAAA,IAC5C,OAAO;AACL,kBAAY,oBAAoB,eAAe,GAAG,QAAQ,EAAE,aAAa;AAAA,IAC3E;AAAA,EACF,WAAW,aAAa,UAAa,sBAAsB,QAAW;AACpE,UAAM,OAAO,eAAe,KAAK,iBAAiB;AAClD,gBAAY,KAAK,aAAa;AAC9B,QAAI,SAAS,eAAe,GAAG;AAC7B,sBAAgB;AAAA,IAClB;AAAA,EAGF,OAAO;AACL,UAAM,IAAI,MAAM,iEAAiE;AAAA,EACnF;AACA,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAGjE,MAAI,QAAa,EAAE,YAAY,EAAE,KAAK,UAAU,EAAE;AAClD,MAAI,kBAAkB,QAAW;AAC/B,YAAQ,EAAE,YAAY,EAAE,KAAK,CAAC,eAAe,SAAS,EAAE,EAAE;AAAA,EAC5D;AAEA,QAAM,OAAO,MAAM,oBAAoB;AAAA,IACrC;AAAA,IACA,gBAAgB;AAAA,IAChB,SAAS;AAAA,MACP;AAAA,IACF;AAAA,EACF,CAAC;AAID,SAAO,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE,SAAS;AACpC;AAeA,eAAsB,oBAAoB,MAID;AACvC,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBAAqD;AAAA,IACzD,GAAG,SAAS;AAAA,IACZ,eAAe,EAAE,KAAK,QAAQ;AAAA,EAChC;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,OAAO,MAAM,aAAuC;AAAA,IACxD;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;AAWA,eAAsB,qBAAqB,MAGvB;AAClB,QAAM,EAAE,aAAa,eAAe,IAAI;AACxC,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW,EAAE,QAAQ;AAAA,EACvB;AAEA,QAAM,OAAO,MAAM,aAAwC;AAAA,IACzD;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,MAAI,CAAC,KAAK,0CAA0C,WAAW;AAC7D,UAAM,MAAM,0CAA0C;AAAA,EACxD;AAEA,SAAO,KAAK,0CAA0C,UAAU;AAClE;AAeA,eAAsB,uBAAuB,MAIL;AACtC,QAAM,EAAE,aAAa,gBAAgB,QAAQ,IAAI;AACjD,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,aAAa;AAEjE,QAAM,iBAAqD;AAAA,IACzD,eAAe,EAAE,KAAK,QAAQ;AAAA,EAChC;AACA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,QAAQ,SAAS;AAAA,MACjB,OAAO,SAAS;AAAA,MAChB,UAAU,SAAS;AAAA,IACrB;AAAA,EACF;AACA,QAAM,OAAO,MAAM,aAAiC;AAAA,IAClD;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,SAAO,KAAK;AACd;AAkBA,eAAsB,4BAA4B,MAG7B;AACnB,QAAM,EAAE,aAAa,WAAW,IAAI;AACpC,QAAM,YAAY,IAAI,aAAa,WAAW,UAAU,CAAC;AAEzD,MAAI,sBAAsB,qBAAqB;AAE7C,UAAM,UAAU,kBAAkB,cAAc,EAAE,UAAU,CAAC;AAC7D,UAAM,UAAU,QAAQ,eAAe;AACvC,WAAO,QAAQ,eAAe,EAAE,YAAY,QAAQ,CAAC;AAAA,EACvD;AAEA,MAAI,sBAAsB,mBAAmB;AAE3C,UAAM,8CAA8C,kBAAkB,cAAc;AAAA,MAClF;AAAA,IACF,CAAC;AACD,UAAM,yCAAyC,MAAM,eAAe;AAAA,MAClE,SAAS;AAAA,MACT;AAAA,IACF,CAAC;AACD,QAAI,wCAAwC;AAC1C,YAAM,UAAU,4CAA4C,eAAe;AAC3E,aAAO,QAAQ,eAAe,EAAE,YAAY,SAAS,QAAQ,MAAM,CAAC;AAAA,IACtE;AAEA,UAAM,gBAAgB,kBAAkB,cAAc;AAAA,MACpD,WAAW,UAAU;AAAA,IACvB,CAAC;AACD,UAAM,kBAAkB,MAAM,eAAe,EAAE,SAAS,eAAe,YAAY,CAAC;AACpF,QAAI,iBAAiB;AACnB,YAAM,UAAU,cAAc,eAAe;AAC7C,aAAO,QAAQ,eAAe,EAAE,YAAY,SAAS,QAAQ,KAAK,CAAC;AAAA,IACrE;AAAA,EACF;AAGA,QAAM,IAAI,MAAM,yCAAyC,UAAU,EAAE;AACvE;AAaA,eAAsB,eAAe,MAAkF;AACrH,QAAM,EAAE,aAAa,QAAQ,IAAI;AACjC,QAAM,iBAAiB,MAAM,6BAA6B;AAAA,IACxD;AAAA,IACA,mBAAmB,QAAQ,eAAe;AAAA,EAC5C,CAAC;AAED,MAAI;AACF,UAAM,QAAQ;AAAA,MACZ;AAAA,MACA;AAAA,IACF,CAAC;AACD,WAAO;AAAA,EACT,SAAS,OAAY;AAEnB,QAAI,MAAM,WAAW,KAAK;AACxB,aAAO;AAAA,IACT;AACA,UAAM,IAAI,MAAM,2CAA2C,eAAe,SAAS,CAAC,EAAE;AAAA,EACxF;AACF;AAEA,eAAe,kCAAkC,MAG0C;AACzF,QAAM,EAAE,aAAa,SAAS,IAAI;AAClC,MAAI,SAAS,WAAW,GAAG;AACzB,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAEA,QAAM,iBAAkD;AAAA,IACtD,UAAU,EAAE,KAAK,SAAS,IAAI,CAAC,YAAY,QAAQ,SAAS,CAAC,EAAE;AAAA,EACjE;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,IACnB;AAAA,EACF;AACA,QAAM,EAAE,0BAA0B,KAAK,IAAI,MAAM,aAAyC;AAAA,IACxF;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,QAAM,oBAAoB,IAAI,IAAI,KAAK,IAAI,CAAC,UAAU,CAAC,MAAM,UAAU,KAAK,CAAC,CAAC;AAE9E,QAAM,SAAwF,CAAC;AAC/F,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK,GAAG;AAC3C,UAAM,QAAQ,kBAAkB,IAAI,SAAS,CAAC,EAAE,SAAS,CAAC;AAC1D,QAAI,CAAC,OAAO;AACV,YAAM,IAAI,MAAM,kDAAkD,SAAS,CAAC,CAAC,EAAE;AAAA,IACjF;AACA,UAAM,YAAY,wBAAwB,KAAK;AAC/C,WAAO,KAAK,EAAE,SAAS,SAAS,CAAC,GAAG,UAAU,CAAC;AAAA,EACjD;AAEA,SAAO;AACT;AAEA,SAAS,wBAAwB,MAAuE;AACtG,QAAM,qBAAqB,KAAK;AAChC,QAAM,iBAAiB,KAAK;AAC5B,QAAM,eAAe,KAAK;AAE1B,MAAI,iBAAiB,iBAAiB;AACpC,UAAM,oBAA6C,CAAC;AACpD,eAAW,OAAO,gBAAgB;AAChC,wBAAkB,KAAK,IAAI,iBAAiB,GAAG,CAAC;AAAA,IAClD;AACA,WAAO,IAAI,sBAAsB;AAAA,MAC/B,YAAY;AAAA,MACZ,WAAW;AAAA,IACb,CAAC;AAAA,EACH;AACA,MAAI,iBAAiB,aAAa;AAChC,UAAM,aAA+B,CAAC;AACtC,eAAW,OAAO,gBAAgB;AAChC,YAAM,eAAe,aAAa,QAAQ,GAAG;AAC7C,YAAM,eAAe,aAAa,wBAAwB;AAC1D,UAAI;AACJ,cAAQ,cAAc;AAAA,QACpB;AACE,sBAAY,IAAI,iBAAiB,aAAa,sBAAsB,EAAE,CAAC;AACvE;AAAA,QACF;AACE,sBAAY,IAAI,mBAAmB,aAAa,sBAAsB,EAAE,CAAC;AACzE;AAAA,QACF;AACE,sBAAY,iBAAiB,YAAY,YAAY;AACrD;AAAA,QACF;AACE,sBAAY,0BAA0B,YAAY,YAAY;AAC9D;AAAA,QACF;AACE,gBAAM,IAAI,MAAM,2CAA2C,YAAY,EAAE;AAAA,MAC7E;AACA,iBAAW,KAAK,IAAI,aAAa,SAAS,CAAC;AAAA,IAC7C;AACA,WAAO,IAAI,SAAS;AAAA,MAClB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AACA,QAAM,IAAI,MAAM,uBAAuB;AACzC;AAEA,eAAe,wBAAwB,MAIN;AAC/B,QAAM,EAAE,aAAa,WAAW,QAAQ,IAAI;AAC5C,QAAM,WAAW,SAAS,YAAY;AACtC,MAAI,UAAqB;AACzB,MAAI,qBAAqB,cAAc;AACrC,cAAU,UAAU;AAAA,EACtB;AACA,QAAM,iBAAsB;AAAA,IAC1B,YAAY,EAAE,KAAK,QAAQ,SAAS,EAAE;AAAA,IACtC,UAAU,EAAE,KAAK,SAAS;AAAA,EAC5B;AACA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,IACnB;AAAA,EACF;AACA,QAAM,EAAE,sBAAsB,KAAK,IAAI,MAAM,aAA2C;AAAA,IACtF;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,QAAM,aAAa,KAAK,KAAK,CAAC,GAAG,MAAM,OAAO,EAAE,wBAAwB,IAAI,OAAO,EAAE,wBAAwB,CAAC;AAC9G,QAAM,WAAW,WAAW,IAAI,CAAC,UAAU,IAAI,kBAAkB,EAAE,MAAM,MAAM,SAAS,CAAC,CAAC;AAC1F,SAAO;AACT;AAEA,eAAe,uCAAuC,MAGlC;AAClB,QAAM,EAAE,aAAa,eAAe,IAAI;AACxC,QAAM,UAAU,eAAe,KAAK,cAAc,EAAE,SAAS;AAE7D,QAAM,iBAAsB;AAAA,IAC1B,QAAQ,EAAE,KAAK,eAAe,SAAS,EAAE;AAAA,EAC3C;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,MACjB,OAAO;AAAA,MACP,UAAU,EAAE,qBAAqB,OAAO;AAAA,IAC1C;AAAA,EACF;AAEA,QAAM,EAAE,YAAY,KAAK,IAAI,MAAM,aAAiC;AAAA,IAClE;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AAED,MAAI,KAAK,WAAW,GAAG;AACrB,UAAM,IAAI,MAAM,0CAA0C,OAAO,SAAS,KAAK,MAAM,EAAE;AAAA,EACzF;AACA,SAAO,OAAO,KAAK,CAAC,EAAE,mBAAmB;AAC3C;AAEA,eAAe,+BAA+B,MAM5C;AACA,QAAM,EAAE,aAAa,SAAS,SAAS,IAAI;AAC3C,QAAM,WAAW,SAAS,YAAY;AACtC,MAAI,SAAS,WAAW,GAAG;AACzB,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAEA,QAAM,iBAAsB;AAAA,IAC1B,UAAU,EAAE,KAAK,SAAS,IAAI,CAAC,YAAY,QAAQ,SAAS,CAAC,EAAE;AAAA,IAC/D,UAAU,EAAE,KAAK,SAAS;AAAA,EAC5B;AAEA,QAAM,eAAe;AAAA,IACnB,OAAO;AAAA,IACP,WAAW;AAAA,MACT,iBAAiB;AAAA,IACnB;AAAA,EACF;AACA,QAAM,EAAE,4BAA4B,KAAK,IAAI,MAAM,aAAiD;AAAA,IAClG;AAAA,IACA,OAAO;AAAA,IACP,cAAc;AAAA,EAChB,CAAC;AACD,SAAO,KAAK,IAAI,CAAC,WAAW;AAAA,IAC1B,SAAS,IAAI,kBAAkB,EAAE,MAAM,MAAM,SAAS,CAAC;AAAA,IACvD,gBAAgB,IAAI,eAAe,IAAI,qBAAqB,MAAM,OAAO,CAAC;AAAA,IAC1E,UAAU,MAAM;AAAA,IAChB,wBAAwB,OAAO,MAAM,wBAAwB;AAAA,EAC/D,EAAE;AACJ;AAEA,eAAsB,wBAAwB,MAK5C;AACA,QAAM,EAAE,aAAa,UAAU,IAAI;AAEnC,MAAI,UAAqB;AACzB,MAAI,qBAAqB,cAAc;AACrC,cAAU,UAAU;AAAA,EACtB;AACA,QAAM,sBAA0C,CAAC;AACjD,MAAI,mBAAmB,kBAAkB;AACvC,wBAAoB,KAAK,OAAO;AAAA,EAClC;AACA,QAAM,eAAe,IAAI,aAAa,OAAO;AAC7C,sBAAoB,KAAK,YAAY;AAErC,QAAM,iCAAiC,oBAAoB,IAAI,CAAC,WAAW;AACzE,UAAM,UAAU,OAAO,QAAQ;AAC/B,WAAO,EAAE,SAAS,WAAW,OAAO;AAAA,EACtC,CAAC;AAED,QAAM,mBAAmB,MAAM,wBAAwB,EAAE,aAAa,UAAU,CAAC;AAEjF,QAAM,CAAC,eAAe,0BAA0B,IAAI,MAAM,QAAQ,IAAI;AAAA,IACpE,kCAAkC,EAAE,aAAa,UAAU,iBAAiB,CAAC;AAAA,IAC7E,+BAA+B;AAAA,MAC7B;AAAA,MACA,UAAU,iBAAiB,OAAO,+BAA+B,IAAI,CAAC,SAAS,KAAK,UAAU,QAAQ,CAAC,CAAC;AAAA,IAC1G,CAAC;AAAA,EACH,CAAC;AAED,QAAM,wBAAwB,+BAA+B,OAAO,aAAa;AAEjF,QAAM,SAKA,CAAC;AACP,QAAM,qBAAqB,IAAI,IAAI,sBAAsB,IAAI,CAAC,SAAS,CAAC,KAAK,QAAQ,SAAS,GAAG,KAAK,SAAS,CAAC,CAAC;AACjH,aAAW,6BAA6B,4BAA4B;AAClE,QAAI,CAAC,mBAAmB,IAAI,0BAA0B,QAAQ,SAAS,CAAC,GAAG;AACzE,YAAM,IAAI,MAAM,6CAA6C,0BAA0B,OAAO,GAAG;AAAA,IACnG;AACA,WAAO,KAAK;AAAA,MACV,gBAAgB,0BAA0B;AAAA,MAC1C,WAAW,mBAAmB,IAAI,0BAA0B,QAAQ,SAAS,CAAC;AAAA,MAC9E,UAAU,0BAA0B;AAAA,MACpC,wBAAwB,0BAA0B;AAAA,IACpD,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAEA,eAAsB,+BAA+B,MAG9B;AACrB,QAAM,EAAE,aAAa,eAAe,IAAI;AAExC,QAAM,cAAc,MAAM,QAAQ,EAAE,aAAa,eAAe,CAAC;AAEjE,QAAM,yBAAyB,MAAM,uCAAuC;AAAA,IAC1E;AAAA,IACA;AAAA,EACF,CAAC;AACD,UAAQ,IAAI,0BAA0B,sBAAsB;AAE5D,QAAM,cAAc,MAAM,wBAAwB,EAAE,aAAa,eAAe,uBAAuB,CAAC;AACxG,MAAI,CAAC,0BAA0B,WAAW,GAAG;AAC3C,UAAM,IAAI,MAAM,uCAAuC;AAAA,EACzD;AAEA,QAAM,EAAE,UAAU,IAAI;AACtB,MAAI,CAAC,WAAW;AACd,UAAM,IAAI,MAAM,8BAA8B;AAAA,EAChD;AAEA,MAAI;AACJ,MAAI,mBAAmB,SAAS,GAAG;AACjC,gBAAY,IAAI,iBAAiB,UAAU,UAAU;AAAA,EACvD,WAAW,wBAAwB,SAAS,GAAG;AAC7C,gBAAY,IAAI,sBAAsB;AAAA,MACpC,YAAY,UAAU,YAAY,IAAI,CAAC,OAAO,IAAI,iBAAiB,EAAE,CAAC;AAAA,MACtE,WAAW,UAAU;AAAA,IACvB,CAAC;AAAA,EACH,WAAW,iCAAiC,SAAS,GAAG;AACtD,gBAAY,eAAe,UAAU,UAAU;AAAA,EACjD,WAAW,gCAAgC,SAAS,GAAG;AACrD,UAAM,aAA+B,CAAC;AACtC,eAAW,MAAM,UAAU,aAAa;AACtC,iBAAW,KAAK,eAAe,EAAE,CAAC;AAAA,IACpC;AACA,gBAAY,IAAI,SAAS;AAAA,MACvB;AAAA,MACA,oBAAoB,UAAU;AAAA,IAChC,CAAC;AAAA,EACH,OAAO;AACL,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AACA,MAAI,UAAU,QAAQ,EAAE,SAAS,MAAM,YAAY,oBAAoB;AACrE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAsB,iCAAiC,MAGT;AAC5C,QAAM,EAAE,aAAa,QAAQ,IAAI;AAEjC,QAAM,SAAS,MAAM,kCAAkC,EAAE,aAAa,UAAU,CAAC,OAAO,EAAE,CAAC;AAE3F,MAAI,OAAO,WAAW,GAAG;AACvB,UAAM,IAAI,MAAM,sDAAsD,OAAO,EAAE;AAAA,EACjF;AACA,MAAI,OAAO,SAAS,GAAG;AAErB,UAAM,IAAI,MAAM,iEAAiE,OAAO,EAAE;AAAA,EAC5F;AAEA,SAAO,OAAO,CAAC,EAAE;AACnB;AAgCA,SAAS,eAAe,MAAqD;AAC3E,MAAI,KAAK,SAAS,WAAW;AAC3B,UAAM,eAAe,aAAa,QAAQ,KAAK,KAAK;AACpD,WAAO,IAAI,aAAa,iBAAiB,YAAY,YAAY,CAAC;AAAA,EACpE;AACA,MAAI,KAAK,SAAS,WAAW;AAC3B,WAAO,IAAI,aAAa,IAAI,iBAAiB,KAAK,KAAK,CAAC;AAAA,EAC1D;AACA,MAAI,KAAK,SAAS,mBAAmB;AACnC,WAAO,IAAI,aAAa,IAAI,mBAAmB,KAAK,KAAK,CAAC;AAAA,EAC5D;AACA,QAAM,IAAI,MAAM,yBAAyB;AAC3C;","names":[]}