@aptos-labs/ts-sdk 5.1.1-side-effect-free.1 → 5.1.2

package/dist/esm/transactions/transactionBuilder/transactionBuilder.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transactions/transactionBuilder/transactionBuilder.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file handles the transaction creation lifecycle.\n * It holds different operations to generate a transaction payload, a raw transaction,\n * and a signed transaction that can be simulated, signed and submitted to chain.\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput, Hex, PublicKey } from \"../../core\";\nimport {\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/utils\";\nimport { getLedgerInfo } from \"../../internal/general\";\nimport { getGasPriceEstimation } from \"../../internal/transaction\";\nimport { NetworkToChainId } from \"../../utils/apiEndpoints\";\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  TransactionInnerPayload,\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\";\nimport {\n  TransactionExecutable,\n  TransactionExecutableEmpty,\n  TransactionExecutableEntryFunction,\n  TransactionExecutableScript,\n  TransactionExtraConfigV1,\n  TransactionInnerPayloadV1,\n} from \"../instances/transactionPayload\";\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  if (options?.replayProtectionNonce !== undefined && options?.accountSequenceNumber !== undefined) {\n    throw new Error(\"Cannot specify both replayProtectionNonce and accountSequenceNumber in options.\");\n  }\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      } else if (options?.replayProtectionNonce !== undefined) {\n        // If replay nonce is provided, use it as the sequence number\n        // This is an unused value, so it's specifically to show that the sequence number is not used\n        return 0xdeadbeefn;\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, replayProtectionNonce } = {\n    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(aptosConfig.getDefaultMaxGasAmount()),\n    gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),\n    expireTimestamp:\n      options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow()),\n    replayProtectionNonce: options?.replayProtectionNonce ? BigInt(options.replayProtectionNonce) : undefined,\n  };\n\n  // If we're using replay nonce, we must convert the original payload\n  let txnPayload = payload;\n  if (replayProtectionNonce !== undefined) {\n    txnPayload = convertPayloadToInnerPayload(payload, replayProtectionNonce);\n  }\n\n  return new RawTransaction(\n    AccountAddress.from(sender),\n    BigInt(sequenceNumber),\n    txnPayload,\n    BigInt(maxGasAmount),\n    BigInt(gasUnitPrice),\n    BigInt(expireTimestamp),\n    new ChainId(chainId),\n  );\n}\n\nexport function convertPayloadToInnerPayload(\n  payload: AnyTransactionPayloadInstance,\n  replayProtectionNonce?: bigint,\n): TransactionInnerPayload {\n  if (payload instanceof TransactionPayloadScript) {\n    return new TransactionInnerPayloadV1(\n      new TransactionExecutableScript(payload.script),\n      new TransactionExtraConfigV1(undefined, replayProtectionNonce),\n    );\n  } else if (payload instanceof TransactionPayloadEntryFunction) {\n    return new TransactionInnerPayloadV1(\n      new TransactionExecutableEntryFunction(payload.entryFunction),\n      new TransactionExtraConfigV1(undefined, replayProtectionNonce),\n    );\n  } else if (payload instanceof TransactionPayloadMultiSig) {\n    const innerPayload = payload.multiSig.transaction_payload;\n    let executable: TransactionExecutable;\n    if (innerPayload === undefined || innerPayload?.transaction_payload === undefined) {\n      executable = new TransactionExecutableEmpty();\n    } else if (innerPayload.transaction_payload instanceof EntryFunction) {\n      executable = new TransactionExecutableEntryFunction(innerPayload.transaction_payload);\n    } else {\n      // TODO For now, scripts are not supported in multi-sig transactions, so it's always entry function\n      throw new Error(\"Scripts are not supported in multi-sig transactions.\");\n    }\n\n    return new TransactionInnerPayloadV1(\n      executable,\n      new TransactionExtraConfigV1(payload.multiSig.multisig_address, replayProtectionNonce),\n    );\n  } else {\n    throw new Error(`Unsupported payload type: ${payload}`);\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((pubKey) => {\n          if (KeylessPublicKey.isInstance(pubKey.publicKey) || FederatedKeylessPublicKey.isInstance(pubKey.publicKey)) {\n            return new AnySignature(KeylessSignature.getSimulationSignature());\n          }\n          return new AnySignature(invalidSignature);\n        }),\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":["sha3Hash","AccountAddress","Hex","AnyPublicKey","AnySignature","KeylessPublicKey","KeylessSignature","Secp256k1PublicKey","FederatedKeylessPublicKey","MultiKey","MultiKeySignature","Ed25519PublicKey","Ed25519Signature","getInfo","getLedgerInfo","getGasPriceEstimation","NetworkToChainId","normalizeBundle","AccountAuthenticator","AccountAuthenticatorEd25519","AccountAuthenticatorMultiEd25519","AccountAuthenticatorMultiKey","AccountAuthenticatorNoAccountAuthenticator","AccountAuthenticatorSingleKey","TransactionAuthenticatorEd25519","TransactionAuthenticatorFeePayer","TransactionAuthenticatorMultiAgent","TransactionAuthenticatorMultiEd25519","TransactionAuthenticatorSingleSender","ChainId","EntryFunction","FeePayerRawTransaction","MultiAgentRawTransaction","MultiSig","MultiSigTransactionPayload","RawTransaction","Script","TransactionPayloadEntryFunction","TransactionPayloadMultiSig","TransactionPayloadScript","SignedTransaction","convertArgument","fetchEntryFunctionAbi","fetchViewFunctionAbi","standardizeTypeTags","memoizeAsync","isScriptDataInput","SimpleTransaction","MultiAgentTransaction","getFunctionParts","TransactionExecutableEmpty","TransactionExecutableEntryFunction","TransactionExecutableScript","TransactionExtraConfigV1","TransactionInnerPayloadV1","generateTransactionPayload","args","generateTransactionPayloadScript","moduleAddress","moduleName","functionName","functionAbi","fetchAbi","generateTransactionPayloadWithABI","typeArguments","functionArguments","arg","i","entryFunctionPayload","multisigAddress","generateViewFunctionPayload","generateViewFunctionPayloadWithABI","generateRawTransaction","aptosConfig","sender","payload","options","feePayerAddress","getChainId","getGasUnitPrice","getSequenceNumberForAny","getSequenceNumber","chainId","gasEstimate","sequenceNumber","maxGasAmount","gasUnitPrice","expireTimestamp","replayProtectionNonce","txnPayload","convertPayloadToInnerPayload","innerPayload","executable","buildTransaction","rawTxn","signers","signer","generateSignedTransactionForSimulation","signerPublicKey","transaction","secondarySignersPublicKeys","feePayerPublicKey","accountAuthenticator","getAuthenticatorForSimulation","transactionToSign","secondaryAccountAuthenticators","publicKey","feePayerAuthenticator","transactionAuthenticator","accountPublicKey","invalidSignature","pubKey","_","generateSignedTransaction","additionalSignersAuthenticators","senderAuthenticator","txnAuthenticator","hashValues","input","hash","item","TRANSACTION_PREFIX","generateUserTransactionHash","signedTransaction","key","abi","fetch"]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/transactions/typeTag/index.mjs

