@aptos-labs/ts-sdk 1.33.2 → 1.35.0-zeta.0

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/transactionBuilder/transactionBuilder.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * This file handles the transaction creation lifecycle.\n * It holds different operations to generate a transaction payload, a raw transaction,\n * and a signed transaction that can be simulated, signed and submitted to chain.\n */\nimport { sha3_256 as sha3Hash } from \"@noble/hashes/sha3\";\nimport { AptosConfig } from \"../../api/aptosConfig\";\nimport { AccountAddress, AccountAddressInput, Hex, PublicKey } from \"../../core\";\nimport {\n  AnyPublicKey,\n  AnySignature,\n  KeylessPublicKey,\n  KeylessSignature,\n  Secp256k1PublicKey,\n  FederatedKeylessPublicKey,\n  MultiKey,\n  MultiKeySignature,\n} from \"../../core/crypto\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"../../core/crypto/ed25519\";\nimport { getInfo } from \"../../internal/account\";\nimport { getLedgerInfo } from \"../../internal/general\";\nimport { getGasPriceEstimation } from \"../../internal/transaction\";\nimport { NetworkToChainId } from \"../../utils/apiEndpoints\";\nimport { DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW } from \"../../utils/const\";\nimport { normalizeBundle } from \"../../utils/normalizeBundle\";\nimport {\n  AccountAuthenticator,\n  AccountAuthenticatorEd25519,\n  AccountAuthenticatorMultiEd25519,\n  AccountAuthenticatorMultiKey,\n  AccountAuthenticatorNoAccountAuthenticator,\n  AccountAuthenticatorSingleKey,\n} from \"../authenticator/account\";\nimport {\n  TransactionAuthenticator,\n  TransactionAuthenticatorEd25519,\n  TransactionAuthenticatorFeePayer,\n  TransactionAuthenticatorMultiAgent,\n  TransactionAuthenticatorMultiEd25519,\n  TransactionAuthenticatorSingleSender,\n} from \"../authenticator/transaction\";\nimport {\n  ChainId,\n  EntryFunction,\n  FeePayerRawTransaction,\n  MultiAgentRawTransaction,\n  MultiSig,\n  MultiSigTransactionPayload,\n  RawTransaction,\n  Script,\n  TransactionPayloadEntryFunction,\n  TransactionPayloadMultiSig,\n  TransactionPayloadScript,\n} from \"../instances\";\nimport { SignedTransaction } from \"../instances/signedTransaction\";\nimport {\n  AnyRawTransaction,\n  AnyTransactionPayloadInstance,\n  EntryFunctionArgumentTypes,\n  InputGenerateMultiAgentRawTransactionArgs,\n  InputGenerateRawTransactionArgs,\n  InputGenerateSingleSignerRawTransactionArgs,\n  InputGenerateTransactionOptions,\n  InputScriptData,\n  InputSimulateTransactionData,\n  InputMultiSigDataWithRemoteABI,\n  InputEntryFunctionDataWithRemoteABI,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputSubmitTransactionData,\n  InputGenerateTransactionPayloadDataWithABI,\n  InputEntryFunctionDataWithABI,\n  InputMultiSigDataWithABI,\n  InputViewFunctionDataWithRemoteABI,\n  InputViewFunctionDataWithABI,\n  FunctionABI,\n} from \"../types\";\nimport { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from \"./remoteAbi\";\nimport { memoizeAsync } from \"../../utils/memoize\";\nimport { isScriptDataInput } from \"./helpers\";\nimport { SimpleTransaction } from \"../instances/simpleTransaction\";\nimport { MultiAgentTransaction } from \"../instances/multiAgentTransaction\";\nimport { getFunctionParts } from \"../../utils/helpers\";\n\n/**\n * Builds a transaction payload based on the provided arguments and returns a transaction payload.\n * This function uses the RemoteABI by default, but can also utilize a specified ABI.\n * When we call our `generateTransactionPayload` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n * @param args - The input data for generating the transaction payload.\n * @param args.function - The function to be called, specified in the format \"moduleAddress::moduleName::functionName\".\n * @param args.functionArguments - The arguments to pass to the function.\n * @param args.typeArguments - The type arguments for the function.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.abi - The ABI to use for the transaction, if not using the RemoteABI.\n *\n * @returns TransactionPayload - The generated transaction payload, which can be of type TransactionPayloadScript,\n * TransactionPayloadMultiSig, or TransactionPayloadEntryFunction.\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(\n  args: InputEntryFunctionDataWithRemoteABI,\n): Promise<TransactionPayloadEntryFunction>;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(\n  args: InputMultiSigDataWithRemoteABI,\n): Promise<TransactionPayloadMultiSig>;\n\n/**\n * Builds a transaction payload based on the data argument and returns\n * a transaction payload - TransactionPayloadScript | TransactionPayloadMultiSig | TransactionPayloadEntryFunction\n *\n * This uses the RemoteABI by default, and the remote ABI can be skipped by using generateTransactionPayloadWithABI\n *\n * @param args.data GenerateTransactionPayloadData\n *\n * @return TransactionPayload\n * @group Implementation\n * @category Transactions\n */\nexport async function generateTransactionPayload(\n  args: InputGenerateTransactionPayloadDataWithRemoteABI,\n): Promise<AnyTransactionPayloadInstance> {\n  if (isScriptDataInput(args)) {\n    return generateTransactionPayloadScript(args);\n  }\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  const functionAbi = await fetchAbi({\n    key: \"entry-function\",\n    moduleAddress,\n    moduleName,\n    functionName,\n    aptosConfig: args.aptosConfig,\n    abi: args.abi,\n    fetch: fetchEntryFunctionAbi,\n  });\n\n  // Fill in the ABI\n  return generateTransactionPayloadWithABI({ ...args, abi: functionAbi });\n}\n\n/**\n * Generates a transaction payload using the provided ABI and function details.\n * This function helps create a properly structured transaction payload for executing a specific function on a module.\n *\n * @param args - The input data required to generate the transaction payload.\n * @param args.abi - The ABI of the function to be executed.\n * @param args.function - The fully qualified name of the function in the format `moduleAddress::moduleName::functionName`.\n * @param args.typeArguments - An array of type arguments that correspond to the function's type parameters.\n * @param args.functionArguments - An array of arguments to be passed to the function.\n * @param args.multisigAddress - (Optional) The address for a multisig transaction if applicable.\n *\n * @throws Error if the type argument count does not match the ABI or if the number of function arguments is incorrect.\n * @group Implementation\n * @category Transactions\n */\nexport function generateTransactionPayloadWithABI(args: InputEntryFunctionDataWithABI): TransactionPayloadEntryFunction;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function generateTransactionPayloadWithABI(args: InputMultiSigDataWithABI): TransactionPayloadMultiSig;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function generateTransactionPayloadWithABI(\n  args: InputGenerateTransactionPayloadDataWithABI,\n): AnyTransactionPayloadInstance {\n  const functionAbi = args.abi;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // Ensure that all type arguments are typed properly\n  const typeArguments = standardizeTypeTags(args.typeArguments);\n\n  // Check the type argument count against the ABI\n  if (typeArguments.length !== functionAbi.typeParameters.length) {\n    throw new Error(\n      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n    );\n  }\n\n  // Check all BCS types, and convert any non-BCS types\n  const functionArguments: Array<EntryFunctionArgumentTypes> = args.functionArguments.map((arg, i) =>\n    /**\n     * Converts the argument for a specified function using its ABI and type arguments.\n     * This function helps ensure that the correct number of arguments is provided for the function call.\n     *\n     * @param args - The arguments for the function call.\n     * @param args.function - The specific function to be invoked.\n     * @param functionAbi - The ABI (Application Binary Interface) of the function, which includes parameter details.\n     * @param arg - The argument to be converted.\n     * @param i - The index of the argument in the function call.\n     * @param typeArguments - Additional type arguments that may be required for the conversion.\n     * @group Implementation\n     * @category Transactions\n     */\n    // TODO: Fix JSDoc\n    convertArgument(args.function, functionAbi, arg, i, typeArguments),\n  );\n\n  // Check that all arguments are accounted for\n  if (functionArguments.length !== functionAbi.parameters.length) {\n    throw new Error(\n      // eslint-disable-next-line max-len\n      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,\n    );\n  }\n\n  // Generate entry function payload\n  const entryFunctionPayload = EntryFunction.build(\n    `${moduleAddress}::${moduleName}`,\n    functionName,\n    typeArguments,\n    functionArguments,\n  );\n\n  // Send it as multi sig if it's a multisig payload\n  if (\"multisigAddress\" in args) {\n    const multisigAddress = AccountAddress.from(args.multisigAddress);\n    return new TransactionPayloadMultiSig(\n      new MultiSig(multisigAddress, new MultiSigTransactionPayload(entryFunctionPayload)),\n    );\n  }\n\n  // Otherwise send as an entry function\n  return new TransactionPayloadEntryFunction(entryFunctionPayload);\n}\n\n/**\n * Generates the payload for a view function call using the provided arguments.\n * This function helps in preparing the necessary data to interact with a specific view function on the blockchain.\n *\n * @param args - The input data required to generate the view function payload.\n * @param args.function - The function identifier in the format \"moduleAddress::moduleName::functionName\".\n * @param args.aptosConfig - Configuration settings for the Aptos client.\n * @param args.abi - The ABI (Application Binary Interface) of the module.\n *\n * @returns The generated payload for the view function call.\n * @group Implementation\n * @category Transactions\n */\nexport async function generateViewFunctionPayload(args: InputViewFunctionDataWithRemoteABI): Promise<EntryFunction> {\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  const functionAbi = await fetchAbi({\n    key: \"view-function\",\n    moduleAddress,\n    moduleName,\n    functionName,\n    aptosConfig: args.aptosConfig,\n    abi: args.abi,\n    fetch: fetchViewFunctionAbi,\n  });\n\n  // Fill in the ABI\n  return generateViewFunctionPayloadWithABI({ abi: functionAbi, ...args });\n}\n\n/**\n * Generates a payload for a view function call using the provided ABI and arguments.\n * This function ensures that the type arguments and function arguments are correctly formatted\n * and match the expected counts as defined in the ABI.\n *\n * @param args - The input data for generating the view function payload.\n * @param args.abi - The ABI of the function to be called.\n * @param args.function - The full name of the function in the format \"moduleAddress::moduleName::functionName\".\n * @param args.typeArguments - An array of type arguments to be used in the function call.\n * @param args.functionArguments - An array of arguments to be passed to the function.\n *\n * @throws Error if the type argument count does not match the ABI or if the function arguments\n * do not match the expected parameters defined in the ABI.\n * @group Implementation\n * @category Transactions\n */\nexport function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWithABI): EntryFunction {\n  const functionAbi = args.abi;\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // Ensure that all type arguments are typed properly\n  const typeArguments = standardizeTypeTags(args.typeArguments);\n\n  // Check the type argument count against the ABI\n  if (typeArguments.length !== functionAbi.typeParameters.length) {\n    throw new Error(\n      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n    );\n  }\n\n  // Check all BCS types, and convert any non-BCS types\n  const functionArguments: Array<EntryFunctionArgumentTypes> =\n    args?.functionArguments?.map((arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments)) ?? [];\n\n  // Check that all arguments are accounted for\n  if (functionArguments.length !== functionAbi.parameters.length) {\n    throw new Error(\n      // eslint-disable-next-line max-len\n      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,\n    );\n  }\n\n  // Generate entry function payload\n  return EntryFunction.build(`${moduleAddress}::${moduleName}`, functionName, typeArguments, functionArguments);\n}\n\n/**\n * Generates a transaction payload script based on the provided input data.\n * This function helps in creating a structured script for transaction processing.\n *\n * @param args - The input data required to generate the transaction payload script.\n * @param args.bytecode - The bytecode to be converted into a Uint8Array.\n * @param args.typeArguments - The type arguments that will be standardized.\n * @param args.functionArguments - The arguments for the function being called.\n * @returns A new instance of TransactionPayloadScript.\n * @group Implementation\n * @category Transactions\n */\nfunction generateTransactionPayloadScript(args: InputScriptData) {\n  return new TransactionPayloadScript(\n    new Script(\n      Hex.fromHexInput(args.bytecode).toUint8Array(),\n      standardizeTypeTags(args.typeArguments),\n      args.functionArguments,\n    ),\n  );\n}\n\n/**\n * Generates a raw transaction that can be sent to the Aptos network.\n *\n * @param args - The arguments for generating the raw transaction.\n * @param args.aptosConfig - The configuration for the Aptos network.\n * @param args.sender - The transaction's sender account address as a hex input.\n * @param args.payload - The transaction payload, which can be created using generateTransactionPayload().\n * @param args.options - Optional parameters for transaction generation.\n * @param args.feePayerAddress - The address of the fee payer for sponsored transactions.\n *\n * @returns RawTransaction - The generated raw transaction.\n * @group Implementation\n * @category Transactions\n */\nexport async function generateRawTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  payload: AnyTransactionPayloadInstance;\n  options?: InputGenerateTransactionOptions;\n  feePayerAddress?: AccountAddressInput;\n}): Promise<RawTransaction> {\n  const { aptosConfig, sender, payload, options, feePayerAddress } = args;\n\n  const getChainId = async () => {\n    if (NetworkToChainId[aptosConfig.network]) {\n      return { chainId: NetworkToChainId[aptosConfig.network] };\n    }\n    const info = await getLedgerInfo({ aptosConfig });\n    return { chainId: info.chain_id };\n  };\n\n  const getGasUnitPrice = async () => {\n    if (options?.gasUnitPrice) {\n      return { gasEstimate: options.gasUnitPrice };\n    }\n    const estimation = await getGasPriceEstimation({ aptosConfig });\n    return { gasEstimate: estimation.gas_estimate };\n  };\n\n  const getSequenceNumberForAny = async () => {\n    const getSequenceNumber = async () => {\n      if (options?.accountSequenceNumber !== undefined) {\n        return options.accountSequenceNumber;\n      }\n\n      return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;\n    };\n\n    /**\n     * Check if is sponsored transaction to honor AIP-52\n     * {@link https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-52.md}\n     * @group Implementation\n     * @category Transactions\n     */\n    if (feePayerAddress && AccountAddress.from(feePayerAddress).equals(AccountAddress.ZERO)) {\n      // Handle sponsored transaction generation with the option that\n      // the main signer has not been created on chain\n      try {\n        // Check if main signer has been created on chain, if not assign sequence number 0\n        return await getSequenceNumber();\n      } catch (e: any) {\n        return 0;\n      }\n    } else {\n      return getSequenceNumber();\n    }\n  };\n  const [{ chainId }, { gasEstimate }, sequenceNumber] = await Promise.all([\n    getChainId(),\n    getGasUnitPrice(),\n    getSequenceNumberForAny(),\n  ]);\n\n  const { maxGasAmount, gasUnitPrice, expireTimestamp } = {\n    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),\n    gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),\n    expireTimestamp: options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + DEFAULT_TXN_EXP_SEC_FROM_NOW),\n  };\n\n  return new RawTransaction(\n    AccountAddress.from(sender),\n    BigInt(sequenceNumber),\n    payload,\n    BigInt(maxGasAmount),\n    BigInt(gasUnitPrice),\n    BigInt(expireTimestamp),\n    new ChainId(chainId),\n  );\n}\n\n/**\n * Generates a transaction based on the provided arguments.\n * This function can create both simple and multi-agent transactions, allowing for flexible transaction handling.\n *\n * @param args - The input arguments for generating the transaction.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.sender - The transaction's sender account address as a hex input.\n * @param args.payload - The transaction payload, which can be created using `generateTransactionPayload()`.\n * @param args.options - Optional. Transaction options object.\n * @param args.secondarySignerAddresses - Optional. An array of addresses for additional signers in a multi-signature transaction.\n * @param args.feePayerAddress - Optional. The address of the fee payer for sponsored transactions.\n * @returns An instance of a transaction, which may include secondary signer addresses and a fee payer address.\n * @group Implementation\n * @category Transactions\n */\nexport async function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<SimpleTransaction>;\n/**\n * @group Implementation\n * @category Transactions\n */\nexport async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;\n\n/**\n * Generates a transaction based on the provided arguments\n *\n * Note: we can start with one function to support all different payload/transaction types,\n * and if to complex to use, we could have function for each type\n *\n * @param args.aptosConfig AptosConfig\n * @param args.sender The transaction's sender account address as a hex input\n * @param args.payload The transaction payload - can create by using generateTransactionPayload()\n * @param args.options optional. Transaction options object\n * @param args.secondarySignerAddresses optional. For when want to create a multi signers transaction\n * @param args.feePayerAddress optional. For when want to create a fee payer (aka sponsored) transaction\n *\n * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses\n * ```\n * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses?: Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n * @group Implementation\n * @category Transactions\n */\nexport async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction> {\n  const { aptosConfig, sender, payload, options, feePayerAddress } = args;\n  // generate raw transaction\n  const rawTxn = await generateRawTransaction({\n    aptosConfig,\n    sender,\n    payload,\n    options,\n    feePayerAddress,\n  });\n\n  // if multi agent transaction\n  if (\"secondarySignerAddresses\" in args) {\n    const signers: Array<AccountAddress> =\n      args.secondarySignerAddresses?.map((signer) => AccountAddress.from(signer)) ?? [];\n\n    return new MultiAgentTransaction(\n      rawTxn,\n      signers,\n      args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,\n    );\n  }\n  // return the raw transaction\n  return new SimpleTransaction(rawTxn, args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined);\n}\n\n/**\n * Generate a signed transaction for simulation before submitting it to the chain.\n * This function helps in preparing a transaction that can be simulated, allowing users to verify its validity and expected behavior.\n *\n * @param args - The input data required to generate the signed transaction for simulation.\n * @param args.transaction - An Aptos transaction type to sign.\n * @param args.signerPublicKey - The public key of the signer.\n * @param args.secondarySignersPublicKeys - Optional. The public keys of secondary signers if it is a multi-signer transaction.\n * @param args.feePayerPublicKey - Optional. The public key of the fee payer in a sponsored transaction.\n * @param args.options - Optional. Additional options for simulating the transaction.\n *\n * @returns A signed serialized transaction that can be simulated.\n * @group Implementation\n * @category Transactions\n */\nexport function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {\n  const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;\n\n  const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);\n\n  // fee payer transaction\n  if (transaction.feePayerAddress) {\n    const transactionToSign = new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n    if (transaction.secondarySignerAddresses) {\n      if (secondarySignersPublicKeys) {\n        secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n          getAuthenticatorForSimulation(publicKey),\n        );\n      } else {\n        secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>\n          getAuthenticatorForSimulation(undefined),\n        );\n      }\n    }\n    const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey);\n\n    const transactionAuthenticator = new TransactionAuthenticatorFeePayer(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses ?? [],\n      secondaryAccountAuthenticators,\n      {\n        address: transaction.feePayerAddress,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // multi agent transaction\n  if (transaction.secondarySignerAddresses) {\n    const transactionToSign = new MultiAgentRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses,\n    );\n\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n\n    if (secondarySignersPublicKeys) {\n      secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n        getAuthenticatorForSimulation(publicKey),\n      );\n    } else {\n      secondaryAccountAuthenticators = Array.from({ length: transaction.secondarySignerAddresses.length }, () =>\n        getAuthenticatorForSimulation(undefined),\n      );\n    }\n\n    const transactionAuthenticator = new TransactionAuthenticatorMultiAgent(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses,\n      secondaryAccountAuthenticators,\n    );\n\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // single signer raw transaction\n  let transactionAuthenticator;\n  if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {\n    transactionAuthenticator = new TransactionAuthenticatorEd25519(\n      accountAuthenticator.public_key,\n      accountAuthenticator.signature,\n    );\n  } else if (\n    accountAuthenticator instanceof AccountAuthenticatorSingleKey ||\n    accountAuthenticator instanceof AccountAuthenticatorMultiKey\n  ) {\n    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);\n  } else if (accountAuthenticator instanceof AccountAuthenticatorNoAccountAuthenticator) {\n    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);\n  } else {\n    throw new Error(\"Invalid public key\");\n  }\n  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();\n}\n\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function getAuthenticatorForSimulation(publicKey?: PublicKey) {\n  if (!publicKey) {\n    return new AccountAuthenticatorNoAccountAuthenticator();\n  }\n\n  // Wrap the public key types below with AnyPublicKey as they are only support through single sender.\n  // Learn more about AnyPublicKey here - https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-55.md\n  const convertToAnyPublicKey =\n    KeylessPublicKey.isInstance(publicKey) ||\n    FederatedKeylessPublicKey.isInstance(publicKey) ||\n    Secp256k1PublicKey.isInstance(publicKey);\n  const accountPublicKey = convertToAnyPublicKey ? new AnyPublicKey(publicKey) : publicKey;\n\n  // No need to for the signature to be matching in scheme. All that matters for simulations is that it's not valid\n  const invalidSignature = new Ed25519Signature(new Uint8Array(64));\n\n  if (Ed25519PublicKey.isInstance(accountPublicKey)) {\n    return new AccountAuthenticatorEd25519(accountPublicKey, invalidSignature);\n  }\n\n  if (AnyPublicKey.isInstance(accountPublicKey)) {\n    if (KeylessPublicKey.isInstance(accountPublicKey.publicKey)) {\n      return new AccountAuthenticatorSingleKey(\n        accountPublicKey,\n        new AnySignature(KeylessSignature.getSimulationSignature()),\n      );\n    }\n    return new AccountAuthenticatorSingleKey(accountPublicKey, new AnySignature(invalidSignature));\n  }\n\n  if (MultiKey.isInstance(accountPublicKey)) {\n    return new AccountAuthenticatorMultiKey(\n      accountPublicKey,\n      new MultiKeySignature({\n        signatures: accountPublicKey.publicKeys.map(() => new AnySignature(invalidSignature)),\n        bitmap: accountPublicKey.createBitmap({\n          bits: Array(accountPublicKey.publicKeys.length)\n            .fill(0)\n            .map((_, i) => i),\n        }),\n      }),\n    );\n  }\n\n  throw new Error(\"Unsupported PublicKey used for simulations\");\n}\n\n/**\n * Generate a signed transaction ready for submission to the blockchain.\n * This function prepares the transaction by authenticating the sender and any additional signers based on the provided arguments.\n *\n * @param args - The input data required to generate the signed transaction.\n * @param args.transaction - An Aptos transaction type containing the details of the transaction.\n * @param args.senderAuthenticator - The account authenticator of the transaction sender.\n * @param args.feePayerAuthenticator - The authenticator for the fee payer, required if the transaction has a fee payer address.\n * @param args.additionalSignersAuthenticators - Optional authenticators for additional signers in a multi-signer transaction.\n *\n * @returns A Uint8Array representing the signed transaction in bytes.\n *\n * @throws Error if the feePayerAuthenticator is not provided for a fee payer transaction.\n * @throws Error if additionalSignersAuthenticators are not provided for a multi-signer transaction.\n * @group Implementation\n * @category Transactions\n */\nexport function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array {\n  const { transaction, feePayerAuthenticator, additionalSignersAuthenticators } = args;\n  const senderAuthenticator = normalizeBundle(AccountAuthenticator, args.senderAuthenticator);\n\n  let txnAuthenticator: TransactionAuthenticator;\n  if (transaction.feePayerAddress) {\n    if (!feePayerAuthenticator) {\n      throw new Error(\"Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction\");\n    }\n    txnAuthenticator = new TransactionAuthenticatorFeePayer(\n      senderAuthenticator,\n      transaction.secondarySignerAddresses ?? [],\n      additionalSignersAuthenticators ?? [],\n      {\n        address: transaction.feePayerAddress,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n  } else if (transaction.secondarySignerAddresses) {\n    if (!additionalSignersAuthenticators) {\n      throw new Error(\n        \"Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction\",\n      );\n    }\n    txnAuthenticator = new TransactionAuthenticatorMultiAgent(\n      senderAuthenticator,\n      transaction.secondarySignerAddresses,\n      additionalSignersAuthenticators,\n    );\n  } else if (senderAuthenticator instanceof AccountAuthenticatorEd25519) {\n    txnAuthenticator = new TransactionAuthenticatorEd25519(\n      senderAuthenticator.public_key,\n      senderAuthenticator.signature,\n    );\n  } else if (senderAuthenticator instanceof AccountAuthenticatorMultiEd25519) {\n    txnAuthenticator = new TransactionAuthenticatorMultiEd25519(\n      senderAuthenticator.public_key,\n      senderAuthenticator.signature,\n    );\n  } else {\n    txnAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);\n  }\n\n  return new SignedTransaction(transaction.rawTransaction, txnAuthenticator).bcsToBytes();\n}\n\n/**\n * Hashes the set of values using a SHA-3 256 hash algorithm.\n * @param input - An array of UTF-8 strings or Uint8Array byte arrays to be hashed.\n * @group Implementation\n * @category Transactions\n */\nexport function hashValues(input: (Uint8Array | string)[]): Uint8Array {\n  const hash = sha3Hash.create();\n  for (const item of input) {\n    hash.update(item);\n  }\n  return hash.digest();\n}\n\n/**\n * The domain separated prefix for hashing transactions\n * @group Implementation\n * @category Transactions\n */\nconst TRANSACTION_PREFIX = hashValues([\"APTOS::Transaction\"]);\n\n/**\n * Generates a user transaction hash for the provided transaction payload, which must already have an authenticator.\n * This function helps ensure the integrity and uniqueness of the transaction by producing a hash based on the signed transaction data.\n *\n * @param args - The input data required to submit the transaction.\n * @param args.authenticator - The authenticator for the transaction.\n * @param args.payload - The payload containing the transaction details.\n * @param args.sender - The address of the sender initiating the transaction.\n * @param args.sequenceNumber - The sequence number of the transaction for the sender.\n * @group Implementation\n * @category Transactions\n */\nexport function generateUserTransactionHash(args: InputSubmitTransactionData): string {\n  const signedTransaction = generateSignedTransaction(args);\n\n  // Transaction signature is defined as, the domain separated prefix based on struct (Transaction)\n  // Then followed by the type of the transaction for the enum, UserTransaction is 0\n  // Then followed by BCS encoded bytes of the signed transaction\n  return new Hex(hashValues([TRANSACTION_PREFIX, new Uint8Array([0]), signedTransaction])).toString();\n}\n\n/**\n * Fetches and caches ABIs while allowing for pass-through on provided ABIs.\n *\n * @param key - A unique identifier for the cached ABI.\n * @param moduleAddress - The address of the module from which to fetch the ABI.\n * @param moduleName - The name of the module containing the function.\n * @param functionName - The name of the function whose ABI is being fetched.\n * @param aptosConfig - Configuration settings for Aptos.\n * @param abi - An optional ABI to use if already available.\n * @param fetch - A function to fetch the ABI if it is not provided.\n * @group Implementation\n * @category Transactions\n */\nasync function fetchAbi<T extends FunctionABI>({\n  key,\n  moduleAddress,\n  moduleName,\n  functionName,\n  aptosConfig,\n  abi,\n  fetch,\n}: {\n  key: string;\n  moduleAddress: string;\n  moduleName: string;\n  functionName: string;\n  aptosConfig: AptosConfig;\n  abi?: T;\n  fetch: (moduleAddress: string, moduleName: string, functionName: string, aptosConfig: AptosConfig) => Promise<T>;\n}): Promise<T> {\n  if (abi !== undefined) {\n    return abi;\n  }\n\n  // We fetch the entry function ABI, and then pretend that we already had the ABI\n  return memoizeAsync(\n    async () => fetch(moduleAddress, moduleName, functionName, aptosConfig),\n    `${key}-${aptosConfig.network}-${moduleAddress}-${moduleName}-${functionName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n}\n"],"mappings":"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","names":["transactionAuthenticator"]}