@@ -1,2 +1,2 @@
-import{Serializable as m}from"../../bcs/serializer";import{AccountAddress as n}from"../../core";import{Identifier as a}from"../instances/identifier";import{TypeTagVariants as r}from"../../types";class t extends m{deserialize(e){const i=n.deserialize(e),s=a.deserialize(e),l=a.deserialize(e),v=e.deserializeVector(t);return new o(i,s,l,v)}static deserialize(e){const i=e.deserializeUleb128AsU32();switch(i){case r.Bool:return u.load(e);case r.U8:return c.load(e);case r.U64:return p.load(e);case r.U128:return T.load(e);case r.Address:return h.load(e);case r.Signer:return y.load(e);case r.Vector:return U.load(e);case r.Struct:return f.load(e);case r.U16:return d.load(e);case r.U32:return g.load(e);case r.U256:return z.load(e);case r.Generic:return S.load(e);default:throw new Error(`Unknown variant index for TypeTag: ${i}`)}}isBool(){return this instanceof u}isAddress(){return this instanceof h}isGeneric(){return this instanceof S}isSigner(){return this instanceof y}isVector(){return this instanceof U}isStruct(){return this instanceof f}isU8(){return this instanceof c}isU16(){return this instanceof d}isU32(){return this instanceof g}isU64(){return this instanceof p}isU128(){return this instanceof T}isU256(){return this instanceof z}isPrimitive(){return this instanceof y||this instanceof h||this instanceof u||this instanceof c||this instanceof d||this instanceof g||this instanceof p||this instanceof T||this instanceof z}}class u extends t{toString(){return"bool"}serialize(e){e.serializeU32AsUleb128(r.Bool)}static load(e){return new u}}class c extends t{toString(){return"u8"}serialize(e){e.serializeU32AsUleb128(r.U8)}static load(e){return new c}}class d extends t{toString(){return"u16"}serialize(e){e.serializeU32AsUleb128(r.U16)}static load(e){return new d}}class g extends t{toString(){return"u32"}serialize(e){e.serializeU32AsUleb128(r.U32)}static load(e){return new g}}class p extends t{toString(){return"u64"}serialize(e){e.serializeU32AsUleb128(r.U64)}static load(e){return new p}}class T extends t{toString(){return"u128"}serialize(e){e.serializeU32AsUleb128(r.U128)}static load(e){return new T}}class z extends t{toString(){return"u256"}serialize(e){e.serializeU32AsUleb128(r.U256)}static load(e){return new z}}class h extends t{toString(){return"address"}serialize(e){e.serializeU32AsUleb128(r.Address)}static load(e){return new h}}class y extends t{toString(){return"signer"}serialize(e){e.serializeU32AsUleb128(r.Signer)}static load(e){return new y}}class x extends t{constructor(i){super();this.value=i}toString(){return`&${this.value.toString()}`}serialize(i){i.serializeU32AsUleb128(r.Reference)}static load(i){const s=t.deserialize(i);return new x(s)}}class S extends t{constructor(i){super();this.value=i;if(i<0)throw new Error("Generic type parameter index cannot be negative")}toString(){return`T${this.value}`}serialize(i){i.serializeU32AsUleb128(r.Generic),i.serializeU32(this.value)}static load(i){const s=i.deserializeU32();return new S(s)}}class U extends t{constructor(i){super();this.value=i}toString(){return`vector<${this.value.toString()}>`}static u8(){return new U(new c)}serialize(i){i.serializeU32AsUleb128(r.Vector),this.value.serialize(i)}static load(i){const s=t.deserialize(i);return new U(s)}}class f extends t{constructor(i){super();this.value=i}toString(){let i="";return this.value.typeArgs.length>0&&(i=`<${this.value.typeArgs.map(s=>s.toString()).join(", ")}>`),`${this.value.address.toString()}::${this.value.moduleName.identifier}::${this.value.name.identifier}${i}`}serialize(i){i.serializeU32AsUleb128(r.Struct),this.value.serialize(i)}static load(i){const s=o.deserialize(i);return new f(s)}isTypeTag(i,s,l){return this.value.moduleName.identifier===s&&this.value.name.identifier===l&&this.value.address.equals(i)}isString(){return this.isTypeTag(n.ONE,"string","String")}isOption(){return this.isTypeTag(n.ONE,"option","Option")}isObject(){return this.isTypeTag(n.ONE,"object","Object")}isDelegationKey(){return this.isTypeTag(n.ONE,"permissioned_delegation","DelegationKey")}isRateLimiter(){return this.isTypeTag(n.ONE,"rate_limiter","RateLimiter")}}class o extends m{constructor(e,i,s,l){super(),this.address=e,this.moduleName=i,this.name=s,this.typeArgs=l}serialize(e){e.serialize(this.address),e.serialize(this.moduleName),e.serialize(this.name),e.serializeVector(this.typeArgs)}static deserialize(e){const i=n.deserialize(e),s=a.deserialize(e),l=a.deserialize(e),v=e.deserializeVector(t);return new o(i,s,l,v)}}function V(){return new o(n.ONE,new a("aptos_coin"),new a("AptosCoin"),[])}function j(){return new o(n.ONE,new a("string"),new a("String"),[])}function G(b){return new o(n.ONE,new a("option"),new a("Option"),[b])}function B(b){return new o(n.ONE,new a("object"),new a("Object"),[b])}export{o as StructTag,t as TypeTag,h as TypeTagAddress,u as TypeTagBool,S as TypeTagGeneric,x as TypeTagReference,y as TypeTagSigner,f as TypeTagStruct,T as TypeTagU128,d as TypeTagU16,z as TypeTagU256,g as TypeTagU32,p as TypeTagU64,c as TypeTagU8,U as TypeTagVector,V as aptosCoinStructTag,B as objectStructTag,G as optionStructTag,j as stringStructTag};
+import{ca as a,da as b,ea as c,fa as d,ga as e,ha as f,ia as g,ja as h,ka as i,la as j,ma as k,na as l,oa as m,pa as n,qa as o,ra as p,sa as q,ta as r,ua as s}from"../../chunk-PJTG745G.mjs";import"../../chunk-A5L76YP7.mjs";import"../../chunk-5HXLZHDW.mjs";import"../../chunk-GOXRBEIJ.mjs";import"../../chunk-XJJVJOX5.mjs";import"../../chunk-QNARIAVM.mjs";import"../../chunk-2PASUPUO.mjs";import"../../chunk-C3Q23D22.mjs";import"../../chunk-NECL5FCQ.mjs";import"../../chunk-4QMXOWHP.mjs";import"../../chunk-RQX6JOEN.mjs";import"../../chunk-WSR5EBJM.mjs";import"../../chunk-WCMW2L3P.mjs";import"../../chunk-V74WPKSY.mjs";import"../../chunk-UYVPNUH3.mjs";import"../../chunk-G3MHXDYA.mjs";import"../../chunk-626KB2UQ.mjs";import"../../chunk-XKUIMGKU.mjs";import"../../chunk-N6YTF76Q.mjs";import"../../chunk-FGFLPH5K.mjs";import"../../chunk-QREVMGQZ.mjs";import"../../chunk-V3MBJJTL.mjs";import"../../chunk-ZP4DWSQA.mjs";import"../../chunk-2OPKZKOB.mjs";import"../../chunk-FC72YL4B.mjs";import"../../chunk-YS5IUILF.mjs";import"../../chunk-PSSIJHHC.mjs";import"../../chunk-YOZBVVKL.mjs";import"../../chunk-R7FWJP3N.mjs";import"../../chunk-UL777LTI.mjs";import"../../chunk-7ECCT6PK.mjs";import"../../chunk-AQW4BUKF.mjs";import"../../chunk-E2U27PNC.mjs";import"../../chunk-LAPXUUHK.mjs";import"../../chunk-HGLO5LDS.mjs";import"../../chunk-CW35YAMN.mjs";import"../../chunk-YZHAI55C.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-TOBQ5UE6.mjs";import"../../chunk-MT2RJ7H3.mjs";import"../../chunk-Q4W3WJ2U.mjs";import"../../chunk-ORMOQWWH.mjs";import"../../chunk-FLZPUYXQ.mjs";import"../../chunk-LA56UDUK.mjs";import"../../chunk-ZYE7UTJZ.mjs";import"../../chunk-RGKRCZ36.mjs";import"../../chunk-FD6FGKYY.mjs";import"../../chunk-MCFQE4GC.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-EBMEXURY.mjs";import"../../chunk-STY74NUA.mjs";import"../../chunk-IF4UU2MT.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-NCKJ7X57.mjs";import"../../chunk-P5HCJN3A.mjs";import"../../chunk-OLILO7VD.mjs";import"../../chunk-H3EP5CGP.mjs";import"../../chunk-KDMSOCZY.mjs";export{o as StructTag,a as TypeTag,i as TypeTagAddress,b as TypeTagBool,l as TypeTagGeneric,k as TypeTagReference,j as TypeTagSigner,n as TypeTagStruct,g as TypeTagU128,d as TypeTagU16,h as TypeTagU256,e as TypeTagU32,f as TypeTagU64,c as TypeTagU8,m as TypeTagVector,p as aptosCoinStructTag,s as objectStructTag,r as optionStructTag,q as stringStructTag};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/transactions/typeTag/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transactions/typeTag/index.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable class-methods-use-this */\n/* eslint-disable max-classes-per-file */\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"../instances/identifier\";\nimport { TypeTagVariants } from \"../../types\";\n\n/**\n * Represents a type tag in the serialization framework, serving as a base class for various specific type tags.\n * This class provides methods for serialization and deserialization of type tags, as well as type checking methods\n * to determine the specific type of the tag at runtime.\n *\n * @extends Serializable\n * @group Implementation\n * @category Transactions\n */\nexport abstract class TypeTag extends Serializable {\n  abstract serialize(serializer: Serializer): void;\n\n  /**\n   * Deserializes a StructTag from the provided deserializer.\n   * This function allows you to reconstruct a StructTag object from its serialized form.\n   *\n   * @param deserializer - The deserializer instance used to read the serialized data.\n   * @group Implementation\n   * @category Transactions\n   */\n  deserialize(deserializer: Deserializer): StructTag {\n    const address = AccountAddress.deserialize(deserializer);\n    const moduleName = Identifier.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    const typeArgs = deserializer.deserializeVector(TypeTag);\n    return new StructTag(address, moduleName, name, typeArgs);\n  }\n\n  static deserialize(deserializer: Deserializer): TypeTag {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case TypeTagVariants.Bool:\n        return TypeTagBool.load(deserializer);\n      case TypeTagVariants.U8:\n        return TypeTagU8.load(deserializer);\n      case TypeTagVariants.U64:\n        return TypeTagU64.load(deserializer);\n      case TypeTagVariants.U128:\n        return TypeTagU128.load(deserializer);\n      case TypeTagVariants.Address:\n        return TypeTagAddress.load(deserializer);\n      case TypeTagVariants.Signer:\n        return TypeTagSigner.load(deserializer);\n      case TypeTagVariants.Vector:\n        return TypeTagVector.load(deserializer);\n      case TypeTagVariants.Struct:\n        return TypeTagStruct.load(deserializer);\n      case TypeTagVariants.U16:\n        return TypeTagU16.load(deserializer);\n      case TypeTagVariants.U32:\n        return TypeTagU32.load(deserializer);\n      case TypeTagVariants.U256:\n        return TypeTagU256.load(deserializer);\n      case TypeTagVariants.Generic:\n        // This is only used for ABI representation, and cannot actually be used as a type.\n        return TypeTagGeneric.load(deserializer);\n      default:\n        throw new Error(`Unknown variant index for TypeTag: ${index}`);\n    }\n  }\n\n  abstract toString(): string;\n\n  /**\n   * Determines if the current instance is of type TypeTagBool.\n   *\n   * @returns {boolean} True if the instance is a TypeTagBool, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isBool(): this is TypeTagBool {\n    return this instanceof TypeTagBool;\n  }\n\n  /**\n   * Determines if the current instance is of type TypeTagAddress.\n   *\n   * @returns {boolean} True if the instance is a TypeTagAddress, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isAddress(): this is TypeTagAddress {\n    return this instanceof TypeTagAddress;\n  }\n\n  /**\n   * Determines if the current instance is of type TypeTagGeneric.\n   *\n   * @returns {boolean} Returns true if the instance is a TypeTagGeneric, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isGeneric(): this is TypeTagGeneric {\n    return this instanceof TypeTagGeneric;\n  }\n\n  /**\n   * Determine if the current instance is a TypeTagSigner.\n   *\n   * @returns {boolean} Returns true if the instance is a TypeTagSigner, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isSigner(): this is TypeTagSigner {\n    return this instanceof TypeTagSigner;\n  }\n\n  /**\n   * Checks if the current instance is a vector type.\n   * This can help determine the specific type of data structure being used.\n   *\n   * @returns {boolean} True if the instance is of type TypeTagVector, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isVector(): this is TypeTagVector {\n    return this instanceof TypeTagVector;\n  }\n\n  /**\n   * Determines if the current instance is a structure type.\n   *\n   * @returns {boolean} True if the instance is of type TypeTagStruct, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isStruct(): this is TypeTagStruct {\n    return this instanceof TypeTagStruct;\n  }\n\n  /**\n   * Determines if the current instance is of type `TypeTagU8`.\n   *\n   * @returns {boolean} Returns true if the instance is of type `TypeTagU8`, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU8(): this is TypeTagU8 {\n    return this instanceof TypeTagU8;\n  }\n\n  /**\n   * Checks if the current instance is of type TypeTagU16.\n   *\n   * @returns {boolean} True if the instance is TypeTagU16, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU16(): this is TypeTagU16 {\n    return this instanceof TypeTagU16;\n  }\n\n  /**\n   * Checks if the current instance is of type TypeTagU32.\n   *\n   * @returns {boolean} Returns true if the instance is TypeTagU32, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU32(): this is TypeTagU32 {\n    return this instanceof TypeTagU32;\n  }\n\n  /**\n   * Checks if the current instance is of type TypeTagU64.\n   *\n   * @returns {boolean} True if the instance is a TypeTagU64, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU64(): this is TypeTagU64 {\n    return this instanceof TypeTagU64;\n  }\n\n  /**\n   * Determines if the current instance is of the TypeTagU128 type.\n   *\n   * @returns {boolean} True if the instance is of TypeTagU128, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU128(): this is TypeTagU128 {\n    return this instanceof TypeTagU128;\n  }\n\n  /**\n   * Checks if the current instance is of type TypeTagU256.\n   *\n   * @returns {boolean} Returns true if the instance is of type TypeTagU256, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isU256(): this is TypeTagU256 {\n    return this instanceof TypeTagU256;\n  }\n\n  isPrimitive(): boolean {\n    return (\n      this instanceof TypeTagSigner ||\n      this instanceof TypeTagAddress ||\n      this instanceof TypeTagBool ||\n      this instanceof TypeTagU8 ||\n      this instanceof TypeTagU16 ||\n      this instanceof TypeTagU32 ||\n      this instanceof TypeTagU64 ||\n      this instanceof TypeTagU128 ||\n      this instanceof TypeTagU256\n    );\n  }\n}\n\n/**\n * Represents a boolean type tag in the type system.\n * This class extends the base TypeTag class and provides\n * methods for serialization and deserialization of the boolean\n * type tag.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagBool extends TypeTag {\n  /**\n   * Returns the string representation of the object.\n   *\n   * @returns {string} The string representation of the object.\n   * @group Implementation\n   * @category Transactions\n   */\n  toString(): string {\n    return \"bool\";\n  }\n\n  /**\n   * Serializes the current instance's properties into a provided serializer.\n   * This function ensures that the address, module name, name, and type arguments are properly serialized.\n   *\n   * @param serializer - The serializer instance used to serialize the properties.\n   * @group Implementation\n   * @category Transactions\n   */\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Bool);\n  }\n\n  /**\n   * Deserializes a StructTag and returns a new TypeTagStruct instance.\n   *\n   * @param _deserializer - The deserializer used to read the StructTag data.\n   * @group Implementation\n   * @category Transactions\n   */\n  static load(_deserializer: Deserializer): TypeTagBool {\n    return new TypeTagBool();\n  }\n}\n\n/**\n * Represents a type tag for an 8-bit unsigned integer (u8).\n * This class extends the base TypeTag class and provides methods\n * for serialization and deserialization specific to the u8 type.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU8 extends TypeTag {\n  toString(): string {\n    return \"u8\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U8);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU8 {\n    return new TypeTagU8();\n  }\n}\n\n/**\n * Represents a type tag for unsigned 16-bit integers (u16).\n * This class extends the base TypeTag class and provides methods for serialization and deserialization.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU16 extends TypeTag {\n  toString(): string {\n    return \"u16\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U16);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU16 {\n    return new TypeTagU16();\n  }\n}\n\n/**\n * Represents a type tag for a 32-bit unsigned integer (u32).\n * This class extends the base TypeTag class and provides methods for serialization\n * and deserialization specific to the u32 type.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU32 extends TypeTag {\n  toString(): string {\n    return \"u32\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U32);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU32 {\n    return new TypeTagU32();\n  }\n}\n\n/**\n * Represents a type tag for 64-bit unsigned integers (u64).\n * This class extends the base TypeTag class and provides methods for serialization and deserialization.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU64 extends TypeTag {\n  toString(): string {\n    return \"u64\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U64);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU64 {\n    return new TypeTagU64();\n  }\n}\n\n/**\n * Represents a type tag for the u128 data type.\n * This class extends the base TypeTag class and provides methods for serialization and deserialization.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU128 extends TypeTag {\n  toString(): string {\n    return \"u128\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U128);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU128 {\n    return new TypeTagU128();\n  }\n}\n\n/**\n * Represents a type tag for the U256 data type.\n * This class extends the base TypeTag class and provides methods for serialization and deserialization.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagU256 extends TypeTag {\n  toString(): string {\n    return \"u256\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.U256);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagU256 {\n    return new TypeTagU256();\n  }\n}\n\n/**\n * Represents a type tag for an address in the system.\n * This class extends the TypeTag class and provides functionality\n * to serialize the address type and load it from a deserializer.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagAddress extends TypeTag {\n  toString(): string {\n    return \"address\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Address);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagAddress {\n    return new TypeTagAddress();\n  }\n}\n\n/**\n * Represents a type tag for a signer in the system.\n * This class extends the base TypeTag and provides specific functionality\n * related to the signer type.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagSigner extends TypeTag {\n  toString(): string {\n    return \"signer\";\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Signer);\n  }\n\n  static load(_deserializer: Deserializer): TypeTagSigner {\n    return new TypeTagSigner();\n  }\n}\n\n/**\n * Represents a reference to a type tag in the type system.\n * This class extends the TypeTag class and provides functionality\n * to serialize and deserialize type tag references.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagReference extends TypeTag {\n  toString(): `&${string}` {\n    return `&${this.value.toString()}`;\n  }\n\n  /**\n   * Initializes a new instance of the class with the specified parameters.\n   *\n   * @param value - The TypeTag to reference.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(public readonly value: TypeTag) {\n    super();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Reference);\n  }\n\n  static load(deserializer: Deserializer): TypeTagReference {\n    const value = TypeTag.deserialize(deserializer);\n    return new TypeTagReference(value);\n  }\n}\n\n/**\n * Represents a generic type tag used for type parameters in entry functions.\n * Generics are not serialized into a real type, so they cannot be used as a type directly.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagGeneric extends TypeTag {\n  toString(): `T${number}` {\n    return `T${this.value}`;\n  }\n\n  constructor(public readonly value: number) {\n    super();\n    if (value < 0) throw new Error(\"Generic type parameter index cannot be negative\");\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Generic);\n    serializer.serializeU32(this.value);\n  }\n\n  static load(deserializer: Deserializer): TypeTagGeneric {\n    const value = deserializer.deserializeU32();\n    return new TypeTagGeneric(value);\n  }\n}\n\n/**\n * Represents a vector type tag, which encapsulates a single type tag value.\n * This class extends the base TypeTag class and provides methods for serialization,\n * deserialization, and string representation of the vector type tag.\n *\n * @extends TypeTag\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagVector extends TypeTag {\n  toString(): `vector<${string}>` {\n    return `vector<${this.value.toString()}>`;\n  }\n\n  constructor(public readonly value: TypeTag) {\n    super();\n  }\n\n  /**\n   * Creates a new TypeTagVector instance with a TypeTagU8 type.\n   *\n   * @returns {TypeTagVector} A new TypeTagVector initialized with TypeTagU8.\n   * @group Implementation\n   * @category Transactions\n   */\n  static u8(): TypeTagVector {\n    return new TypeTagVector(new TypeTagU8());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Vector);\n    this.value.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TypeTagVector {\n    const value = TypeTag.deserialize(deserializer);\n    return new TypeTagVector(value);\n  }\n}\n\n/**\n * Represents a structured type tag in the system, extending the base TypeTag class.\n * This class encapsulates information about a specific structure, including its address,\n * module name, and type arguments, and provides methods for serialization and type checking.\n *\n * @param value - The StructTag instance containing the details of the structured type.\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagStruct extends TypeTag {\n  toString(): `0x${string}::${string}::${string}` {\n    // Collect type args and add it if there are any\n    let typePredicate = \"\";\n    if (this.value.typeArgs.length > 0) {\n      typePredicate = `<${this.value.typeArgs.map((typeArg) => typeArg.toString()).join(\", \")}>`;\n    }\n\n    return `${this.value.address.toString()}::${this.value.moduleName.identifier}::${\n      this.value.name.identifier\n    }${typePredicate}`;\n  }\n\n  constructor(public readonly value: StructTag) {\n    super();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeU32AsUleb128(TypeTagVariants.Struct);\n    this.value.serialize(serializer);\n  }\n\n  static load(deserializer: Deserializer): TypeTagStruct {\n    const value = StructTag.deserialize(deserializer);\n    return new TypeTagStruct(value);\n  }\n\n  /**\n   * Determines if the provided address, module name, and struct name match the current type tag.\n   *\n   * @param address - The account address to compare against the type tag.\n   * @param moduleName - The name of the module to compare against the type tag.\n   * @param structName - The name of the struct to compare against the type tag.\n   * @returns True if the address, module name, and struct name match the type tag; otherwise, false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean {\n    return (\n      this.value.moduleName.identifier === moduleName &&\n      this.value.name.identifier === structName &&\n      this.value.address.equals(address)\n    );\n  }\n\n  /**\n   * Checks if the provided value is of type string.\n   * This function can help ensure that the data being processed is in the correct format before further operations.\n   *\n   * @returns {boolean} Returns true if the value is a string, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isString(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"string\", \"String\");\n  }\n\n  /**\n   * Checks if the specified account address is of type \"option\".\n   *\n   * @returns {boolean} Returns true if the account address is an option type, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isOption(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"option\", \"Option\");\n  }\n\n  /**\n   * Checks if the provided value is of type 'object'.\n   * This function helps determine if a value can be treated as an object type in the context of the SDK.\n   *\n   * @returns {boolean} Returns true if the value is an object, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isObject(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"object\", \"Object\");\n  }\n\n  /**\n   * Checks if the provided value is a 'DelegationKey' for permissioned signers.\n   *\n   * @returns {boolean} Returns true if the value is a DelegationKey, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isDelegationKey(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"permissioned_delegation\", \"DelegationKey\");\n  }\n\n  /**\n   * Checks if the provided value is of type `RateLimiter`.\n   *\n   * @returns {boolean} Returns true if the value is a RateLimiter, otherwise false.\n   * @group Implementation\n   * @category Transactions\n   */\n  isRateLimiter(): boolean {\n    return this.isTypeTag(AccountAddress.ONE, \"rate_limiter\", \"RateLimiter\");\n  }\n}\n\n/**\n * Represents a structured tag that includes an address, module name,\n * name, and type arguments. This class is used to define and manage\n * structured data types within the SDK.\n *\n * @property {AccountAddress} address - The address associated with the struct tag.\n * @property {Identifier} moduleName - The name of the module that contains the struct.\n * @property {Identifier} name - The name of the struct.\n * @property {Array<TypeTag>} typeArgs - An array of type arguments associated with the struct.\n * @group Implementation\n * @category Transactions\n */\nexport class StructTag extends Serializable {\n  public readonly address: AccountAddress;\n\n  public readonly moduleName: Identifier;\n\n  public readonly name: Identifier;\n\n  public readonly typeArgs: Array<TypeTag>;\n\n  constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>) {\n    super();\n    this.address = address;\n    this.moduleName = module_name;\n    this.name = name;\n    this.typeArgs = type_args;\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serialize(this.address);\n    serializer.serialize(this.moduleName);\n    serializer.serialize(this.name);\n    serializer.serializeVector(this.typeArgs);\n  }\n\n  static deserialize(deserializer: Deserializer): StructTag {\n    const address = AccountAddress.deserialize(deserializer);\n    const moduleName = Identifier.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    const typeArgs = deserializer.deserializeVector(TypeTag);\n    return new StructTag(address, moduleName, name, typeArgs);\n  }\n}\n\n/**\n * Retrieves the StructTag for the AptosCoin, which represents the Aptos Coin in the Aptos blockchain.\n *\n * @returns {StructTag} The StructTag for the AptosCoin.\n * @group Implementation\n * @category Transactions\n */\nexport function aptosCoinStructTag(): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"aptos_coin\"), new Identifier(\"AptosCoin\"), []);\n}\n\n/**\n * Returns a new StructTag representing a string type.\n *\n * @returns {StructTag} A StructTag for the string type.\n * @group Implementation\n * @category Transactions\n */\nexport function stringStructTag(): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"string\"), new Identifier(\"String\"), []);\n}\n\n/**\n * Creates a new StructTag for the Option type with the specified type argument.\n * This can help in defining a specific instance of an Option type in your application.\n *\n * @param typeArg - The type tag that specifies the type of the value contained in the Option.\n * @group Implementation\n * @category Transactions\n */\nexport function optionStructTag(typeArg: TypeTag): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"option\"), new Identifier(\"Option\"), [typeArg]);\n}\n\n/**\n * Creates a new StructTag for the Object type with the specified type argument.\n * This function helps in defining a structured representation of an Object with a specific type.\n *\n * @param typeArg - The type tag that specifies the type of the Object.\n * @group Implementation\n * @category Transactions\n */\nexport function objectStructTag(typeArg: TypeTag): StructTag {\n  return new StructTag(AccountAddress.ONE, new Identifier(\"object\"), new Identifier(\"Object\"), [typeArg]);\n}\n"],"mappings":"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","names":["Serializable","AccountAddress","Identifier","TypeTagVariants","TypeTag","deserializer","address","moduleName","name","typeArgs","StructTag","index","TypeTagBool","TypeTagU8","TypeTagU64","TypeTagU128","TypeTagAddress","TypeTagSigner","TypeTagVector","TypeTagStruct","TypeTagU16","TypeTagU32","TypeTagU256","TypeTagGeneric","serializer","_deserializer","TypeTagReference","value","typePredicate","typeArg","structName","module_name","type_args","aptosCoinStructTag","stringStructTag","optionStructTag","objectStructTag"]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/transactions/typeTag/parser.mjs

@@ -1,2 +1,2 @@
-import{StructTag as x,TypeTagAddress as v,TypeTagBool as A,TypeTagGeneric as C,TypeTagReference as U,TypeTagSigner as b,TypeTagStruct as I,TypeTagU128 as P,TypeTagU16 as E,TypeTagU256 as M,TypeTagU32 as G,TypeTagU64 as N,TypeTagU8 as V,TypeTagVector as W}from".";import{AccountAddress as _}from"../../core";import{Identifier as l}from"../instances/identifier";function y(e){return!!e.match(/^[_a-zA-Z0-9]+$/)}function w(e){return!!e.match(/\s/)}function $(e){return!!e.match(/^T[0-9]+$/)}function F(e){return!!e.match(/^&.+$/)}function k(e){switch(e){case"signer":case"address":case"bool":case"u8":case"u16":case"u32":case"u64":case"u128":case"u256":return!0;default:return!1}}function L(e,i){let c=i;for(;c<e.length;c+=1){const s=e[c];if(!w(s))break}return c}var R=(n=>(n.InvalidTypeTag="unknown type",n.UnexpectedGenericType="unexpected generic type",n.UnexpectedTypeArgumentClose="unexpected '>'",n.UnexpectedWhitespaceCharacter="unexpected whitespace character",n.UnexpectedComma="unexpected ','",n.TypeArgumentCountMismatch="type argument count doesn't match expected amount",n.MissingTypeArgumentClose="no matching '>' for '<'",n.MissingTypeArgument="no type argument before ','",n.UnexpectedPrimitiveTypeArguments="primitive types not expected to have type arguments",n.UnexpectedVectorTypeArgumentCount="vector type expected to have exactly one type argument",n.UnexpectedStructFormat="unexpected struct format, must be of the form 0xaddress::module_name::struct_name",n.InvalidModuleNameCharacter="module name must only contain alphanumeric or '_' characters",n.InvalidStructNameCharacter="struct name must only contain alphanumeric or '_' characters",n.InvalidAddress="struct address must be valid",n))(R||{});class a extends Error{constructor(i,c){super(`Failed to parse typeTag '${i}', ${c}`)}}function j(e,i){const c=i?.allowGenerics??!1,s=[];let u=[],t=[],o=0,r="",T=1;for(;o<e.length;){const d=e[o];if(d==="<")s.push({savedExpectedTypes:T,savedStr:r,savedTypes:t}),r="",t=[],T=1;else if(d===">"){if(r!==""){const n=g(r,u,c);t.push(n)}const p=s.pop();if(p===void 0)throw new a(e,"unexpected '>'");if(T!==t.length)throw new a(e,"type argument count doesn't match expected amount");const{savedStr:m,savedTypes:h,savedExpectedTypes:f}=p;u=t,t=h,r=m,T=f}else if(d===","){if(s.length===0)throw new a(e,"unexpected ','");if(r.length===0)throw new a(e,"no type argument before ','");const p=g(r,u,c);u=[],t.push(p),r="",T+=1}else if(w(d)){let p=!1;if(r.length!==0){const h=g(r,u,c);u=[],t.push(h),r="",p=!0}o=L(e,o);const m=e[o];if(o<e.length&&p&&m!==","&&m!==">")throw new a(e,"unexpected whitespace character");continue}else r+=d;o+=1}if(s.length>0)throw new a(e,"no matching '>' for '<'");switch(t.length){case 0:return g(r,u,c);case 1:if(r==="")return t[0];throw new a(e,"unexpected ','");default:throw new a(e,"unexpected whitespace character")}}function g(e,i,c){const s=e.trim(),u=s.toLowerCase();if(k(u)&&i.length>0)throw new a(e,"primitive types not expected to have type arguments");switch(s.toLowerCase()){case"signer":return new b;case"bool":return new A;case"address":return new v;case"u8":return new V;case"u16":return new E;case"u32":return new G;case"u64":return new N;case"u128":return new P;case"u256":return new M;case"vector":if(i.length!==1)throw new a(e,"vector type expected to have exactly one type argument");return new W(i[0]);default:if(F(s)){const r=s.substring(1);return new U(g(r,i,c))}if($(s)){if(c)return new C(Number(s.split("T")[1]));throw new a(e,"unexpected generic type")}if(!s.match(/:/))throw new a(e,"unknown type");const t=s.split("::");if(t.length!==3)throw new a(e,"unexpected struct format, must be of the form 0xaddress::module_name::struct_name");let o;try{o=_.fromString(t[0])}catch{throw new a(e,"struct address must be valid")}if(!y(t[1]))throw new a(e,"module name must only contain alphanumeric or '_' characters");if(!y(t[2]))throw new a(e,"struct name must only contain alphanumeric or '_' characters");return new I(new x(o,new l(t[1]),new l(t[2]),i))}}export{a as TypeTagParserError,R as TypeTagParserErrorType,j as parseTypeTag};
+import{rb as a,sb as b,tb as c}from"../../chunk-PJTG745G.mjs";import"../../chunk-A5L76YP7.mjs";import"../../chunk-5HXLZHDW.mjs";import"../../chunk-GOXRBEIJ.mjs";import"../../chunk-XJJVJOX5.mjs";import"../../chunk-QNARIAVM.mjs";import"../../chunk-2PASUPUO.mjs";import"../../chunk-C3Q23D22.mjs";import"../../chunk-NECL5FCQ.mjs";import"../../chunk-4QMXOWHP.mjs";import"../../chunk-RQX6JOEN.mjs";import"../../chunk-WSR5EBJM.mjs";import"../../chunk-WCMW2L3P.mjs";import"../../chunk-V74WPKSY.mjs";import"../../chunk-UYVPNUH3.mjs";import"../../chunk-G3MHXDYA.mjs";import"../../chunk-626KB2UQ.mjs";import"../../chunk-XKUIMGKU.mjs";import"../../chunk-N6YTF76Q.mjs";import"../../chunk-FGFLPH5K.mjs";import"../../chunk-QREVMGQZ.mjs";import"../../chunk-V3MBJJTL.mjs";import"../../chunk-ZP4DWSQA.mjs";import"../../chunk-2OPKZKOB.mjs";import"../../chunk-FC72YL4B.mjs";import"../../chunk-YS5IUILF.mjs";import"../../chunk-PSSIJHHC.mjs";import"../../chunk-YOZBVVKL.mjs";import"../../chunk-R7FWJP3N.mjs";import"../../chunk-UL777LTI.mjs";import"../../chunk-7ECCT6PK.mjs";import"../../chunk-AQW4BUKF.mjs";import"../../chunk-E2U27PNC.mjs";import"../../chunk-LAPXUUHK.mjs";import"../../chunk-HGLO5LDS.mjs";import"../../chunk-CW35YAMN.mjs";import"../../chunk-YZHAI55C.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-TOBQ5UE6.mjs";import"../../chunk-MT2RJ7H3.mjs";import"../../chunk-Q4W3WJ2U.mjs";import"../../chunk-ORMOQWWH.mjs";import"../../chunk-FLZPUYXQ.mjs";import"../../chunk-LA56UDUK.mjs";import"../../chunk-ZYE7UTJZ.mjs";import"../../chunk-RGKRCZ36.mjs";import"../../chunk-FD6FGKYY.mjs";import"../../chunk-MCFQE4GC.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-EBMEXURY.mjs";import"../../chunk-STY74NUA.mjs";import"../../chunk-IF4UU2MT.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-NCKJ7X57.mjs";import"../../chunk-P5HCJN3A.mjs";import"../../chunk-OLILO7VD.mjs";import"../../chunk-H3EP5CGP.mjs";import"../../chunk-KDMSOCZY.mjs";export{b as TypeTagParserError,a as TypeTagParserErrorType,c as parseTypeTag};
 //# sourceMappingURL=parser.mjs.map