package/dist/esm/chunk-HQTQEHHZ.mjs

@@ -0,0 +1,195 @@
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+import {
+  FixedBytes
+} from "./chunk-Y3ENAKRC.mjs";
+import {
+  MoveOption,
+  MoveString,
+  MoveVector
+} from "./chunk-KSK3XIGF.mjs";
+import {
+  Bool,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8
+} from "./chunk-QSYWLSSN.mjs";
+
+// src/transactions/transactionBuilder/helpers.ts
+function isBool(arg) {
+  return typeof arg === "boolean";
+}
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+function convertNumber(arg) {
+  if (isNumber(arg)) {
+    return arg;
+  }
+  if (isString(arg) && arg !== "") {
+    return Number.parseInt(arg, 10);
+  }
+  return void 0;
+}
+function isLargeNumber(arg) {
+  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
+}
+function isEmptyOption(arg) {
+  return arg === null || arg === void 0;
+}
+function isEncodedEntryFunctionArgument(arg) {
+  return (
+    /**
+     * Determines if the provided argument is an instance of the Bool class.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsBool(arg) || /**
+     * Determines if the provided argument is an instance of U8.
+     * This function helps validate the type of the argument passed to ensure it is a U8 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU8(arg) || /**
+     * Determines if the provided argument is an instance of U16.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU16(arg) || /**
+     * Determines if the provided argument is an instance of U32.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U32 instance.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU32(arg) || /**
+     * Determine if the provided argument is an instance of U64.
+     * This function helps validate that the argument conforms to the expected U64 type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU64(arg) || /**
+     * Determines if the provided argument is an instance of U128.
+     * This function helps validate the type of the argument passed to ensure it is a U128 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU128(arg) || /**
+     * Determines if the provided argument is an instance of U256.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U256 instance.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU256(arg) || /**
+     * Determines if the provided argument is an instance of AccountAddress.
+     * This function helps validate whether a given input corresponds to a valid BCS address type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsAddress(arg) || /**
+     * Determine if the provided argument is an instance of MoveString.
+     *
+     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsString(arg) || /**
+     * Determine if the provided argument is an instance of FixedBytes.
+     * This function helps to validate the type of the argument being passed.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption
+  );
+}
+function isBcsBool(arg) {
+  return arg instanceof Bool;
+}
+function isBcsAddress(arg) {
+  return arg instanceof AccountAddress;
+}
+function isBcsString(arg) {
+  return arg instanceof MoveString;
+}
+function isBcsFixedBytes(arg) {
+  return arg instanceof FixedBytes;
+}
+function isBcsU8(arg) {
+  return arg instanceof U8;
+}
+function isBcsU16(arg) {
+  return arg instanceof U16;
+}
+function isBcsU32(arg) {
+  return arg instanceof U32;
+}
+function isBcsU64(arg) {
+  return arg instanceof U64;
+}
+function isBcsU128(arg) {
+  return arg instanceof U128;
+}
+function isBcsU256(arg) {
+  return arg instanceof U256;
+}
+function isScriptDataInput(arg) {
+  return "bytecode" in arg;
+}
+function throwTypeMismatch(expectedType, position) {
+  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
+}
+function findFirstNonSignerArg(functionAbi) {
+  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+  if (index < 0) {
+    return functionAbi.params.length;
+  }
+  return index;
+}
+
+export {
+  isBool,
+  isString,
+  isNumber,
+  convertNumber,
+  isLargeNumber,
+  isEmptyOption,
+  isEncodedEntryFunctionArgument,
+  isBcsBool,
+  isBcsAddress,
+  isBcsString,
+  isBcsFixedBytes,
+  isBcsU8,
+  isBcsU16,
+  isBcsU32,
+  isBcsU64,
+  isBcsU128,
+  isBcsU256,
+  isScriptDataInput,
+  throwTypeMismatch,
+  findFirstNonSignerArg
+};
+//# sourceMappingURL=chunk-HQTQEHHZ.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/transactionBuilder/helpers.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  EntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputScriptData,\n  SimpleEntryFunctionArgumentTypes,\n} from \"../types\";\nimport { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from \"../../bcs\";\nimport { AccountAddress } from \"../../core\";\nimport { MoveFunction } from \"../../types\";\n\n/**\n * Determines if the provided argument is of type boolean.\n * This can help in validating input types before processing them further.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a boolean.\n * @group Implementation\n * @category Transactions\n */\nexport function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {\n  return typeof arg === \"boolean\";\n}\n\n/**\n * Checks if the provided argument is of type string.\n *\n * @param arg - The value to be checked for string type.\n * @returns A boolean indicating whether the argument is a string.\n * @group Implementation\n * @category Transactions\n */\nexport function isString(arg: any): arg is string {\n  return typeof arg === \"string\";\n}\n\n/**\n * Determines if the provided argument is of type number.\n *\n * @param arg - The argument to check, which can be of various types.\n * @returns A boolean indicating whether the argument is a number.\n * @group Implementation\n * @category Transactions\n */\nexport function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {\n  return typeof arg === \"number\";\n}\n\n/**\n * Converts a number or a string representation of a number into a number type.\n * This function is useful for ensuring that the input is in a consistent numeric format,\n * which can help prevent type mismatches in further processing.\n *\n * @param arg - The input value to be converted. This can be a number, a string representing a number, or any other type.\n * @returns Returns the converted number if the input is valid; otherwise, it returns undefined.\n * @group Implementation\n * @category Transactions\n */\nexport function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | undefined {\n  if (isNumber(arg)) {\n    return arg;\n  }\n  if (isString(arg) && arg !== \"\") {\n    return Number.parseInt(arg, 10);\n  }\n\n  return undefined;\n}\n\n/**\n * Determines if the provided argument is a large number, which can be a number, bigint, or string representation of a number.\n *\n * @param arg - The argument to check, which can be of type number, bigint, or string.\n * @group Implementation\n * @category Transactions\n */\nexport function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {\n  return typeof arg === \"number\" || typeof arg === \"bigint\" || typeof arg === \"string\";\n}\n\n/**\n * Checks if the provided argument is empty, meaning it is either null or undefined.\n *\n * @param arg - The argument to check for emptiness.\n * @returns A boolean indicating whether the argument is empty.\n * @group Implementation\n * @category Transactions\n */\nexport function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {\n  return arg === null || arg === undefined;\n}\n\n/**\n * Determines if the provided argument is a valid encoded entry function argument type.\n * This function helps validate that the argument conforms to the expected types for entry function parameters.\n *\n * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n * @group Implementation\n * @category Transactions\n */\nexport function isEncodedEntryFunctionArgument(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is EntryFunctionArgumentTypes {\n  return (\n    /**\n     * Determines if the provided argument is an instance of the Bool class.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsBool(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U8.\n     * This function helps validate the type of the argument passed to ensure it is a U8 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU8(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U16.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU16(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U32.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U32 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU32(arg) ||\n    /**\n     * Determine if the provided argument is an instance of U64.\n     * This function helps validate that the argument conforms to the expected U64 type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU64(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U128.\n     * This function helps validate the type of the argument passed to ensure it is a U128 type.\n     *\n     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU128(arg) ||\n    /**\n     * Determines if the provided argument is an instance of U256.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @returns A boolean indicating whether the argument is a U256 instance.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsU256(arg) ||\n    /**\n     * Determines if the provided argument is an instance of AccountAddress.\n     * This function helps validate whether a given input corresponds to a valid BCS address type.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsAddress(arg) ||\n    /**\n     * Determine if the provided argument is an instance of MoveString.\n     *\n     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsString(arg) ||\n    /**\n     * Determine if the provided argument is an instance of FixedBytes.\n     * This function helps to validate the type of the argument being passed.\n     *\n     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.\n     * @group Implementation\n     * @category Transactions\n     */\n    isBcsFixedBytes(arg) ||\n    arg instanceof MoveVector ||\n    arg instanceof MoveOption\n  );\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool {\n  return arg instanceof Bool;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsAddress(\n  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,\n): arg is AccountAddress {\n  return arg instanceof AccountAddress;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString {\n  return arg instanceof MoveString;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes {\n  return arg instanceof FixedBytes;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8 {\n  return arg instanceof U8;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16 {\n  return arg instanceof U16;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32 {\n  return arg instanceof U32;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64 {\n  return arg instanceof U64;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128 {\n  return arg instanceof U128;\n}\n/**\n * @group Implementation\n * @category Transactions\n */\nexport function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {\n  return arg instanceof U256;\n}\n\n/**\n * Determines if the provided argument contains script data input by checking for the presence of bytecode.\n *\n * @param arg - The input data to be checked, which can either be a payload with remote ABI or a standard payload.\n * @param arg.bytecode - The bytecode of the script, present if the input is script data.\n * @param arg.function - The function associated with the transaction, which is relevant for standard payloads.\n * @param arg.args - The arguments for the function, applicable in the context of standard payloads.\n * @group Implementation\n * @category Transactions\n */\nexport function isScriptDataInput(\n  arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,\n): arg is InputScriptData {\n  return \"bytecode\" in arg;\n}\n\n/**\n * Throws an error indicating a type mismatch for a specified argument position.\n * This function helps in debugging by providing clear feedback on expected types.\n *\n * @param expectedType - The type that was expected for the argument.\n * @param position - The position of the argument that caused the type mismatch.\n * @group Implementation\n * @category Transactions\n */\nexport function throwTypeMismatch(expectedType: string, position: number) {\n  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);\n}\n\n/**\n * Finds the index of the first non-signer argument in the function ABI parameters.\n *\n * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in\n * by signatures and not by the caller. This function helps identify the position of the first argument that\n * can be provided by the caller, allowing for easier handling of function parameters.\n *\n * @param functionAbi - The ABI of the function to analyze.\n * @returns The index of the first non-signer argument, or the length of the parameters array if none are found.\n * @group Implementation\n * @category Transactions\n */\nexport function findFirstNonSignerArg(functionAbi: MoveFunction): number {\n  const index = functionAbi.params.findIndex((param) => param !== \"signer\" && param !== \"&signer\");\n  if (index < 0) {\n    return functionAbi.params.length;\n  }\n  return index;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBO,SAAS,OAAO,KAAuD;AAC5E,SAAO,OAAO,QAAQ;AACxB;AAUO,SAAS,SAAS,KAAyB;AAChD,SAAO,OAAO,QAAQ;AACxB;AAUO,SAAS,SAAS,KAAsD;AAC7E,SAAO,OAAO,QAAQ;AACxB;AAYO,SAAS,cAAc,KAA2D;AACvF,MAAI,SAAS,GAAG,GAAG;AACjB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,GAAG,KAAK,QAAQ,IAAI;AAC/B,WAAO,OAAO,SAAS,KAAK,EAAE;AAAA,EAChC;AAEA,SAAO;AACT;AASO,SAAS,cAAc,KAAwE;AACpG,SAAO,OAAO,QAAQ,YAAY,OAAO,QAAQ,YAAY,OAAO,QAAQ;AAC9E;AAUO,SAAS,cAAc,KAAgE;AAC5F,SAAO,QAAQ,QAAQ,QAAQ;AACjC;AAUO,SAAS,+BACd,KACmC;AACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQE,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,QAAQ,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQX,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,SAAS,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASZ,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,UAAU,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASb,aAAa,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQhB,YAAY,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASf,gBAAgB,GAAG,KACnB,eAAe,cACf,eAAe;AAAA;AAEnB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAKO,SAAS,aACd,KACuB;AACvB,SAAO,eAAe;AACxB;AAKO,SAAS,YAAY,KAAuF;AACjH,SAAO,eAAe;AACxB;AAKO,SAAS,gBAAgB,KAAuF;AACrH,SAAO,eAAe;AACxB;AAKO,SAAS,QAAQ,KAA+E;AACrG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,SAAS,KAAgF;AACvG,SAAO,eAAe;AACxB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAKO,SAAS,UAAU,KAAiF;AACzG,SAAO,eAAe;AACxB;AAYO,SAAS,kBACd,KACwB;AACxB,SAAO,cAAc;AACvB;AAWO,SAAS,kBAAkB,cAAsB,UAAkB;AACxE,QAAM,IAAI,MAAM,8BAA8B,QAAQ,eAAe,YAAY,GAAG;AACtF;AAcO,SAAS,sBAAsB,aAAmC;AACvE,QAAM,QAAQ,YAAY,OAAO,UAAU,CAAC,UAAU,UAAU,YAAY,UAAU,SAAS;AAC/F,MAAI,QAAQ,GAAG;AACb,WAAO,YAAY,OAAO;AAAA,EAC5B;AACA,SAAO;AACT;","names":[]}

package/dist/esm/chunk-I25AX6PQ.mjs

@@ -0,0 +1,7 @@
+// src/version.ts
+var VERSION = "1.35.0";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-I25AX6PQ.mjs.map

package/dist/esm/{chunk-77AEKF7K.mjs.map → chunk-I25AX6PQ.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/version.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The current version of the SDK\n *\n * hardcoded for now, we would want to have it injected dynamically\n */\nexport const VERSION = \"1.33.2\";\n"],"mappings":"AAQO,IAAMA,EAAU","names":["VERSION"]}
+{"version":3,"sources":["../../src/version.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The current version of the SDK\n *\n * hardcoded for now, we would want to have it injected dynamically\n */\nexport const VERSION = \"1.35.0\";\n"],"mappings":";AAQO,IAAM,UAAU;","names":[]}

package/dist/esm/chunk-I4OHHVRF.mjs

@@ -0,0 +1,125 @@
+import {
+  AbstractKeylessAccount
+} from "./chunk-46VPRC7E.mjs";
+import {
+  KeylessPublicKey,
+  getIssAudAndUidVal
+} from "./chunk-T573PCIR.mjs";
+import {
+  Deserializer
+} from "./chunk-NUT2VOX2.mjs";
+import {
+  Hex
+} from "./chunk-BDM6FBUO.mjs";
+
+// src/account/KeylessAccount.ts
+var KeylessAccount = class _KeylessAccount extends AbstractKeylessAccount {
+  // Use the static constructor 'create' instead.
+  /**
+   * Use the static generator `create(...)` instead.
+   * Creates an instance of the KeylessAccount with an optional proof.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.iss - A JWT issuer.
+   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
+   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+   * OIDC registration with the identity provider.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  constructor(args) {
+    const publicKey = KeylessPublicKey.create(args);
+    super({ publicKey, ...args });
+    this.publicKey = publicKey;
+  }
+  /**
+   * Serializes the transaction data into a format suitable for transmission or storage.
+   * This function ensures that both the transaction bytes and the proof are properly serialized.
+   *
+   * @param serializer - The serializer instance used to convert the transaction data into bytes.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  serialize(serializer) {
+    super.serialize(serializer);
+  }
+  /**
+   * Deserializes the provided deserializer to create a KeylessAccount instance.
+   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+   *
+   * @param deserializer - The deserializer instance used to retrieve the serialized data.
+   * @returns A KeylessAccount instance created from the deserialized data.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  static deserialize(deserializer) {
+    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new _KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      verificationKeyHash
+    });
+  }
+  /**
+   * Deserialize bytes using this account's information.
+   *
+   * @param bytes The bytes being interpreted.
+   * @returns
+   */
+  static fromBytes(bytes) {
+    return _KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
+  }
+  /**
+   * Creates a KeylessAccount instance using the provided parameters.
+   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+   * This is used instead of the KeylessAccount constructor.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @param args.uidKey - Optional key for user identification, defaults to "sub".
+   * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  static create(args) {
+    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = "sub", proofFetchCallback, verificationKey } = args;
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new _KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      proofFetchCallback,
+      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
+    });
+  }
+};
+
+export {
+  KeylessAccount
+};
+//# sourceMappingURL=chunk-I4OHHVRF.mjs.map

package/dist/esm/{chunk-M77M6NSB.mjs.map → chunk-I4OHHVRF.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class KeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The KeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  // Use the static constructor 'create' instead.\n\n  /**\n   * Use the static generator `create(...)` instead.\n   * Creates an instance of the KeylessAccount with an optional proof.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.iss - A JWT issuer.\n   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.\n   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n  }) {\n    const publicKey = KeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): KeylessAccount {\n    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = \"sub\", proofFetchCallback, verificationKey } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":"2KAwBO,IAAMA,EAAN,MAAMC,UAAuBC,CAAuB,CA6BzD,YAAYC,EAYT,CACD,IAAMC,EAAYC,EAAiB,OAAOF,CAAI,EAC9C,MAAM,CAAE,UAAAC,EAAW,GAAGD,CAAK,CAAC,EAC5B,KAAK,UAAYC,CACnB,CAUA,UAAUE,EAA8B,CACtC,MAAM,UAAUA,CAAU,CAC5B,CAWA,OAAO,YAAYC,EAA4C,CAC7D,GAAM,CAAE,QAAAC,EAAS,MAAAC,EAAO,iBAAAC,EAAkB,IAAAC,EAAK,OAAAC,EAAQ,OAAAC,EAAQ,oBAAAC,CAAoB,EACjFZ,EAAuB,mBAAmBK,CAAY,EAClD,CAAE,IAAAQ,EAAK,IAAAC,EAAK,OAAAC,CAAO,EAAIC,EAAmB,CAAE,IAAAP,EAAK,OAAAC,CAAO,CAAC,EAC/D,OAAO,IAAIX,EAAe,CACxB,QAAAO,EACA,MAAAC,EACA,iBAAAC,EACA,IAAAK,EACA,OAAAH,EACA,OAAAK,EACA,IAAAD,EACA,OAAAH,EACA,IAAAF,EACA,oBAAAG,CACF,CAAC,CACH,CAQA,OAAO,UAAUK,EAAiC,CAChD,OAAOlB,EAAe,YAAY,IAAImB,EAAaC,EAAI,qBAAqBF,CAAK,CAAC,CAAC,CACrF,CAkBA,OAAO,OAAOhB,EASK,CACjB,GAAM,CAAE,QAAAK,EAAS,MAAAC,EAAO,IAAAE,EAAK,iBAAAD,EAAkB,OAAAG,EAAQ,OAAAD,EAAS,MAAO,mBAAAU,EAAoB,gBAAAC,CAAgB,EAAIpB,EAEzG,CAAE,IAAAY,EAAK,IAAAC,EAAK,OAAAC,CAAO,EAAIC,EAAmB,CAAE,IAAAP,EAAK,OAAAC,CAAO,CAAC,EAC/D,OAAO,IAAIX,EAAe,CACxB,QAAAO,EACA,MAAAC,EACA,iBAAAC,EACA,IAAAK,EACA,OAAAH,EACA,OAAAK,EACA,IAAAD,EACA,OAAAH,EACA,IAAAF,EACA,mBAAAW,EACA,oBAAqBC,EAAkBA,EAAgB,KAAK,EAAI,MAClE,CAAC,CACH,CACF","names":["KeylessAccount","_KeylessAccount","AbstractKeylessAccount","args","publicKey","KeylessPublicKey","serializer","deserializer","address","proof","ephemeralKeyPair","jwt","uidKey","pepper","verificationKeyHash","iss","aud","uidVal","getIssAudAndUidVal","bytes","Deserializer","Hex","proofFetchCallback","verificationKey"]}
+{"version":3,"sources":["../../src/account/KeylessAccount.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { HexInput } from \"../types\";\nimport { AccountAddress } from \"../core/accountAddress\";\nimport { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from \"../core/crypto\";\n\nimport { EphemeralKeyPair } from \"./EphemeralKeyPair\";\nimport { Deserializer, Serializer } from \"../bcs\";\nimport { AbstractKeylessAccount, ProofFetchCallback } from \"./AbstractKeylessAccount\";\nimport { Hex } from \"../core/hex\";\n\n/**\n * Account implementation for the Keyless authentication scheme.\n *\n * Used to represent a Keyless based account and sign transactions with it.\n *\n * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.\n *\n * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,\n * EphemeralKeyPair, and corresponding proof.\n * @group Implementation\n * @category Account (On-Chain Model)\n */\nexport class KeylessAccount extends AbstractKeylessAccount {\n  /**\n   * The KeylessPublicKey associated with the account\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly publicKey: KeylessPublicKey;\n\n  // Use the static constructor 'create' instead.\n\n  /**\n   * Use the static generator `create(...)` instead.\n   * Creates an instance of the KeylessAccount with an optional proof.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.iss - A JWT issuer.\n   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.\n   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.\n   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's\n   * OIDC registration with the identity provider.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  constructor(args: {\n    address?: AccountAddress;\n    ephemeralKeyPair: EphemeralKeyPair;\n    iss: string;\n    uidKey: string;\n    uidVal: string;\n    aud: string;\n    pepper: HexInput;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    proofFetchCallback?: ProofFetchCallback;\n    jwt: string;\n    verificationKeyHash?: HexInput;\n  }) {\n    const publicKey = KeylessPublicKey.create(args);\n    super({ publicKey, ...args });\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Serializes the transaction data into a format suitable for transmission or storage.\n   * This function ensures that both the transaction bytes and the proof are properly serialized.\n   *\n   * @param serializer - The serializer instance used to convert the transaction data into bytes.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  serialize(serializer: Serializer): void {\n    super.serialize(serializer);\n  }\n\n  /**\n   * Deserializes the provided deserializer to create a KeylessAccount instance.\n   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.\n   *\n   * @param deserializer - The deserializer instance used to retrieve the serialized data.\n   * @returns A KeylessAccount instance created from the deserialized data.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static deserialize(deserializer: Deserializer): KeylessAccount {\n    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =\n      AbstractKeylessAccount.partialDeserialize(deserializer);\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      verificationKeyHash,\n    });\n  }\n\n  /**\n   * Deserialize bytes using this account's information.\n   *\n   * @param bytes The bytes being interpreted.\n   * @returns\n   */\n  static fromBytes(bytes: HexInput): KeylessAccount {\n    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));\n  }\n\n  /**\n   * Creates a KeylessAccount instance using the provided parameters.\n   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.\n   * This is used instead of the KeylessAccount constructor.\n   *\n   * @param args - The parameters for creating a KeylessAccount.\n   * @param args.address - Optional account address associated with the KeylessAccount.\n   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.\n   * @param args.jwt - A JSON Web Token used for authentication.\n   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.\n   * @param args.pepper - A hexadecimal input used for additional security.\n   * @param args.uidKey - Optional key for user identification, defaults to \"sub\".\n   * @param args.proofFetchCallback - Optional callback function for fetching proof.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  static create(args: {\n    address?: AccountAddress;\n    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;\n    jwt: string;\n    ephemeralKeyPair: EphemeralKeyPair;\n    pepper: HexInput;\n    uidKey?: string;\n    proofFetchCallback?: ProofFetchCallback;\n    verificationKey?: Groth16VerificationKey;\n  }): KeylessAccount {\n    const { address, proof, jwt, ephemeralKeyPair, pepper, uidKey = \"sub\", proofFetchCallback, verificationKey } = args;\n\n    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });\n    return new KeylessAccount({\n      address,\n      proof,\n      ephemeralKeyPair,\n      iss,\n      uidKey,\n      uidVal,\n      aud,\n      pepper,\n      jwt,\n      proofFetchCallback,\n      verificationKeyHash: verificationKey ? verificationKey.hash() : undefined,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBO,IAAM,iBAAN,MAAM,wBAAuB,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA6BzD,YAAY,MAYT;AACD,UAAM,YAAY,iBAAiB,OAAO,IAAI;AAC9C,UAAM,EAAE,WAAW,GAAG,KAAK,CAAC;AAC5B,SAAK,YAAY;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,UAAU,YAA8B;AACtC,UAAM,UAAU,UAAU;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,YAAY,cAA4C;AAC7D,UAAM,EAAE,SAAS,OAAO,kBAAkB,KAAK,QAAQ,QAAQ,oBAAoB,IACjF,uBAAuB,mBAAmB,YAAY;AACxD,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAO,UAAU,OAAiC;AAChD,WAAO,gBAAe,YAAY,IAAI,aAAa,IAAI,qBAAqB,KAAK,CAAC,CAAC;AAAA,EACrF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,OAAO,OAAO,MASK;AACjB,UAAM,EAAE,SAAS,OAAO,KAAK,kBAAkB,QAAQ,SAAS,OAAO,oBAAoB,gBAAgB,IAAI;AAE/G,UAAM,EAAE,KAAK,KAAK,OAAO,IAAI,mBAAmB,EAAE,KAAK,OAAO,CAAC;AAC/D,WAAO,IAAI,gBAAe;AAAA,MACxB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,qBAAqB,kBAAkB,gBAAgB,KAAK,IAAI;AAAA,IAClE,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/esm/chunk-I6QE3PKO.mjs

@@ -0,0 +1,100 @@
+import {
+  generateSigningMessageForTransaction
+} from "./chunk-JOVCSFQC.mjs";
+import {
+  AccountAuthenticatorMultiEd25519
+} from "./chunk-AGKEC2IM.mjs";
+import {
+  MultiEd25519Signature
+} from "./chunk-3TUV6YMI.mjs";
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+
+// src/account/MultiEd25519Account.ts
+var MultiEd25519Account = class {
+  // region Constructors
+  constructor(args) {
+    this.signingScheme = 1 /* MultiEd25519 */;
+    const { signers, publicKey, address } = args;
+    this.publicKey = publicKey;
+    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
+    if (publicKey.threshold > signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `Not enough signers provided to satisfy the required signatures. Need ${publicKey.threshold} signers, but only ${signers.length} provided`
+      );
+    } else if (publicKey.threshold < signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `More signers provided than required. Need ${publicKey.threshold} signers, but ${signers.length} provided`
+      );
+    }
+    const bitPositions = [];
+    for (const signer of signers) {
+      bitPositions.push(this.publicKey.getIndex(signer.publicKey()));
+    }
+    const signersAndBitPosition = signers.map((signer, index) => [
+      signer,
+      bitPositions[index]
+    ]);
+    signersAndBitPosition.sort((a, b) => a[1] - b[1]);
+    this.signers = signersAndBitPosition.map((value) => value[0]);
+    this.signerIndices = signersAndBitPosition.map((value) => value[1]);
+    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
+  }
+  // endregion
+  // region Account
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * @param args.message raw message data in HexInput format
+   * @param args.signature signed message Signature
+   * @returns
+   */
+  verifySignature(args) {
+    return this.publicKey.verifySignature(args);
+  }
+  /**
+   * Sign a message using the account's Ed25519 private key.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message) {
+    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.sign(message));
+  }
+  /**
+   * Sign a transaction using the account's Ed25519 private keys.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction) {
+    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.signTransaction(transaction));
+  }
+  /**
+   * Sign the given message using the account's Ed25519 private keys.
+   * @param message in HexInput format
+   * @returns MultiEd25519Signature
+   */
+  sign(message) {
+    const signatures = [];
+    for (const signer of this.signers) {
+      signatures.push(signer.sign(message));
+    }
+    return new MultiEd25519Signature({ signatures, bitmap: this.signaturesBitmap });
+  }
+  /**
+   * Sign the given transaction using the available signing capabilities.
+   * @param transaction the transaction to be signed
+   * @returns Signature
+   */
+  signTransaction(transaction) {
+    return this.sign(generateSigningMessageForTransaction(transaction));
+  }
+  // endregion
+};
+
+export {
+  MultiEd25519Account
+};
+//# sourceMappingURL=chunk-I6QE3PKO.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/account/MultiEd25519Account.ts"],"sourcesContent":["import { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { Ed25519PrivateKey } from \"../core/crypto\";\nimport { MultiEd25519PublicKey, MultiEd25519Signature } from \"../core/crypto/multiEd25519\";\nimport { AccountAuthenticatorMultiEd25519 } from \"../transactions/authenticator/account\";\nimport { generateSigningMessageForTransaction } from \"../transactions/transactionBuilder/signingMessage\";\nimport { AnyRawTransaction } from \"../transactions/types\";\nimport { HexInput, SigningScheme } from \"../types\";\nimport type { Account } from \"./Account\";\n\nexport interface MultiEd25519SignerConstructorArgs {\n  publicKey: MultiEd25519PublicKey;\n  signers: Ed25519PrivateKey[];\n  address?: AccountAddressInput;\n}\n\nexport interface VerifyMultiEd25519SignatureArgs {\n  message: HexInput;\n  signature: MultiEd25519Signature;\n}\n\n/**\n * Signer implementation for the Multi-Ed25519 authentication scheme.\n *\n * Note: This authentication scheme is a legacy authentication scheme.  Prefer using MultiKeyAccounts as a\n * MultiKeyAccount can support any type of signer, not just Ed25519.  Generating a signer instance does not\n * create the account on-chain.\n */\nexport class MultiEd25519Account implements Account {\n  readonly publicKey: MultiEd25519PublicKey;\n\n  readonly accountAddress: AccountAddress;\n\n  readonly signingScheme = SigningScheme.MultiEd25519;\n\n  /**\n   * The signers used to sign messages.  These signers should correspond to public keys in the\n   * MultiEd25519Account.  The number of signers should be equal to this.publicKey.threshold.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signers: Ed25519PrivateKey[];\n\n  /**\n   * An array of indices where for signer[i], signerIndicies[i] is the index of the corresponding public key in\n   * publicKey.publicKeys.  Used to derive the right public key to use for verification.\n   * @group Implementation\n   * @category Account (On-Chain Model)\n   */\n  readonly signerIndices: number[];\n\n  readonly signaturesBitmap: Uint8Array;\n\n  // region Constructors\n\n  constructor(args: MultiEd25519SignerConstructorArgs) {\n    const { signers, publicKey, address } = args;\n    this.publicKey = publicKey;\n    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();\n\n    if (publicKey.threshold > signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `Not enough signers provided to satisfy the required signatures. Need ${publicKey.threshold} signers, but only ${signers.length} provided`,\n      );\n    } else if (publicKey.threshold < signers.length) {\n      throw new Error(\n        // eslint-disable-next-line max-len\n        `More signers provided than required. Need ${publicKey.threshold} signers, but ${signers.length} provided`,\n      );\n    }\n\n    // For each signer, find its corresponding position in the public keys array\n    const bitPositions: number[] = [];\n    for (const signer of signers) {\n      bitPositions.push(this.publicKey.getIndex(signer.publicKey()));\n    }\n\n    // Create pairs of [signer, position] and sort them by position\n    // This sorting is critical because:\n    // 1. The on-chain verification expects signatures to be in ascending order by bit position\n    // 2. The bitmap must match the order of signatures when verifying\n    const signersAndBitPosition: [Ed25519PrivateKey, number][] = signers.map((signer, index) => [\n      signer,\n      bitPositions[index],\n    ]);\n    signersAndBitPosition.sort((a, b) => a[1] - b[1]);\n\n    // Extract the sorted signers and their positions into separate arrays\n    this.signers = signersAndBitPosition.map((value) => value[0]);\n    this.signerIndices = signersAndBitPosition.map((value) => value[1]);\n\n    // Create a bitmap representing which public keys from the MultiEd25519PublicKey are being used\n    // This bitmap is used during signature verification to identify which public keys\n    // should be used to verify each signature\n    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });\n  }\n\n  // endregion\n\n  // region Account\n\n  /**\n   * Verify the given message and signature with the public key.\n   *\n   * @param args.message raw message data in HexInput format\n   * @param args.signature signed message Signature\n   * @returns\n   */\n  verifySignature(args: VerifyMultiEd25519SignatureArgs): boolean {\n    return this.publicKey.verifySignature(args);\n  }\n\n  /**\n   * Sign a message using the account's Ed25519 private key.\n   * @param message the signing message, as binary input\n   * @return the AccountAuthenticator containing the signature, together with the account's public key\n   */\n  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiEd25519 {\n    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.sign(message));\n  }\n\n  /**\n   * Sign a transaction using the account's Ed25519 private keys.\n   * @param transaction the raw transaction\n   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key\n   */\n  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiEd25519 {\n    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.signTransaction(transaction));\n  }\n\n  /**\n   * Sign the given message using the account's Ed25519 private keys.\n   * @param message in HexInput format\n   * @returns MultiEd25519Signature\n   */\n  sign(message: HexInput): MultiEd25519Signature {\n    const signatures = [];\n    for (const signer of this.signers) {\n      signatures.push(signer.sign(message));\n    }\n    return new MultiEd25519Signature({ signatures, bitmap: this.signaturesBitmap });\n  }\n\n  /**\n   * Sign the given transaction using the available signing capabilities.\n   * @param transaction the transaction to be signed\n   * @returns Signature\n   */\n  signTransaction(transaction: AnyRawTransaction): MultiEd25519Signature {\n    return this.sign(generateSigningMessageForTransaction(transaction));\n  }\n\n  // endregion\n}\n"],"mappings":";;;;;;;;;;;;;;AA2BO,IAAM,sBAAN,MAA6C;AAAA;AAAA,EA2BlD,YAAY,MAAyC;AAtBrD,SAAS;AAuBP,UAAM,EAAE,SAAS,WAAW,QAAQ,IAAI;AACxC,SAAK,YAAY;AACjB,SAAK,iBAAiB,UAAU,eAAe,KAAK,OAAO,IAAI,KAAK,UAAU,QAAQ,EAAE,eAAe;AAEvG,QAAI,UAAU,YAAY,QAAQ,QAAQ;AACxC,YAAM,IAAI;AAAA;AAAA,QAER,wEAAwE,UAAU,SAAS,sBAAsB,QAAQ,MAAM;AAAA,MACjI;AAAA,IACF,WAAW,UAAU,YAAY,QAAQ,QAAQ;AAC/C,YAAM,IAAI;AAAA;AAAA,QAER,6CAA6C,UAAU,SAAS,iBAAiB,QAAQ,MAAM;AAAA,MACjG;AAAA,IACF;AAGA,UAAM,eAAyB,CAAC;AAChC,eAAW,UAAU,SAAS;AAC5B,mBAAa,KAAK,KAAK,UAAU,SAAS,OAAO,UAAU,CAAC,CAAC;AAAA,IAC/D;AAMA,UAAM,wBAAuD,QAAQ,IAAI,CAAC,QAAQ,UAAU;AAAA,MAC1F;AAAA,MACA,aAAa,KAAK;AAAA,IACpB,CAAC;AACD,0BAAsB,KAAK,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;AAGhD,SAAK,UAAU,sBAAsB,IAAI,CAAC,UAAU,MAAM,CAAC,CAAC;AAC5D,SAAK,gBAAgB,sBAAsB,IAAI,CAAC,UAAU,MAAM,CAAC,CAAC;AAKlE,SAAK,mBAAmB,KAAK,UAAU,aAAa,EAAE,MAAM,aAAa,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,gBAAgB,MAAgD;AAC9D,WAAO,KAAK,UAAU,gBAAgB,IAAI;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,sBAAsB,SAAqD;AACzE,WAAO,IAAI,iCAAiC,KAAK,WAAW,KAAK,KAAK,OAAO,CAAC;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iCAAiC,aAAkE;AACjG,WAAO,IAAI,iCAAiC,KAAK,WAAW,KAAK,gBAAgB,WAAW,CAAC;AAAA,EAC/F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,KAAK,SAA0C;AAC7C,UAAM,aAAa,CAAC;AACpB,eAAW,UAAU,KAAK,SAAS;AACjC,iBAAW,KAAK,OAAO,KAAK,OAAO,CAAC;AAAA,IACtC;AACA,WAAO,IAAI,sBAAsB,EAAE,YAAY,QAAQ,KAAK,iBAAiB,CAAC;AAAA,EAChF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAgB,aAAuD;AACrE,WAAO,KAAK,KAAK,qCAAqC,WAAW,CAAC;AAAA,EACpE;AAAA;AAGF;","names":[]}