package/dist/esm/transactions/typeTag/parser.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/transactions/typeTag/parser.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  StructTag,\n  TypeTag,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagGeneric,\n  TypeTagReference,\n  TypeTagSigner,\n  TypeTagStruct,\n  TypeTagU128,\n  TypeTagU16,\n  TypeTagU256,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU8,\n  TypeTagVector,\n} from \".\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"../instances/identifier\";\n\n/**\n * Determines if the provided string is a valid Move identifier, which can only contain alphanumeric characters and underscores.\n * @param str - The string to validate as a Move identifier.\n * @group Implementation\n * @category Transactions\n */\nfunction isValidIdentifier(str: string) {\n  return !!str.match(/^[_a-zA-Z0-9]+$/);\n}\n\n/**\n * Determines if the provided character is a whitespace character. This function only works for single characters.\n * @param char - The character to check for whitespace.\n * @group Implementation\n * @category Transactions\n */\nfunction isValidWhitespaceCharacter(char: string) {\n  return !!char.match(/\\s/);\n}\n\n/**\n * Determines if a given string represents a generic type from the ABI, specifically in the format T0, T1, etc.\n * @param str - The string to evaluate for generic type format.\n * @group Implementation\n * @category Transactions\n */\nfunction isGeneric(str: string) {\n  return !!str.match(/^T[0-9]+$/);\n}\n\n/**\n * Determines if the provided string is a reference type, which is indicated by starting with an ampersand (&).\n * @param str - The string to evaluate for reference type.\n * @group Implementation\n * @category Transactions\n */\nfunction isRef(str: string) {\n  return !!str.match(/^&.+$/);\n}\n\n/**\n * Determines if the provided string represents a primitive type.\n * @param str - The string to evaluate as a potential primitive type.\n * @returns A boolean indicating whether the string is a primitive type.\n * @group Implementation\n * @category Transactions\n */\nfunction isPrimitive(str: string) {\n  switch (str) {\n    case \"signer\":\n    case \"address\":\n    case \"bool\":\n    case \"u8\":\n    case \"u16\":\n    case \"u32\":\n    case \"u64\":\n    case \"u128\":\n    case \"u256\":\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Consumes all whitespace characters in a string starting from a specified position.\n *\n * @param tagStr - The string from which to consume whitespace.\n * @param pos - The position in the string to start consuming whitespace from.\n * @returns The new position in the string after consuming whitespace.\n * @group Implementation\n * @category Transactions\n */\nfunction consumeWhitespace(tagStr: string, pos: number) {\n  let i = pos;\n  for (; i < tagStr.length; i += 1) {\n    const innerChar = tagStr[i];\n\n    if (!isValidWhitespaceCharacter(innerChar)) {\n      // If it's not colons, and it's an invalid character, we will stop here\n      break;\n    }\n  }\n  return i;\n}\n\n/**\n * State for TypeTag parsing, maintained on a stack to track the current parsing state.\n * @group Implementation\n * @category Transactions\n */\ntype TypeTagState = {\n  savedExpectedTypes: number;\n  savedStr: string;\n  savedTypes: Array<TypeTag>;\n};\n\n/**\n * Error types related to parsing type tags, indicating various issues encountered during the parsing process.\n * @group Implementation\n * @category Transactions\n */\nexport enum TypeTagParserErrorType {\n  InvalidTypeTag = \"unknown type\",\n  UnexpectedGenericType = \"unexpected generic type\",\n  UnexpectedTypeArgumentClose = \"unexpected '>'\",\n  UnexpectedWhitespaceCharacter = \"unexpected whitespace character\",\n  UnexpectedComma = \"unexpected ','\",\n  TypeArgumentCountMismatch = \"type argument count doesn't match expected amount\",\n  MissingTypeArgumentClose = \"no matching '>' for '<'\",\n  MissingTypeArgument = \"no type argument before ','\",\n  UnexpectedPrimitiveTypeArguments = \"primitive types not expected to have type arguments\",\n  UnexpectedVectorTypeArgumentCount = \"vector type expected to have exactly one type argument\",\n  UnexpectedStructFormat = \"unexpected struct format, must be of the form 0xaddress::module_name::struct_name\",\n  InvalidModuleNameCharacter = \"module name must only contain alphanumeric or '_' characters\",\n  InvalidStructNameCharacter = \"struct name must only contain alphanumeric or '_' characters\",\n  InvalidAddress = \"struct address must be valid\",\n}\n\n/**\n * Represents an error that occurs during the parsing of a type tag.\n * This error extends the built-in Error class and provides additional context\n * regarding the specific type tag that failed to parse and the reason for the failure.\n *\n * @param typeTagStr - The type tag string that failed to be parsed.\n * @param invalidReason - The reason why the type tag string is considered invalid.\n * @group Implementation\n * @category Transactions\n */\nexport class TypeTagParserError extends Error {\n  /**\n   * Constructs an error indicating a failure to parse a type tag.\n   * This error provides details about the specific type tag that could not be parsed and the reason for the failure.\n   *\n   * @param typeTagStr - The string representation of the type tag that failed to parse.\n   * @param invalidReason - The reason why the type tag is considered invalid.\n   * @group Implementation\n   * @category Transactions\n   */\n  constructor(typeTagStr: string, invalidReason: TypeTagParserErrorType) {\n    super(`Failed to parse typeTag '${typeTagStr}', ${invalidReason}`);\n  }\n}\n\n/**\n * Parses a type string into a structured representation of type tags, accommodating various formats including generics and\n * nested types.\n *\n * This function can help you accurately interpret type strings, which can include simple types, standalone structs, and complex\n * nested generics.\n * It supports multiple generics, spacing within generics, and nested generics of varying depths.\n * All types are made of a few parts they're either:\n * 1. A simple type e.g. u8\n * 2. A standalone struct e.g. 0x1::account::Account\n * 3. A nested struct e.g. 0x1::coin::Coin<0x1234::coin::MyCoin>\n *\n * There are a few more special cases that need to be handled, however.\n * 1. Multiple generics e.g. 0x1::pair::Pair<u8, u16>\n * 2. Spacing in the generics e.g. 0x1::pair::Pair< u8 , u16>\n * 3. Nested generics of different depths e.g. 0x1::pair::Pair<0x1::coin::Coin<0x1234::coin::MyCoin>, u8>\n * 4. Generics for types in ABIs are filled in with placeholders e.g. T1, T2, T3\n * @param typeStr - The string representation of the type to be parsed.\n * @param options - Optional settings for parsing behavior.\n * @param options.allowGenerics - A flag indicating whether to allow generics in the parsing process.\n * @returns The parsed type tag representation.\n * @throws TypeTagParserError if the type string is malformed or does not conform to expected formats.\n * @group Implementation\n * @category Transactions\n */\nexport function parseTypeTag(typeStr: string, options?: { allowGenerics?: boolean }) {\n  const allowGenerics = options?.allowGenerics ?? false;\n\n  const saved: Array<TypeTagState> = [];\n  // This represents the internal types for a type tag e.g. '0x1::coin::Coin<innerTypes>'\n  let innerTypes: Array<TypeTag> = [];\n  // This represents the current parsed types in a comma list e.g. 'u8, u8'\n  let curTypes: Array<TypeTag> = [];\n  // This represents the current character index\n  let cur: number = 0;\n  // This represents the current working string as a type or struct name\n  let currentStr: string = \"\";\n  let expectedTypes: number = 1;\n\n  // Iterate through each character, and handle the border conditions\n  while (cur < typeStr.length) {\n    const char = typeStr[cur];\n\n    if (char === \"<\") {\n      // Start of a type argument, push current state onto a stack\n      saved.push({\n        savedExpectedTypes: expectedTypes,\n        savedStr: currentStr,\n        savedTypes: curTypes,\n      });\n\n      // Clear current state\n      currentStr = \"\";\n      curTypes = [];\n      expectedTypes = 1;\n    } else if (char === \">\") {\n      // Process last type, if there is no type string, then don't parse it\n      if (currentStr !== \"\") {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n        curTypes.push(newType);\n      }\n\n      // Pop off stack outer type, if there's nothing left, there were too many '>'\n      const savedPop = saved.pop();\n      if (savedPop === undefined) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedTypeArgumentClose);\n      }\n\n      // If the expected types don't match the number of commas, then we also fail\n      if (expectedTypes !== curTypes.length) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.TypeArgumentCountMismatch);\n      }\n\n      // Add in the new created type, shifting the current types to the inner types\n      const { savedStr, savedTypes, savedExpectedTypes } = savedPop;\n      innerTypes = curTypes;\n      curTypes = savedTypes;\n      currentStr = savedStr;\n      expectedTypes = savedExpectedTypes;\n    } else if (char === \",\") {\n      // Comma means we need to start parsing a new tag, push the previous one to the curTypes\n\n      // No top level commas (not in a type <> are allowed)\n      if (saved.length === 0) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedComma);\n      }\n      // If there was no actual value before the comma, then it's missing a type argument\n      if (currentStr.length === 0) {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.MissingTypeArgument);\n      }\n\n      // Process characters before as a type\n      const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n      // parse type tag and push it on the types\n      innerTypes = [];\n      curTypes.push(newType);\n      currentStr = \"\";\n      expectedTypes += 1;\n    } else if (isValidWhitespaceCharacter(char)) {\n      // This means we should save what we have and everything else should skip until the next\n      let parsedTypeTag = false;\n      if (currentStr.length !== 0) {\n        const newType = parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n\n        // parse type tag and push it on the types\n        innerTypes = [];\n        curTypes.push(newType);\n        currentStr = \"\";\n        parsedTypeTag = true;\n      }\n\n      // Skip ahead on any more whitespace\n      cur = consumeWhitespace(typeStr, cur);\n\n      // The next space MUST be a comma, or a closing > if there was something parsed before\n      // e.g. `u8 u8` is invalid but `u8, u8` is valid\n      const nextChar = typeStr[cur];\n      if (cur < typeStr.length && parsedTypeTag && nextChar !== \",\" && nextChar !== \">\") {\n        throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n      }\n\n      // eslint-disable-next-line no-continue\n      continue;\n    } else {\n      // Any other characters just append to the current string\n      currentStr += char;\n    }\n\n    cur += 1;\n  }\n\n  // This prevents a missing '>' on type arguments\n  if (saved.length > 0) {\n    throw new TypeTagParserError(typeStr, TypeTagParserErrorType.MissingTypeArgumentClose);\n  }\n\n  // This prevents 'u8, u8' as an input\n  switch (curTypes.length) {\n    case 0:\n      return parseTypeTagInner(currentStr, innerTypes, allowGenerics);\n    case 1:\n      if (currentStr === \"\") {\n        return curTypes[0];\n      }\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedComma);\n    default:\n      throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);\n  }\n}\n\n/**\n * Parses a type tag with internal types associated, allowing for the inclusion of generics if specified. This function helps in\n * constructing the appropriate type tags based on the provided string representation and associated types.\n *\n * @param str - The string representation of the type tag to parse.\n * @param types - An array of TypeTag instances that represent internal types associated with the type tag.\n * @param allowGenerics - A boolean indicating whether generics are allowed in the parsing of the type tag.\n * @group Implementation\n * @category Transactions\n */\nfunction parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: boolean): TypeTag {\n  const trimmedStr = str.trim();\n  const lowerCaseTrimmed = trimmedStr.toLowerCase();\n  if (isPrimitive(lowerCaseTrimmed)) {\n    if (types.length > 0) {\n      throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedPrimitiveTypeArguments);\n    }\n  }\n\n  switch (trimmedStr.toLowerCase()) {\n    case \"signer\":\n      return new TypeTagSigner();\n    case \"bool\":\n      return new TypeTagBool();\n    case \"address\":\n      return new TypeTagAddress();\n    case \"u8\":\n      return new TypeTagU8();\n    case \"u16\":\n      return new TypeTagU16();\n    case \"u32\":\n      return new TypeTagU32();\n    case \"u64\":\n      return new TypeTagU64();\n    case \"u128\":\n      return new TypeTagU128();\n    case \"u256\":\n      return new TypeTagU256();\n    case \"vector\":\n      if (types.length !== 1) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedVectorTypeArgumentCount);\n      }\n      return new TypeTagVector(types[0]);\n    default:\n      // Reference will have to handle the inner type\n      if (isRef(trimmedStr)) {\n        const actualType = trimmedStr.substring(1);\n        return new TypeTagReference(parseTypeTagInner(actualType, types, allowGenerics));\n      }\n\n      // Generics are always expected to be T0 or T1\n      if (isGeneric(trimmedStr)) {\n        if (allowGenerics) {\n          return new TypeTagGeneric(Number(trimmedStr.split(\"T\")[1]));\n        }\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedGenericType);\n      }\n\n      // If the value doesn't contain a colon, then we'll assume it isn't trying to be a struct\n      if (!trimmedStr.match(/:/)) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidTypeTag);\n      }\n\n      // Parse for a struct tag\n      // eslint-disable-next-line no-case-declarations\n      const structParts = trimmedStr.split(\"::\");\n      if (structParts.length !== 3) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedStructFormat);\n      }\n\n      // Validate struct address\n      // eslint-disable-next-line no-case-declarations\n      let address: AccountAddress;\n      try {\n        address = AccountAddress.fromString(structParts[0]);\n      } catch (error: any) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidAddress);\n      }\n\n      // Validate identifier characters\n      if (!isValidIdentifier(structParts[1])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidModuleNameCharacter);\n      }\n      if (!isValidIdentifier(structParts[2])) {\n        throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidStructNameCharacter);\n      }\n\n      return new TypeTagStruct(\n        new StructTag(address, new Identifier(structParts[1]), new Identifier(structParts[2]), types),\n      );\n  }\n}\n"],"mappings":"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","names":["StructTag","TypeTagAddress","TypeTagBool","TypeTagGeneric","TypeTagReference","TypeTagSigner","TypeTagStruct","TypeTagU128","TypeTagU16","TypeTagU256","TypeTagU32","TypeTagU64","TypeTagU8","TypeTagVector","AccountAddress","Identifier","isValidIdentifier","str","isValidWhitespaceCharacter","char","isGeneric","isRef","isPrimitive","consumeWhitespace","tagStr","pos","i","innerChar","TypeTagParserErrorType","TypeTagParserError","typeTagStr","invalidReason","parseTypeTag","typeStr","options","allowGenerics","saved","innerTypes","curTypes","cur","currentStr","expectedTypes","newType","parseTypeTagInner","savedPop","savedStr","savedTypes","savedExpectedTypes","parsedTypeTag","nextChar","types","trimmedStr","lowerCaseTrimmed","actualType","structParts","address"]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/transactions/types.mjs

@@ -1 +1,2 @@
+import"../chunk-V3MBJJTL.mjs";
 //# sourceMappingURL=types.mjs.map

package/dist/esm/types/abstraction.mjs

@@ -1,2 +1,2 @@
-var p=(e=>(e[e.V1=0]="V1",e[e.DerivableV1=1]="DerivableV1",e))(p||{}),x=(m=>(m[m.V1=0]="V1",m))(x||{});export{x as AASigningDataVariant,p as AbstractAuthenticationDataVariant};
+import{a,b}from"../chunk-ZP4DWSQA.mjs";import"../chunk-KDMSOCZY.mjs";export{b as AASigningDataVariant,a as AbstractAuthenticationDataVariant};
 //# sourceMappingURL=abstraction.mjs.map

package/dist/esm/types/abstraction.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/abstraction.ts"],"sourcesContent":["/**\n * The variant for the AbstractAuthenticationData enum.\n */\nexport enum AbstractAuthenticationDataVariant {\n  V1 = 0,\n  DerivableV1 = 1,\n}\n\n/**\n * The variant for the AASigningData enum.\n */\nexport enum AASigningDataVariant {\n  V1 = 0,\n}\n"],"mappings":"AAGO,IAAKA,OACVA,IAAA,GAAK,GAAL,KACAA,IAAA,YAAc,GAAd,cAFUA,OAAA,IAQAC,OACVA,IAAA,GAAK,GAAL,KADUA,OAAA","names":["AbstractAuthenticationDataVariant","AASigningDataVariant"]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}