@aptos-labs/ts-sdk 0.0.7 → 1.0.0

package/dist/esm/chunk-MNFGMNYS.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 { Account } from \"../../core/account\";\nimport { AnyPublicKey } from \"../../core/crypto/anyPublicKey\";\nimport { AnySignature } from \"../../core/crypto/anySignature\";\nimport { Ed25519PublicKey, Ed25519Signature } from \"../../core/crypto/ed25519\";\nimport { Secp256k1PublicKey, Secp256k1Signature } from \"../../core/crypto/secp256k1\";\nimport { getInfo } from \"../../internal/account\";\nimport { getLedgerInfo } from \"../../internal/general\";\nimport { getGasPriceEstimation } from \"../../internal/transaction\";\nimport { NetworkToChainId } from \"../../utils/apiEndpoints\";\nimport {\n  DEFAULT_MAX_GAS_AMOUNT,\n  DEFAULT_TXN_EXP_SEC_FROM_NOW,\n  RAW_TRANSACTION_SALT,\n  RAW_TRANSACTION_WITH_DATA_SALT,\n} from \"../../utils/const\";\nimport {\n  AccountAuthenticator,\n  AccountAuthenticatorEd25519,\n  AccountAuthenticatorMultiKey,\n  AccountAuthenticatorSingleKey,\n} from \"../authenticator/account\";\nimport {\n  TransactionAuthenticatorEd25519,\n  TransactionAuthenticatorFeePayer,\n  TransactionAuthenticatorMultiAgent,\n  TransactionAuthenticatorSingleSender,\n} from \"../authenticator/transaction\";\nimport {\n  ChainId,\n  EntryFunction,\n  FeePayerRawTransaction,\n  MultiAgentRawTransaction,\n  MultiSig,\n  MultisigTransactionPayload,\n  RawTransaction,\n  Script,\n  TransactionPayloadEntryFunction,\n  TransactionPayloadMultisig,\n  TransactionPayloadScript,\n} from \"../instances\";\nimport { SignedTransaction } from \"../instances/signedTransaction\";\nimport {\n  AnyRawTransaction,\n  AnyTransactionPayloadInstance,\n  AnyRawTransactionInstance,\n  EntryFunctionArgumentTypes,\n  EntryFunctionABI,\n  InputGenerateMultiAgentRawTransactionArgs,\n  InputGenerateRawTransactionArgs,\n  InputGenerateSingleSignerRawTransactionArgs,\n  SingleSignerTransaction,\n  InputGenerateTransactionOptions,\n  MultiAgentTransaction,\n  InputScriptData,\n  InputSimulateTransactionData,\n  InputGenerateTransactionPayloadData,\n  InputEntryFunctionData,\n  InputMultiSigData,\n  InputMultiSigDataWithRemoteABI,\n  InputEntryFunctionDataWithRemoteABI,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputSubmitTransactionData,\n} from \"../types\";\nimport { convertArgument, fetchEntryFunctionAbi, standardizeTypeTags } from \"./remoteAbi\";\nimport { memoizeAsync } from \"../../utils/memoize\";\nimport { SigningScheme } from \"../../types\";\nimport { getFunctionParts, isScriptDataInput } from \"./helpers\";\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for our `generateTransactionPayload` function.\n * When we call our `generateTransactionPayload` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n */\nexport async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;\nexport async function generateTransactionPayload(\n  args: InputEntryFunctionDataWithRemoteABI,\n): Promise<TransactionPayloadEntryFunction>;\nexport async function generateTransactionPayload(\n  args: InputMultiSigDataWithRemoteABI,\n): Promise<TransactionPayloadMultisig>;\n\n/**\n * Builds a transaction payload based on the data argument and returns\n * a transaction payload - TransactionPayloadScript | TransactionPayloadMultisig | TransactionPayloadEntryFunction\n *\n * This uses the RemoteABI by default, and the remote ABI can be skipped by using generateTransactionPayloadWithABI\n *\n * @param args.data GenerateTransactionPayloadData\n *\n * @return TransactionPayload\n */\nexport async function generateTransactionPayload(\n  args: InputGenerateTransactionPayloadDataWithRemoteABI,\n): Promise<AnyTransactionPayloadInstance> {\n  if (isScriptDataInput(args)) {\n    return generateTransactionPayloadScript(args);\n  }\n\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // We fetch the entry function ABI, and then pretend that we already had the ABI\n  const functionAbi = await memoizeAsync(\n    async () => fetchEntryFunctionAbi(moduleAddress, moduleName, functionName, args.aptosConfig),\n    `entry-function-${args.aptosConfig.network}-${moduleAddress}-${moduleName}-${functionName}`,\n    1000 * 60 * 5, // 5 minutes\n  )();\n\n  return generateTransactionPayloadWithABI(args, functionAbi);\n}\n\nexport function generateTransactionPayloadWithABI(\n  args: InputEntryFunctionData,\n  functionAbi: EntryFunctionABI,\n): TransactionPayloadEntryFunction;\nexport function generateTransactionPayloadWithABI(\n  args: InputMultiSigData,\n  functionAbi: EntryFunctionABI,\n): TransactionPayloadMultisig;\nexport function generateTransactionPayloadWithABI(\n  args: InputGenerateTransactionPayloadData,\n  functionAbi: EntryFunctionABI,\n): AnyTransactionPayloadInstance {\n  if (isScriptDataInput(args)) {\n    return generateTransactionPayloadScript(args);\n  }\n\n  const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);\n\n  // Ensure that all type arguments are typed properly\n  const typeArguments = standardizeTypeTags(args.typeArguments);\n\n  // Check the type argument count against the ABI\n  if (typeArguments.length !== functionAbi.typeParameters.length) {\n    throw new Error(\n      `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,\n    );\n  }\n\n  // Check all BCS types, and convert any non-BCS types\n  const functionArguments: Array<EntryFunctionArgumentTypes> = args.functionArguments.map((arg, i) =>\n    convertArgument(args.function, functionAbi, arg, i, typeArguments),\n  );\n\n  // Check that all arguments are accounted for\n  if (functionArguments.length !== functionAbi.parameters.length) {\n    throw new Error(\n      // eslint-disable-next-line max-len\n      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,\n    );\n  }\n\n  // Generate entry function payload\n  const entryFunctionPayload = EntryFunction.build(\n    `${moduleAddress}::${moduleName}`,\n    functionName,\n    typeArguments,\n    functionArguments,\n  );\n\n  // Send it as multi sig if it's a multisig payload\n  if (\"multisigAddress\" in args) {\n    const multisigAddress = AccountAddress.from(args.multisigAddress);\n    return new TransactionPayloadMultisig(\n      new MultiSig(multisigAddress, new MultisigTransactionPayload(entryFunctionPayload)),\n    );\n  }\n\n  // Otherwise send as an entry function\n  return new TransactionPayloadEntryFunction(entryFunctionPayload);\n}\n\nfunction generateTransactionPayloadScript(args: InputScriptData) {\n  return new TransactionPayloadScript(\n    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), args.typeArguments ?? [], args.functionArguments),\n  );\n}\n\n/**\n * Generates a raw transaction\n *\n * @param args.aptosConfig AptosConfig\n * @param args.sender The transaction's sender account address as a hex input\n * @param args.payload The transaction payload - can create by using generateTransactionPayload()\n *\n * @returns RawTransaction\n */\nexport async function generateRawTransaction(args: {\n  aptosConfig: AptosConfig;\n  sender: AccountAddressInput;\n  payload: AnyTransactionPayloadInstance;\n  options?: InputGenerateTransactionOptions;\n}): Promise<RawTransaction> {\n  const { aptosConfig, sender, payload, options } = args;\n\n  const getSequenceNumber =\n    options?.accountSequenceNumber !== undefined\n      ? Promise.resolve({ sequence_number: options.accountSequenceNumber })\n      : getInfo({ aptosConfig, accountAddress: sender });\n\n  const getChainId = NetworkToChainId[aptosConfig.network]\n    ? Promise.resolve({ chain_id: NetworkToChainId[aptosConfig.network] })\n    : getLedgerInfo({ aptosConfig });\n\n  const getGasUnitPrice = options?.gasUnitPrice\n    ? Promise.resolve({ gas_estimate: options.gasUnitPrice })\n    : getGasPriceEstimation({ aptosConfig });\n\n  const [{ sequence_number: sequenceNumber }, { chain_id: chainId }, { gas_estimate: gasEstimate }] = await Promise.all(\n    [getSequenceNumber, getChainId, getGasUnitPrice],\n  );\n\n  const { maxGasAmount, gasUnitPrice, expireTimestamp } = {\n    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),\n    gasUnitPrice: BigInt(gasEstimate),\n    expireTimestamp: BigInt(Math.floor(Date.now() / 1000) + DEFAULT_TXN_EXP_SEC_FROM_NOW),\n    ...options,\n  };\n\n  return new RawTransaction(\n    AccountAddress.from(sender),\n    BigInt(sequenceNumber),\n    payload,\n    BigInt(maxGasAmount),\n    BigInt(gasUnitPrice),\n    BigInt(expireTimestamp),\n    new ChainId(chainId),\n  );\n}\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for our `generateTransaction` function.\n * When we call our `generateTransaction` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n */\nexport async function buildTransaction(\n  args: InputGenerateSingleSignerRawTransactionArgs,\n): Promise<SingleSignerTransaction>;\nexport async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;\n\n/**\n * Generates a transaction based on the provided arguments\n *\n * Note: we can start with one function to support all different payload/transaction types,\n * and if to complex to use, we could have function for each type\n *\n * @param args.aptosConfig AptosConfig\n * @param args.sender The transaction's sender account address as a hex input\n * @param args.payload The transaction payload - can create by using generateTransactionPayload()\n * @param args.options optional. Transaction options object\n * @param args.secondarySignerAddresses optional. For when want to create a multi signers transaction\n * @param args.feePayerAddress optional. For when want to create a fee payer (aka sponsored) transaction\n *\n * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses\n * ```\n * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses? : Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n */\nexport async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction> {\n  const { aptosConfig, sender, payload, options } = args;\n  // generate raw transaction\n  const rawTxn = await generateRawTransaction({\n    aptosConfig,\n    sender,\n    payload,\n    options,\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 {\n      rawTransaction: rawTxn,\n      secondarySignerAddresses: signers,\n      feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,\n    };\n  }\n  // return the raw transaction\n  return {\n    rawTransaction: rawTxn,\n    feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,\n  };\n}\n\n/**\n * Simulate a transaction before signing and submit to chain\n *\n * @param args.transaction A aptos transaction type to sign\n * @param args.signerPublicKey The signer public key\n * @param args.secondarySignersPublicKeys optional. The secondary signers public keys if multi signers transaction\n * @param args.feePayerPublicKey optional. The fee payer public key is a fee payer (aka sponsored) transaction\n * @param args.options optional. SimulateTransactionOptions\n *\n * @returns A signed serialized transaction that can be simulated\n */\nexport function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {\n  const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;\n\n  const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);\n\n  // fee payer transaction\n  if (transaction.feePayerAddress) {\n    const transactionToSign = new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n    if (secondarySignersPublicKeys) {\n      secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>\n        getAuthenticatorForSimulation(publicKey),\n      );\n    }\n    const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey!);\n\n    const transactionAuthenticator = new TransactionAuthenticatorFeePayer(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses ?? [],\n      secondaryAccountAuthenticators,\n      {\n        address: transaction.feePayerAddress,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // multi agent transaction\n  if (transaction.secondarySignerAddresses) {\n    const transactionToSign = new MultiAgentRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses,\n    );\n\n    let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];\n\n    secondaryAccountAuthenticators = secondarySignersPublicKeys!.map((publicKey) =>\n      getAuthenticatorForSimulation(publicKey),\n    );\n\n    const transactionAuthenticator = new TransactionAuthenticatorMultiAgent(\n      accountAuthenticator,\n      transaction.secondarySignerAddresses,\n      secondaryAccountAuthenticators,\n    );\n\n    return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();\n  }\n\n  // single signer raw transaction\n  let transactionAuthenticator;\n  if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {\n    transactionAuthenticator = new TransactionAuthenticatorEd25519(\n      accountAuthenticator.public_key,\n      accountAuthenticator.signature,\n    );\n  } else if (accountAuthenticator instanceof AccountAuthenticatorSingleKey) {\n    transactionAuthenticator = new TransactionAuthenticatorSingleSender(accountAuthenticator);\n  } else {\n    throw new Error(\"Invalid public key\");\n  }\n  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();\n}\n\nexport function getAuthenticatorForSimulation(publicKey: PublicKey) {\n  // TODO add support for AnyMultiKey\n  if (publicKey instanceof AnyPublicKey) {\n    if (publicKey.publicKey instanceof Ed25519PublicKey) {\n      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));\n    }\n    if (publicKey.publicKey instanceof Secp256k1PublicKey) {\n      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));\n    }\n  }\n\n  // legacy code\n  return new AccountAuthenticatorEd25519(\n    new Ed25519PublicKey(publicKey.toUint8Array()),\n    new Ed25519Signature(new Uint8Array(64)),\n  );\n}\n\n/**\n * Sign a transaction that can later be submitted to chain\n *\n * @param args.signer The signer account to sign the transaction\n * @param args.transaction A aptos transaction type to sign\n *\n * @return The signer AccountAuthenticator\n */\nexport function sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n  const { signer, transaction } = args;\n\n  // get the signing message\n  const message = generateSigningMessage(transaction);\n\n  // account.signMessage\n  const signerSignature = signer.sign(message);\n\n  // return account authentication\n  switch (signer.signingScheme) {\n    case SigningScheme.Ed25519:\n      return new AccountAuthenticatorEd25519(\n        new Ed25519PublicKey(signer.publicKey.toUint8Array()),\n        new Ed25519Signature(signerSignature.toUint8Array()),\n      );\n    case SigningScheme.SingleKey:\n      if (!AnyPublicKey.isPublicKey(signer.publicKey)) {\n        throw new Error(`Cannot sign transaction, public key does not match ${signer.signingScheme}`);\n      }\n      return new AccountAuthenticatorSingleKey(signer.publicKey, new AnySignature(signerSignature));\n    // TODO support MultiEd25519\n    default:\n      throw new Error(`Cannot sign transaction, signing scheme ${signer.signingScheme} not supported`);\n  }\n}\n\n/**\n * Prepare a transaction to be submitted to chain\n *\n * @param args.transaction A aptos transaction type\n * @param args.senderAuthenticator The account authenticator of the transaction sender\n * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction\n *\n * @returns A SignedTransaction\n */\nexport function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array {\n  const { transaction, senderAuthenticator, feePayerAuthenticator, additionalSignersAuthenticators } = args;\n\n  const transactionToSubmit = deriveTransactionType(transaction);\n\n  if (\n    (feePayerAuthenticator || additionalSignersAuthenticators) &&\n    (transactionToSubmit instanceof MultiAgentRawTransaction || transactionToSubmit instanceof FeePayerRawTransaction)\n  ) {\n    return generateMultiSignersSignedTransaction(\n      transactionToSubmit,\n      senderAuthenticator,\n      feePayerAuthenticator,\n      additionalSignersAuthenticators,\n    );\n  }\n\n  // submit single signer transaction\n\n  // check what instance is accountAuthenticator\n  if (senderAuthenticator instanceof AccountAuthenticatorEd25519 && transactionToSubmit instanceof RawTransaction) {\n    const transactionAuthenticator = new TransactionAuthenticatorEd25519(\n      senderAuthenticator.public_key,\n      senderAuthenticator.signature,\n    );\n    return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();\n  }\n\n  if (\n    (senderAuthenticator instanceof AccountAuthenticatorSingleKey ||\n      senderAuthenticator instanceof AccountAuthenticatorMultiKey) &&\n    transactionToSubmit instanceof RawTransaction\n  ) {\n    const transactionAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);\n    return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();\n  }\n\n  throw new Error(\n    `Cannot generate a signed transaction, ${senderAuthenticator} is not a supported account authentication scheme`,\n  );\n}\n\n/**\n * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction\n *\n * @param transaction A aptos transaction type\n *\n * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction\n */\nexport function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {\n  if (transaction.feePayerAddress) {\n    return new FeePayerRawTransaction(\n      transaction.rawTransaction,\n      transaction.secondarySignerAddresses ?? [],\n      transaction.feePayerAddress,\n    );\n  }\n  if (transaction.secondarySignerAddresses) {\n    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);\n  }\n\n  return transaction.rawTransaction;\n}\n\n/**\n * Generate a multi signers signed transaction that can be submitted to chain\n *\n * @param transaction MultiAgentRawTransaction | FeePayerRawTransaction\n * @param senderAuthenticator The account authenticator of the transaction sender\n * @param secondarySignerAuthenticators The extra signers account Authenticators\n *\n * @returns A SignedTransaction\n */\nexport function generateMultiSignersSignedTransaction(\n  transaction: MultiAgentRawTransaction | FeePayerRawTransaction,\n  senderAuthenticator: AccountAuthenticator,\n  feePayerAuthenticator?: AccountAuthenticator,\n  additionalSignersAuthenticators?: Array<AccountAuthenticator>,\n) {\n  if (transaction instanceof FeePayerRawTransaction) {\n    if (!feePayerAuthenticator) {\n      throw new Error(\"Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction\");\n    }\n    const txAuthenticatorFeePayer = new TransactionAuthenticatorFeePayer(\n      senderAuthenticator,\n      transaction.secondary_signer_addresses,\n      additionalSignersAuthenticators ?? [],\n      {\n        address: transaction.fee_payer_address,\n        authenticator: feePayerAuthenticator,\n      },\n    );\n    return new SignedTransaction(transaction.raw_txn, txAuthenticatorFeePayer).bcsToBytes();\n  }\n  if (transaction instanceof MultiAgentRawTransaction) {\n    if (!additionalSignersAuthenticators) {\n      throw new Error(\n        \"Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction\",\n      );\n    }\n    const multiAgentAuthenticator = new TransactionAuthenticatorMultiAgent(\n      senderAuthenticator,\n      transaction.secondary_signer_addresses,\n      additionalSignersAuthenticators ?? [],\n    );\n    return new SignedTransaction(transaction.raw_txn, multiAgentAuthenticator).bcsToBytes();\n  }\n\n  throw new Error(\n    `Cannot prepare multi signers transaction to submission, ${typeof transaction} transaction is not supported`,\n  );\n}\n\nexport function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array {\n  const rawTxn = deriveTransactionType(transaction);\n  const hash = sha3Hash.create();\n\n  if (rawTxn instanceof RawTransaction) {\n    hash.update(RAW_TRANSACTION_SALT);\n  } else if (rawTxn instanceof MultiAgentRawTransaction) {\n    hash.update(RAW_TRANSACTION_WITH_DATA_SALT);\n  } else if (rawTxn instanceof FeePayerRawTransaction) {\n    hash.update(RAW_TRANSACTION_WITH_DATA_SALT);\n  } else {\n    throw new Error(`Unknown transaction type to sign on: ${rawTxn}`);\n  }\n\n  const prefix = hash.digest();\n\n  const body = rawTxn.bcsToBytes();\n\n  const mergedArray = new Uint8Array(prefix.length + body.length);\n  mergedArray.set(prefix);\n  mergedArray.set(body, prefix.length);\n\n  return mergedArray;\n}\n"],"mappings":"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","names":["sha3Hash","generateTransactionPayload","args","isScriptDataInput","generateTransactionPayloadScript","moduleAddress","moduleName","functionName","getFunctionParts","functionAbi","memoizeAsync","fetchEntryFunctionAbi","generateTransactionPayloadWithABI","typeArguments","standardizeTypeTags","functionArguments","arg","i","convertArgument","entryFunctionPayload","EntryFunction","multisigAddress","AccountAddress","TransactionPayloadMultisig","MultiSig","MultisigTransactionPayload","TransactionPayloadEntryFunction","TransactionPayloadScript","Script","Hex","generateRawTransaction","aptosConfig","sender","payload","options","getSequenceNumber","getInfo","getChainId","NetworkToChainId","getLedgerInfo","getGasUnitPrice","getGasPriceEstimation","sequenceNumber","chainId","gasEstimate","maxGasAmount","gasUnitPrice","expireTimestamp","DEFAULT_MAX_GAS_AMOUNT","DEFAULT_TXN_EXP_SEC_FROM_NOW","RawTransaction","ChainId","buildTransaction","rawTxn","signers","signer","generateSignedTransactionForSimulation","signerPublicKey","transaction","secondarySignersPublicKeys","feePayerPublicKey","accountAuthenticator","getAuthenticatorForSimulation","transactionToSign","FeePayerRawTransaction","secondaryAccountAuthenticators","publicKey","feePayerAuthenticator","transactionAuthenticator","TransactionAuthenticatorFeePayer","SignedTransaction","MultiAgentRawTransaction","TransactionAuthenticatorMultiAgent","AccountAuthenticatorEd25519","TransactionAuthenticatorEd25519","AccountAuthenticatorSingleKey","TransactionAuthenticatorSingleSender","AnyPublicKey","Ed25519PublicKey","AnySignature","Ed25519Signature","Secp256k1PublicKey","Secp256k1Signature","sign","message","generateSigningMessage","signerSignature","generateSignedTransaction","senderAuthenticator","additionalSignersAuthenticators","transactionToSubmit","deriveTransactionType","generateMultiSignersSignedTransaction","AccountAuthenticatorMultiKey","txAuthenticatorFeePayer","multiAgentAuthenticator","hash","sha3Hash","RAW_TRANSACTION_SALT","RAW_TRANSACTION_WITH_DATA_SALT","prefix","body","mergedArray"]}

package/dist/esm/{chunk-IBH7IOIM.mjs → chunk-N25GOEVL.mjs}

@@ -1,2 +1,2 @@
-import{a as m}from"./chunk-44MGBJ73.mjs";import{a as d}from"./chunk-YYRDFZE6.mjs";import{a as y}from"./chunk-U25N2VWA.mjs";import{a as l}from"./chunk-RYETO74W.mjs";import{b as u}from"./chunk-NZIJV4O2.mjs";import{a as c}from"./chunk-HA6JD5R6.mjs";import{b as s}from"./chunk-TIH6ARYP.mjs";import{sha3_256 as b}from"@noble/hashes/sha3";var i=class i extends c{constructor(r){super();let{data:t}=r,e=s.fromHexInput(t);if(e.toUint8Array().length!==i.LENGTH)throw new Error(`Authentication Key length should be ${i.LENGTH}`);this.data=e}serialize(r){r.serializeFixedBytes(this.data.toUint8Array())}static deserialize(r){let t=r.deserializeFixedBytes(i.LENGTH);return new i({data:t})}toString(){return this.data.toString()}toUint8Array(){return this.data.toUint8Array()}static fromPublicKeyAndScheme(r){let{publicKey:t,scheme:e}=r,n;switch(e){case 3:case 2:{let a=t.bcsToBytes();n=new Uint8Array([...a,e]);break}case 0:case 1:{let a=t.toUint8Array(),p=s.fromHexInput(a).toUint8Array();n=new Uint8Array([...p,e]);break}default:throw new Error(`Scheme ${e} is not supported`)}let o=b.create();o.update(n);let f=o.digest();return new i({data:f})}static fromPublicKey(r){let{publicKey:t}=r,e;if(t instanceof l)e=0 .valueOf();else if(t instanceof y)e=1 .valueOf();else if(t instanceof d)e=2 .valueOf();else if(t instanceof m)e=3 .valueOf();else throw new Error("No supported authentication scheme for public key");return i.fromPublicKeyAndScheme({publicKey:t,scheme:e})}derivedAddress(){return new u(this.data.toUint8Array())}};i.LENGTH=32;var h=i;export{h as a};
-//# sourceMappingURL=chunk-IBH7IOIM.mjs.map
+import{a as y}from"./chunk-4K252UDE.mjs";import{a as m}from"./chunk-NMFS5KAE.mjs";import{a as d}from"./chunk-OWP2MKTX.mjs";import{a as l}from"./chunk-5HZKDT5C.mjs";import{b as u}from"./chunk-UR5E2UDO.mjs";import{a as c}from"./chunk-IU5JZNH4.mjs";import{b as s}from"./chunk-NL72WE3E.mjs";import{sha3_256 as b}from"@noble/hashes/sha3";var i=class i extends c{constructor(r){super();let{data:t}=r,e=s.fromHexInput(t);if(e.toUint8Array().length!==i.LENGTH)throw new Error(`Authentication Key length should be ${i.LENGTH}`);this.data=e}serialize(r){r.serializeFixedBytes(this.data.toUint8Array())}static deserialize(r){let t=r.deserializeFixedBytes(i.LENGTH);return new i({data:t})}toString(){return this.data.toString()}toUint8Array(){return this.data.toUint8Array()}static fromPublicKeyAndScheme(r){let{publicKey:t,scheme:e}=r,n;switch(e){case 3:case 2:{let a=t.bcsToBytes();n=new Uint8Array([...a,e]);break}case 0:case 1:{let a=t.toUint8Array(),p=s.fromHexInput(a).toUint8Array();n=new Uint8Array([...p,e]);break}default:throw new Error(`Scheme ${e} is not supported`)}let o=b.create();o.update(n);let f=o.digest();return new i({data:f})}static fromPublicKey(r){let{publicKey:t}=r,e;if(t instanceof l)e=0 .valueOf();else if(t instanceof y)e=1 .valueOf();else if(t instanceof d)e=2 .valueOf();else if(t instanceof m)e=3 .valueOf();else throw new Error("No supported authentication scheme for public key");return i.fromPublicKeyAndScheme({publicKey:t,scheme:e})}derivedAddress(){return new u(this.data.toUint8Array())}};i.LENGTH=32;var h=i;export{h as a};
+//# sourceMappingURL=chunk-N25GOEVL.mjs.map

package/dist/esm/chunk-NBSXZKMQ.mjs

@@ -0,0 +1,2 @@
+import{a as s}from"./chunk-DYJVDOBH.mjs";import{h as r,i as e,j as i}from"./chunk-7IY2Y73Q.mjs";var c=class{constructor(n){this.config=n}async batchTransactionsForSingleAccount(n){try{let{sender:t,data:o,options:p}=n,a=new s(this.config,t);a.start();for(let u of o)await a.push(u,p)}catch(t){throw new Error(`failed to submit transactions with error: ${t}`)}}async signAndSubmitTransaction(n){let{signer:t,transaction:o}=n;return r({aptosConfig:this.config,signer:t,transaction:o})}async publishPackageTransaction(n){return e({aptosConfig:this.config,...n})}async rotateAuthKey(n){return i({aptosConfig:this.config,...n})}};export{c as a};
+//# sourceMappingURL=chunk-NBSXZKMQ.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/transactionSubmission.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AptosConfig } from \"./aptosConfig\";\nimport { Account, AccountAddressInput, PrivateKey } from \"../core\";\nimport {\n  AnyRawTransaction,\n  SingleSignerTransaction,\n  InputGenerateTransactionOptions,\n  InputGenerateTransactionPayloadData,\n} from \"../transactions/types\";\nimport { PendingTransactionResponse, HexInput, TransactionResponse } from \"../types\";\nimport { publicPackageTransaction, rotateAuthKey, signAndSubmitTransaction } from \"../internal/transactionSubmission\";\nimport { TransactionWorker } from \"../transactions/management\";\n\nexport class TransactionSubmission {\n  readonly config: AptosConfig;\n\n  constructor(config: AptosConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Batch transactions for a single account.\n   *\n   * This function uses a transaction worker that receives payloads to be processed\n   * and submitted to chain.\n   * Note that this process is best for submitting multiple transactions that\n   * dont rely on each other, i.e batch funds, batch token mints, etc.\n   *\n   * If any worker failure, the functions throws an error.\n   *\n   * @param args.sender The sender account to sign and submit the transaction\n   * @param args.data An array of transaction payloads\n   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)\n   *\n   * @return void. Throws if any error\n   */\n  async batchTransactionsForSingleAccount(args: {\n    sender: Account;\n    data: InputGenerateTransactionPayloadData[];\n    options?: Omit<InputGenerateTransactionOptions, \"accountSequenceNumber\">;\n  }): Promise<void> {\n    try {\n      const { sender, data, options } = args;\n      const transactionWorker = new TransactionWorker(this.config, sender);\n\n      transactionWorker.start();\n\n      for (const d of data) {\n        /* eslint-disable no-await-in-loop */\n        await transactionWorker.push(d, options);\n      }\n    } catch (error: any) {\n      throw new Error(`failed to submit transactions with error: ${error}`);\n    }\n  }\n\n  /**\n   * Sign and submit a single signer transaction to chain\n   *\n   * @param args.signer The signer account to sign the transaction\n   * @param args.transaction 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   *\n   * @return PendingTransactionResponse\n   */\n  async signAndSubmitTransaction(args: {\n    signer: Account;\n    transaction: AnyRawTransaction;\n  }): Promise<PendingTransactionResponse> {\n    const { signer, transaction } = args;\n    return signAndSubmitTransaction({\n      aptosConfig: this.config,\n      signer,\n      transaction,\n    });\n  }\n\n  /**\n   * Generates a transaction to publish a move package to chain.\n   *\n   * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command\n   * `aptos move compile --save-metadata ...`,\n   * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}\n   *\n   * @param args.account The publisher account\n   * @param args.metadataBytes The package metadata bytes\n   * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order\n   *\n   * @returns A SingleSignerTransaction that can be simulated or submitted to chain\n   */\n  async publishPackageTransaction(args: {\n    account: AccountAddressInput;\n    metadataBytes: HexInput;\n    moduleBytecode: Array<HexInput>;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SingleSignerTransaction> {\n    return publicPackageTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for\n   * the account.\n   * Note: Only legacy Ed25519 scheme is supported for now.\n   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}\n   * @param args.fromAccount The account to rotate the auth key for\n   * @param args.toNewPrivateKey The new private key to rotate to\n   *\n   * @returns PendingTransactionResponse\n   */\n  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKey }): Promise<TransactionResponse> {\n    return rotateAuthKey({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"gGAeO,IAAMA,EAAN,KAA4B,CAGjC,YAAYC,EAAqB,CAC/B,KAAK,OAASA,CAChB,CAkBA,MAAM,kCAAkCC,EAItB,CAChB,GAAI,CACF,GAAM,CAAE,OAAAC,EAAQ,KAAAC,EAAM,QAAAC,CAAQ,EAAIH,EAC5BI,EAAoB,IAAIC,EAAkB,KAAK,OAAQJ,CAAM,EAEnEG,EAAkB,MAAM,EAExB,QAAWE,KAAKJ,EAEd,MAAME,EAAkB,KAAKE,EAAGH,CAAO,CAE3C,OAASI,EAAY,CACnB,MAAM,IAAI,MAAM,6CAA6CA,CAAK,EAAE,CACtE,CACF,CAiBA,MAAM,yBAAyBP,EAGS,CACtC,GAAM,CAAE,OAAAQ,EAAQ,YAAAC,CAAY,EAAIT,EAChC,OAAOU,EAAyB,CAC9B,YAAa,KAAK,OAClB,OAAAF,EACA,YAAAC,CACF,CAAC,CACH,CAeA,MAAM,0BAA0BT,EAKK,CACnC,OAAOW,EAAyB,CAAE,YAAa,KAAK,OAAQ,GAAGX,CAAK,CAAC,CACvE,CAYA,MAAM,cAAcA,EAA2F,CAC7G,OAAOY,EAAc,CAAE,YAAa,KAAK,OAAQ,GAAGZ,CAAK,CAAC,CAC5D,CACF","names":["TransactionSubmission","config","args","sender","data","options","transactionWorker","TransactionWorker","d","error","signer","transaction","signAndSubmitTransaction","publicPackageTransaction","rotateAuthKey"]}

package/dist/esm/chunk-NFGAZSSK.mjs

@@ -0,0 +1,2 @@
+import{b as n}from"./chunk-5X46HDCI.mjs";async function p(e){let{aptosConfig:t,overrides:s,params:r,contentType:o,acceptType:i,path:a,originMethod:u,type:R}=e,d=t.getRequestUrl(R);return n({url:d,method:"GET",originMethod:u,path:a,contentType:o?.valueOf(),acceptType:i?.valueOf(),params:r,overrides:{...t.clientConfig,...s}},t)}async function g(e){return p({...e,type:0})}async function f(e){let t=[],s,r=e.params;for(;;){r.start=s;let o=await p({type:0,aptosConfig:e.aptosConfig,originMethod:e.originMethod,path:e.path,params:r,overrides:e.overrides});if(s=o.headers["x-aptos-cursor"],delete o.headers,t.push(...o.data),s==null)break}return t}export{p as a,g as b,f as c};
+//# sourceMappingURL=chunk-NFGAZSSK.mjs.map

package/dist/esm/{chunk-ND3ZQKTT.mjs.map → chunk-NFGAZSSK.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/client/get.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { aptosRequest } from \"./core\";\nimport { AptosResponse } from \"./types\";\nimport { AnyNumber, ClientConfig, MimeType } from \"../types\";\nimport { AptosApiType } from \"../utils/const\";\n\nexport type GetRequestOptions = {\n  /**\n   * The config for the API client\n   */\n  aptosConfig: AptosConfig;\n  /**\n   * The type of API endpoint to call e.g. fullnode, indexer, etc\n   */\n  type: AptosApiType;\n  /**\n   * The name of the API method\n   */\n  originMethod: string;\n  /**\n   * The URL path to the API method\n   */\n  path: string;\n  /**\n   * The content type of the request body\n   */\n  contentType?: MimeType;\n  /**\n   * The accepted content type of the response of the API\n   */\n  acceptType?: MimeType;\n  /**\n   * The query parameters for the request\n   */\n  params?: Record<string, string | AnyNumber | boolean | undefined>;\n  /**\n   * Specific client overrides for this request to override aptosConfig\n   */\n  overrides?: ClientConfig;\n};\n\nexport type GetAptosRequestOptions = Omit<GetRequestOptions, \"type\">;\n\n/**\n * Main function to do a Get request\n *\n * @param options GetRequestOptions\n * @returns\n */\nexport async function get<Req extends {}, Res extends {}>(\n  options: GetRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosRequest<Req, Res>(\n    {\n      url,\n      method: \"GET\",\n      originMethod,\n      path,\n      contentType: contentType?.valueOf(),\n      acceptType: acceptType?.valueOf(),\n      params,\n      overrides: {\n        ...aptosConfig.clientConfig,\n        ...overrides,\n      },\n    },\n    aptosConfig,\n  );\n}\n\nexport async function getAptosFullNode<Req extends {}, Res extends {}>(\n  options: GetAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  return get<Req, Res>({ ...options, type: AptosApiType.FULLNODE });\n}\n\n/// This function is a helper for paginating using a function wrapping an API\nexport async function paginateWithCursor<Req extends Record<string, any>, Res extends any[]>(\n  options: GetAptosRequestOptions,\n): Promise<Res> {\n  const out = [];\n  let cursor: string | undefined;\n  const requestParams = options.params as Req & { start?: string; limit?: number };\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    requestParams.start = cursor;\n    // eslint-disable-next-line no-await-in-loop\n    const response = await getAptosFullNode<Req, Res>({\n      aptosConfig: options.aptosConfig,\n      originMethod: options.originMethod,\n      path: options.path,\n      params: requestParams,\n      overrides: options.overrides,\n    });\n    /**\n     * the cursor is a \"state key\" from the API perspective. Client\n     * should not need to \"care\" what it represents but just use it\n     * to query the next chunk of data.\n     */\n    cursor = response.headers[\"x-aptos-cursor\"];\n    // Now that we have the cursor (if any), we remove the headers before\n    // adding these to the output of this function.\n    delete (response as any).headers;\n    out.push(...response.data);\n    if (cursor === null || cursor === undefined) {\n      break;\n    }\n  }\n  return out as any;\n}\n"],"mappings":"yCAiDA,eAAsBA,EACpBC,EACkC,CAClC,GAAM,CAAE,YAAAC,EAAa,UAAAC,EAAW,OAAAC,EAAQ,YAAAC,EAAa,WAAAC,EAAY,KAAAC,EAAM,aAAAC,EAAc,KAAAC,CAAK,EAAIR,EACxFS,EAAMR,EAAY,cAAcO,CAAI,EAE1C,OAAOE,EACL,CACE,IAAAD,EACA,OAAQ,MACR,aAAAF,EACA,KAAAD,EACA,YAAaF,GAAa,QAAQ,EAClC,WAAYC,GAAY,QAAQ,EAChC,OAAAF,EACA,UAAW,CACT,GAAGF,EAAY,aACf,GAAGC,CACL,CACF,EACAD,CACF,CACF,CAEA,eAAsBU,EACpBX,EACkC,CAClC,OAAOD,EAAc,CAAE,GAAGC,EAAS,MAA4B,CAAC,CAClE,CAGA,eAAsBY,EACpBZ,EACc,CACd,IAAMa,EAAM,CAAC,EACTC,EACEC,EAAgBf,EAAQ,OAE9B,OAAa,CACXe,EAAc,MAAQD,EAEtB,IAAME,EAAW,MAAML,EAA2B,CAChD,YAAaX,EAAQ,YACrB,aAAcA,EAAQ,aACtB,KAAMA,EAAQ,KACd,OAAQe,EACR,UAAWf,EAAQ,SACrB,CAAC,EAWD,GALAc,EAASE,EAAS,QAAQ,gBAAgB,EAG1C,OAAQA,EAAiB,QACzBH,EAAI,KAAK,GAAGG,EAAS,IAAI,EACrBF,GAAW,KACb,KAEJ,CACA,OAAOD,CACT","names":["get","options","aptosConfig","overrides","params","contentType","acceptType","path","originMethod","type","url","aptosRequest","getAptosFullNode","paginateWithCursor","out","cursor","requestParams","response"]}
+{"version":3,"sources":["../../src/client/get.ts"],"sourcesContent":["import { AptosConfig } from \"../api/aptosConfig\";\nimport { aptosRequest } from \"./core\";\nimport { AptosResponse } from \"./types\";\nimport { AnyNumber, ClientConfig, MimeType } from \"../types\";\nimport { AptosApiType } from \"../utils/const\";\n\nexport type GetRequestOptions = {\n  /**\n   * The config for the API client\n   */\n  aptosConfig: AptosConfig;\n  /**\n   * The type of API endpoint to call e.g. fullnode, indexer, etc\n   */\n  type: AptosApiType;\n  /**\n   * The name of the API method\n   */\n  originMethod: string;\n  /**\n   * The URL path to the API method\n   */\n  path: string;\n  /**\n   * The content type of the request body\n   */\n  contentType?: MimeType;\n  /**\n   * The accepted content type of the response of the API\n   */\n  acceptType?: MimeType;\n  /**\n   * The query parameters for the request\n   */\n  params?: Record<string, string | AnyNumber | boolean | undefined>;\n  /**\n   * Specific client overrides for this request to override aptosConfig\n   */\n  overrides?: ClientConfig;\n};\n\nexport type GetAptosRequestOptions = Omit<GetRequestOptions, \"type\">;\n\n/**\n * Main function to do a Get request\n *\n * @param options GetRequestOptions\n * @returns\n */\nexport async function get<Req extends {}, Res extends {}>(\n  options: GetRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;\n  const url = aptosConfig.getRequestUrl(type);\n\n  return aptosRequest<Req, Res>(\n    {\n      url,\n      method: \"GET\",\n      originMethod,\n      path,\n      contentType: contentType?.valueOf(),\n      acceptType: acceptType?.valueOf(),\n      params,\n      overrides: {\n        ...aptosConfig.clientConfig,\n        ...overrides,\n      },\n    },\n    aptosConfig,\n  );\n}\n\nexport async function getAptosFullNode<Req extends {}, Res extends {}>(\n  options: GetAptosRequestOptions,\n): Promise<AptosResponse<Req, Res>> {\n  return get<Req, Res>({ ...options, type: AptosApiType.FULLNODE });\n}\n\n/// This function is a helper for paginating using a function wrapping an API\nexport async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(\n  options: GetAptosRequestOptions,\n): Promise<Res> {\n  const out: any[] = [];\n  let cursor: string | undefined;\n  const requestParams = options.params as { start?: string; limit?: number };\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    requestParams.start = cursor;\n    // eslint-disable-next-line no-await-in-loop\n    const response = await get<Req, Res>({\n      type: AptosApiType.FULLNODE,\n      aptosConfig: options.aptosConfig,\n      originMethod: options.originMethod,\n      path: options.path,\n      params: requestParams,\n      overrides: options.overrides,\n    });\n    /**\n     * the cursor is a \"state key\" from the API perspective. Client\n     * should not need to \"care\" what it represents but just use it\n     * to query the next chunk of data.\n     */\n    cursor = response.headers[\"x-aptos-cursor\"];\n    // Now that we have the cursor (if any), we remove the headers before\n    // adding these to the output of this function.\n    delete response.headers;\n    out.push(...response.data);\n    if (cursor === null || cursor === undefined) {\n      break;\n    }\n  }\n  return out as Res;\n}\n"],"mappings":"yCAiDA,eAAsBA,EACpBC,EACkC,CAClC,GAAM,CAAE,YAAAC,EAAa,UAAAC,EAAW,OAAAC,EAAQ,YAAAC,EAAa,WAAAC,EAAY,KAAAC,EAAM,aAAAC,EAAc,KAAAC,CAAK,EAAIR,EACxFS,EAAMR,EAAY,cAAcO,CAAI,EAE1C,OAAOE,EACL,CACE,IAAAD,EACA,OAAQ,MACR,aAAAF,EACA,KAAAD,EACA,YAAaF,GAAa,QAAQ,EAClC,WAAYC,GAAY,QAAQ,EAChC,OAAAF,EACA,UAAW,CACT,GAAGF,EAAY,aACf,GAAGC,CACL,CACF,EACAD,CACF,CACF,CAEA,eAAsBU,EACpBX,EACkC,CAClC,OAAOD,EAAc,CAAE,GAAGC,EAAS,MAA4B,CAAC,CAClE,CAGA,eAAsBY,EACpBZ,EACc,CACd,IAAMa,EAAa,CAAC,EAChBC,EACEC,EAAgBf,EAAQ,OAE9B,OAAa,CACXe,EAAc,MAAQD,EAEtB,IAAME,EAAW,MAAMjB,EAAc,CACnC,OACA,YAAaC,EAAQ,YACrB,aAAcA,EAAQ,aACtB,KAAMA,EAAQ,KACd,OAAQe,EACR,UAAWf,EAAQ,SACrB,CAAC,EAWD,GALAc,EAASE,EAAS,QAAQ,gBAAgB,EAG1C,OAAOA,EAAS,QAChBH,EAAI,KAAK,GAAGG,EAAS,IAAI,EACrBF,GAAW,KACb,KAEJ,CACA,OAAOD,CACT","names":["get","options","aptosConfig","overrides","params","contentType","acceptType","path","originMethod","type","url","aptosRequest","getAptosFullNode","paginateWithCursor","out","cursor","requestParams","response"]}

package/dist/esm/chunk-NL72WE3E.mjs

@@ -0,0 +1,2 @@
+import{a}from"./chunk-FBPNHF54.mjs";import{bytesToHex as s,hexToBytes as o}from"@noble/hashes/utils";var l=(e=>(e.TOO_SHORT="too_short",e.INVALID_LENGTH="invalid_length",e.INVALID_HEX_CHARS="invalid_hex_chars",e))(l||{}),i=class n{constructor(t){this.data=t}toUint8Array(){return this.data}toStringWithoutPrefix(){return s(this.data)}toString(){return`0x${this.toStringWithoutPrefix()}`}static fromString(t){let r=t;if(r.startsWith("0x")&&(r=r.slice(2)),r.length===0)throw new a("Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.","too_short");if(r.length%2!==0)throw new a("Hex string must be an even number of hex characters.","invalid_length");try{return new n(o(r))}catch(e){throw new a(`Hex string contains invalid hex characters: ${e?.message}`,"invalid_hex_chars")}}static fromHexInput(t){return t instanceof Uint8Array?new n(t):n.fromString(t)}static isValid(t){try{return n.fromString(t),{valid:!0}}catch(r){return{valid:!1,invalidReason:r?.invalidReason,invalidReasonMessage:r?.message}}}equals(t){return this.data.length!==t.data.length?!1:this.data.every((r,e)=>r===t.data[e])}};export{l as a,i as b};
+//# sourceMappingURL=chunk-NL72WE3E.mjs.map

package/dist/esm/{chunk-TIH6ARYP.mjs.map → chunk-NL72WE3E.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/hex.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { HexInput } from \"../types\";\n\n/**\n * This enum is used to explain why parsing might have failed.\n */\nexport enum HexInvalidReason {\n  TOO_SHORT = \"too_short\",\n  INVALID_LENGTH = \"invalid_length\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n}\n\n/**\n * NOTE: Do not use this class when working with account addresses, use AccountAddress.\n *\n * NOTE: When accepting hex data as input to a function, prefer to accept HexInput and\n * then use the static helper methods of this class to convert it into the desired\n * format. This enables the greatest flexibility for the developer.\n *\n * Hex is a helper class for working with hex data. Hex data, when represented as a\n * string, generally looks like this, for example: 0xaabbcc, 45cd32, etc.\n *\n * You might use this class like this:\n *\n * ```ts\n * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {\n *   const txnHashString = Hex.fromHexInput(txnHash).toString();\n *   return await getTransactionByHashInner(txnHashString);\n * }\n * ```\n *\n * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string\n * with a leading 0x prefix, regardless of what the input format was.\n *\n * These are some other ways to chain the functions together:\n * - `Hex.fromString({ hexInput: \"0x1f\" }).toUint8Array()`\n * - `new Hex([1, 3]).toStringWithoutPrefix()`\n */\nexport class Hex {\n  private readonly data: Uint8Array;\n\n  /**\n   * Create a new Hex instance from a Uint8Array.\n   *\n   * @param data Uint8Array\n   */\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  // ===\n  // Methods for representing an instance of Hex as other types.\n  // ===\n\n  /**\n   * Get the inner hex data. The inner data is already a Uint8Array so no conversion\n   * is taking place here, it just returns the inner data.\n   *\n   * @returns Hex data as Uint8Array\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Get the hex data as a string without the 0x prefix.\n   *\n   * @returns Hex string without 0x prefix\n   */\n  toStringWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the hex data as a string with the 0x prefix.\n   *\n   * @returns Hex string with 0x prefix\n   */\n  toString(): string {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  // ===\n  // Methods for creating an instance of Hex from other types.\n  // ===\n\n  /**\n   * Static method to convert a hex string to Hex\n   *\n   * @param str A hex string, with or without the 0x prefix\n   *\n   * @returns Hex\n   */\n  static fromString(str: string): Hex {\n    let input = str;\n\n    if (input.startsWith(\"0x\")) {\n      input = input.slice(2);\n    }\n\n    if (input.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.\",\n        HexInvalidReason.TOO_SHORT,\n      );\n    }\n\n    if (input.length % 2 !== 0) {\n      throw new ParsingError(\"Hex string must be an even number of hex characters.\", HexInvalidReason.INVALID_LENGTH);\n    }\n\n    try {\n      return new Hex(hexToBytes(input));\n    } catch (e) {\n      const error = e as Error;\n      throw new ParsingError(\n        `Hex string contains invalid hex characters: ${error.message}`,\n        HexInvalidReason.INVALID_HEX_CHARS,\n      );\n    }\n  }\n\n  /**\n   * Static method to convert an instance of HexInput to Hex\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   *\n   * @returns Hex\n   */\n  static fromHexInput(hexInput: HexInput): Hex {\n    if (hexInput instanceof Uint8Array) return new Hex(hexInput);\n    return Hex.fromString(hexInput);\n  }\n\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the string is valid hex.\n   *\n   * @param str A hex string representing byte data.\n   *\n   * @returns valid = true if the string is valid, false if not. If the string is not\n   * valid, invalidReason and invalidReasonMessage will be set explaining why it is\n   * invalid.\n   */\n  static isValid(str: string): ParsingResult<HexInvalidReason> {\n    try {\n      Hex.fromString(str);\n      return { valid: true };\n    } catch (e) {\n      const error = e as ParsingError<HexInvalidReason>;\n      return {\n        valid: false,\n        invalidReason: error.invalidReason,\n        invalidReasonMessage: error.message,\n      };\n    }\n  }\n\n  /**\n   * Return whether Hex instances are equal. Hex instances are considered equal if\n   * their underlying byte data is identical.\n   *\n   * @param other The Hex instance to compare to.\n   * @returns true if the Hex instances are equal, false if not.\n   */\n  equals(other: Hex): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n"],"mappings":"oCAGA,OAAS,cAAAA,EAAY,cAAAC,MAAkB,sBAOhC,IAAKC,OACVA,EAAA,UAAY,YACZA,EAAA,eAAiB,iBACjBA,EAAA,kBAAoB,oBAHVA,OAAA,IAgCCC,EAAN,MAAMC,CAAI,CAQf,YAAYC,EAAkB,CAC5B,KAAK,KAAOA,CACd,CAYA,cAA2B,CACzB,OAAO,KAAK,IACd,CAOA,uBAAgC,CAC9B,OAAOC,EAAW,KAAK,IAAI,CAC7B,CAOA,UAAmB,CACjB,MAAO,KAAK,KAAK,sBAAsB,CAAC,EAC1C,CAaA,OAAO,WAAWC,EAAkB,CAClC,IAAIC,EAAQD,EAMZ,GAJIC,EAAM,WAAW,IAAI,IACvBA,EAAQA,EAAM,MAAM,CAAC,GAGnBA,EAAM,SAAW,EACnB,MAAM,IAAIC,EACR,4FACA,WACF,EAGF,GAAID,EAAM,OAAS,IAAM,EACvB,MAAM,IAAIC,EAAa,uDAAwD,gBAA+B,EAGhH,GAAI,CACF,OAAO,IAAIL,EAAIM,EAAWF,CAAK,CAAC,CAClC,OAAS,EAAG,CACV,IAAMG,EAAQ,EACd,MAAM,IAAIF,EACR,+CAA+CE,EAAM,OAAO,GAC5D,mBACF,CACF,CACF,CASA,OAAO,aAAaC,EAAyB,CAC3C,OAAIA,aAAoB,WAAmB,IAAIR,EAAIQ,CAAQ,EACpDR,EAAI,WAAWQ,CAAQ,CAChC,CAeA,OAAO,QAAQL,EAA8C,CAC3D,GAAI,CACF,OAAAH,EAAI,WAAWG,CAAG,EACX,CAAE,MAAO,EAAK,CACvB,OAASM,EAAG,CACV,IAAMF,EAAQE,EACd,MAAO,CACL,MAAO,GACP,cAAeF,EAAM,cACrB,qBAAsBA,EAAM,OAC9B,CACF,CACF,CASA,OAAOG,EAAqB,CAC1B,OAAI,KAAK,KAAK,SAAWA,EAAM,KAAK,OAAe,GAC5C,KAAK,KAAK,MAAM,CAACC,EAAOC,IAAUD,IAAUD,EAAM,KAAKE,CAAK,CAAC,CACtE,CACF","names":["bytesToHex","hexToBytes","HexInvalidReason","Hex","_Hex","data","bytesToHex","str","input","ParsingError","hexToBytes","error","hexInput","e","other","value","index"]}
+{"version":3,"sources":["../../src/core/hex.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { bytesToHex, hexToBytes } from \"@noble/hashes/utils\";\nimport { ParsingError, ParsingResult } from \"./common\";\nimport { HexInput } from \"../types\";\n\n/**\n * This enum is used to explain why parsing might have failed.\n */\nexport enum HexInvalidReason {\n  TOO_SHORT = \"too_short\",\n  INVALID_LENGTH = \"invalid_length\",\n  INVALID_HEX_CHARS = \"invalid_hex_chars\",\n}\n\n/**\n * NOTE: Do not use this class when working with account addresses, use AccountAddress.\n *\n * NOTE: When accepting hex data as input to a function, prefer to accept HexInput and\n * then use the static helper methods of this class to convert it into the desired\n * format. This enables the greatest flexibility for the developer.\n *\n * Hex is a helper class for working with hex data. Hex data, when represented as a\n * string, generally looks like this, for example: 0xaabbcc, 45cd32, etc.\n *\n * You might use this class like this:\n *\n * ```ts\n * getTransactionByHash(txnHash: HexInput): Promise<Transaction> {\n *   const txnHashString = Hex.fromHexInput(txnHash).toString();\n *   return await getTransactionByHashInner(txnHashString);\n * }\n * ```\n *\n * This call to `Hex.fromHexInput().toString()` converts the HexInput to a hex string\n * with a leading 0x prefix, regardless of what the input format was.\n *\n * These are some other ways to chain the functions together:\n * - `Hex.fromString({ hexInput: \"0x1f\" }).toUint8Array()`\n * - `new Hex([1, 3]).toStringWithoutPrefix()`\n */\nexport class Hex {\n  private readonly data: Uint8Array;\n\n  /**\n   * Create a new Hex instance from a Uint8Array.\n   *\n   * @param data Uint8Array\n   */\n  constructor(data: Uint8Array) {\n    this.data = data;\n  }\n\n  // ===\n  // Methods for representing an instance of Hex as other types.\n  // ===\n\n  /**\n   * Get the inner hex data. The inner data is already a Uint8Array so no conversion\n   * is taking place here, it just returns the inner data.\n   *\n   * @returns Hex data as Uint8Array\n   */\n  toUint8Array(): Uint8Array {\n    return this.data;\n  }\n\n  /**\n   * Get the hex data as a string without the 0x prefix.\n   *\n   * @returns Hex string without 0x prefix\n   */\n  toStringWithoutPrefix(): string {\n    return bytesToHex(this.data);\n  }\n\n  /**\n   * Get the hex data as a string with the 0x prefix.\n   *\n   * @returns Hex string with 0x prefix\n   */\n  toString(): string {\n    return `0x${this.toStringWithoutPrefix()}`;\n  }\n\n  // ===\n  // Methods for creating an instance of Hex from other types.\n  // ===\n\n  /**\n   * Static method to convert a hex string to Hex\n   *\n   * @param str A hex string, with or without the 0x prefix\n   *\n   * @returns Hex\n   */\n  static fromString(str: string): Hex {\n    let input = str;\n\n    if (input.startsWith(\"0x\")) {\n      input = input.slice(2);\n    }\n\n    if (input.length === 0) {\n      throw new ParsingError(\n        \"Hex string is too short, must be at least 1 char long, excluding the optional leading 0x.\",\n        HexInvalidReason.TOO_SHORT,\n      );\n    }\n\n    if (input.length % 2 !== 0) {\n      throw new ParsingError(\"Hex string must be an even number of hex characters.\", HexInvalidReason.INVALID_LENGTH);\n    }\n\n    try {\n      return new Hex(hexToBytes(input));\n    } catch (error: any) {\n      throw new ParsingError(\n        `Hex string contains invalid hex characters: ${error?.message}`,\n        HexInvalidReason.INVALID_HEX_CHARS,\n      );\n    }\n  }\n\n  /**\n   * Static method to convert an instance of HexInput to Hex\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   *\n   * @returns Hex\n   */\n  static fromHexInput(hexInput: HexInput): Hex {\n    if (hexInput instanceof Uint8Array) return new Hex(hexInput);\n    return Hex.fromString(hexInput);\n  }\n\n  // ===\n  // Methods for checking validity.\n  // ===\n\n  /**\n   * Check if the string is valid hex.\n   *\n   * @param str A hex string representing byte data.\n   *\n   * @returns valid = true if the string is valid, false if not. If the string is not\n   * valid, invalidReason and invalidReasonMessage will be set explaining why it is\n   * invalid.\n   */\n  static isValid(str: string): ParsingResult<HexInvalidReason> {\n    try {\n      Hex.fromString(str);\n      return { valid: true };\n    } catch (error: any) {\n      return {\n        valid: false,\n        invalidReason: error?.invalidReason,\n        invalidReasonMessage: error?.message,\n      };\n    }\n  }\n\n  /**\n   * Return whether Hex instances are equal. Hex instances are considered equal if\n   * their underlying byte data is identical.\n   *\n   * @param other The Hex instance to compare to.\n   * @returns true if the Hex instances are equal, false if not.\n   */\n  equals(other: Hex): boolean {\n    if (this.data.length !== other.data.length) return false;\n    return this.data.every((value, index) => value === other.data[index]);\n  }\n}\n"],"mappings":"oCAGA,OAAS,cAAAA,EAAY,cAAAC,MAAkB,sBAOhC,IAAKC,OACVA,EAAA,UAAY,YACZA,EAAA,eAAiB,iBACjBA,EAAA,kBAAoB,oBAHVA,OAAA,IAgCCC,EAAN,MAAMC,CAAI,CAQf,YAAYC,EAAkB,CAC5B,KAAK,KAAOA,CACd,CAYA,cAA2B,CACzB,OAAO,KAAK,IACd,CAOA,uBAAgC,CAC9B,OAAOC,EAAW,KAAK,IAAI,CAC7B,CAOA,UAAmB,CACjB,MAAO,KAAK,KAAK,sBAAsB,CAAC,EAC1C,CAaA,OAAO,WAAWC,EAAkB,CAClC,IAAIC,EAAQD,EAMZ,GAJIC,EAAM,WAAW,IAAI,IACvBA,EAAQA,EAAM,MAAM,CAAC,GAGnBA,EAAM,SAAW,EACnB,MAAM,IAAIC,EACR,4FACA,WACF,EAGF,GAAID,EAAM,OAAS,IAAM,EACvB,MAAM,IAAIC,EAAa,uDAAwD,gBAA+B,EAGhH,GAAI,CACF,OAAO,IAAIL,EAAIM,EAAWF,CAAK,CAAC,CAClC,OAASG,EAAY,CACnB,MAAM,IAAIF,EACR,+CAA+CE,GAAO,OAAO,GAC7D,mBACF,CACF,CACF,CASA,OAAO,aAAaC,EAAyB,CAC3C,OAAIA,aAAoB,WAAmB,IAAIR,EAAIQ,CAAQ,EACpDR,EAAI,WAAWQ,CAAQ,CAChC,CAeA,OAAO,QAAQL,EAA8C,CAC3D,GAAI,CACF,OAAAH,EAAI,WAAWG,CAAG,EACX,CAAE,MAAO,EAAK,CACvB,OAASI,EAAY,CACnB,MAAO,CACL,MAAO,GACP,cAAeA,GAAO,cACtB,qBAAsBA,GAAO,OAC/B,CACF,CACF,CASA,OAAOE,EAAqB,CAC1B,OAAI,KAAK,KAAK,SAAWA,EAAM,KAAK,OAAe,GAC5C,KAAK,KAAK,MAAM,CAACC,EAAOC,IAAUD,IAAUD,EAAM,KAAKE,CAAK,CAAC,CACtE,CACF","names":["bytesToHex","hexToBytes","HexInvalidReason","Hex","_Hex","data","bytesToHex","str","input","ParsingError","hexToBytes","error","hexInput","other","value","index"]}

package/dist/esm/{chunk-EWTHPMEE.mjs → chunk-NLONZHYT.mjs}

@@ -1,2 +1,2 @@
-import{a as e}from"./chunk-HA6JD5R6.mjs";var r=class t extends e{constructor(i){super();this.identifier=i}serialize(i){i.serializeStr(this.identifier)}static deserialize(i){let s=i.deserializeStr();return new t(s)}};export{r as a};
-//# sourceMappingURL=chunk-EWTHPMEE.mjs.map
+import{a as e}from"./chunk-IU5JZNH4.mjs";var r=class t extends e{constructor(i){super();this.identifier=i}serialize(i){i.serializeStr(this.identifier)}static deserialize(i){let s=i.deserializeStr();return new t(s)}};export{r as a};
+//# sourceMappingURL=chunk-NLONZHYT.mjs.map

package/dist/esm/{chunk-44MGBJ73.mjs → chunk-NMFS5KAE.mjs}

@@ -1,2 +1,2 @@
-import{a as o}from"./chunk-YYRDFZE6.mjs";import{a as y}from"./chunk-EFIYW4WK.mjs";import{b as l}from"./chunk-TIH6ARYP.mjs";var p=class h extends y{constructor(e){super();let{publicKeys:t,signaturesRequired:r}=e;if(r<1)throw new Error("The number of required signatures needs to be greater then 0");if(t.length<r)throw new Error(`Provided ${t.length} public keys is smaller than the ${r} required signatures`);let i=[];t.forEach(s=>{s instanceof o?i.push(s):i.push(new o(s))}),this.publicKeys=i,this.signaturesRequired=r}toUint8Array(){return this.bcsToBytes()}createBitmap(e){let{bits:t}=e,r=128,i=new Uint8Array([0,0,0,0]),s=new Set;return t.forEach((n,u)=>{if(u+1>this.publicKeys.length)throw new Error(`Signature index ${u+1} is out of public keys range, ${this.publicKeys.length}.`);if(s.has(n))throw new Error(`Duplicate bit ${n} detected.`);s.add(n);let a=Math.floor(n/8),c=i[a];c|=r>>n%8,i[a]=c}),i}toString(){return l.fromHexInput(this.toUint8Array()).toString()}verifySignature(e){throw new Error("not implemented")}serialize(e){e.serializeVector(this.publicKeys),e.serializeU8(this.signaturesRequired)}static deserialize(e){let t=e.deserializeVector(o),r=e.deserializeU8();return new h({publicKeys:t,signaturesRequired:r})}};export{p as a};
-//# sourceMappingURL=chunk-44MGBJ73.mjs.map
+import{a as o}from"./chunk-OWP2MKTX.mjs";import{a as y}from"./chunk-EHJEK7FU.mjs";import{b as l}from"./chunk-NL72WE3E.mjs";var p=class h extends y{constructor(e){super();let{publicKeys:t,signaturesRequired:r}=e;if(r<1)throw new Error("The number of required signatures needs to be greater then 0");if(t.length<r)throw new Error(`Provided ${t.length} public keys is smaller than the ${r} required signatures`);let i=[];t.forEach(s=>{s instanceof o?i.push(s):i.push(new o(s))}),this.publicKeys=i,this.signaturesRequired=r}toUint8Array(){return this.bcsToBytes()}createBitmap(e){let{bits:t}=e,r=128,i=new Uint8Array([0,0,0,0]),s=new Set;return t.forEach((n,u)=>{if(u+1>this.publicKeys.length)throw new Error(`Signature index ${u+1} is out of public keys range, ${this.publicKeys.length}.`);if(s.has(n))throw new Error(`Duplicate bit ${n} detected.`);s.add(n);let a=Math.floor(n/8),c=i[a];c|=r>>n%8,i[a]=c}),i}toString(){return l.fromHexInput(this.toUint8Array()).toString()}verifySignature(e){throw new Error("not implemented")}serialize(e){e.serializeVector(this.publicKeys),e.serializeU8(this.signaturesRequired)}static deserialize(e){let t=e.deserializeVector(o),r=e.deserializeU8();return new h({publicKeys:t,signaturesRequired:r})}};export{p as a};
+//# sourceMappingURL=chunk-NMFS5KAE.mjs.map

package/dist/esm/{chunk-4KTQIWUP.mjs → chunk-NZ36UN4C.mjs}

@@ -1,2 +1,2 @@
-import{d as a}from"./chunk-O2B54NZT.mjs";import{a as r}from"./chunk-ZWH2ESXT.mjs";var n=class{constructor(t){this.config=t}async transaction(t){return a({aptosConfig:this.config,...t})}async multiAgentTransaction(t){return a({aptosConfig:this.config,...t})}};r([c],n.prototype,"transaction",1),r([c],n.prototype,"multiAgentTransaction",1);function c(s,t,o){let u=o.value;return o.value=async function(...e){let[i]=e;if(i.transaction.feePayerAddress&&!i.feePayerAuthenticator)throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");return u.apply(this,e)},o}export{n as a};
-//# sourceMappingURL=chunk-4KTQIWUP.mjs.map
+import{g as a}from"./chunk-7IY2Y73Q.mjs";import{a as r}from"./chunk-ZWH2ESXT.mjs";var n=class{constructor(t){this.config=t}async transaction(t){return a({aptosConfig:this.config,...t})}async multiAgentTransaction(t){return a({aptosConfig:this.config,...t})}};r([c],n.prototype,"transaction",1),r([c],n.prototype,"multiAgentTransaction",1);function c(s,t,o){let u=o.value;return o.value=async function(...e){let[i]=e;if(i.transaction.feePayerAddress&&!i.feePayerAuthenticator)throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");return u.apply(this,e)},o}export{n as a};
+//# sourceMappingURL=chunk-NZ36UN4C.mjs.map

package/dist/esm/{chunk-YYRDFZE6.mjs → chunk-OWP2MKTX.mjs}

@@ -1,2 +1,2 @@
-import{a as t}from"./chunk-62SCW5NH.mjs";import{a as r}from"./chunk-RYETO74W.mjs";import{a as s}from"./chunk-EFIYW4WK.mjs";var o=class n extends s{constructor(e){super();this.publicKey=e}toUint8Array(){return this.publicKey.toUint8Array()}toString(){return this.publicKey.toString()}verifySignature(e){let{message:i,signature:l}=e;return this.publicKey.verifySignature({message:i,signature:l})}serialize(e){if(this.publicKey instanceof r)e.serializeU32AsUleb128(0),this.publicKey.serialize(e);else if(this.publicKey instanceof t)e.serializeU32AsUleb128(1),this.publicKey.serialize(e);else throw new Error("Unknown public key type")}static deserialize(e){let i=e.deserializeUleb128AsU32();switch(i){case 0:return new n(r.load(e));case 1:return new n(t.load(e));default:throw new Error(`Unknown variant index for AnyPublicKey: ${i}`)}}};export{o as a};
-//# sourceMappingURL=chunk-YYRDFZE6.mjs.map
+import{a as t}from"./chunk-RCYWJZR4.mjs";import{a as r}from"./chunk-5HZKDT5C.mjs";import{a as s}from"./chunk-EHJEK7FU.mjs";var c=class n extends s{constructor(e){super();this.publicKey=e}toUint8Array(){return this.publicKey.toUint8Array()}toString(){return this.publicKey.toString()}verifySignature(e){let{message:i,signature:u}=e;return this.publicKey.verifySignature({message:i,signature:u})}serialize(e){if(this.publicKey instanceof r)e.serializeU32AsUleb128(0),this.publicKey.serialize(e);else if(this.publicKey instanceof t)e.serializeU32AsUleb128(1),this.publicKey.serialize(e);else throw new Error("Unknown public key type")}static deserialize(e){let i=e.deserializeUleb128AsU32();switch(i){case 0:return new n(r.load(e));case 1:return new n(t.load(e));default:throw new Error(`Unknown variant index for AnyPublicKey: ${i}`)}}static isPublicKey(e){return e instanceof n}isEd25519(){return this.publicKey instanceof r}isSecp256k1PublicKey(){return this.publicKey instanceof t}};export{c as a};
+//# sourceMappingURL=chunk-OWP2MKTX.mjs.map

package/dist/esm/{chunk-YYRDFZE6.mjs.map → chunk-OWP2MKTX.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/crypto/anyPublicKey.ts"],"sourcesContent":["import { Serializer, Deserializer } from \"../../bcs\";\nimport { AnyPublicKeyVariant, HexInput } from \"../../types\";\nimport { AnySignature } from \"./anySignature\";\nimport { PublicKey } from \"./asymmetricCrypto\";\nimport { Ed25519PublicKey } from \"./ed25519\";\nimport { Secp256k1PublicKey } from \"./secp256k1\";\n\n/**\n * Represents any public key supported by Aptos.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n *\n * Any unified authentication key is represented in the SDK as `AnyPublicKey`.\n */\nexport class AnyPublicKey extends PublicKey {\n  /**\n   * Reference to the inner public key\n   */\n  public readonly publicKey: PublicKey;\n\n  constructor(publicKey: PublicKey) {\n    super();\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.publicKey.toUint8Array();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return this.publicKey.toString();\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   */\n  verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {\n    const { message, signature } = args;\n    return this.publicKey.verifySignature({ message, signature });\n  }\n\n  serialize(serializer: Serializer): void {\n    if (this.publicKey instanceof Ed25519PublicKey) {\n      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Ed25519);\n      this.publicKey.serialize(serializer);\n    } else if (this.publicKey instanceof Secp256k1PublicKey) {\n      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Secp256k1);\n      this.publicKey.serialize(serializer);\n    } else {\n      throw new Error(\"Unknown public key type\");\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): AnyPublicKey {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case AnyPublicKeyVariant.Ed25519:\n        return new AnyPublicKey(Ed25519PublicKey.load(deserializer));\n      case AnyPublicKeyVariant.Secp256k1:\n        return new AnyPublicKey(Secp256k1PublicKey.load(deserializer));\n      default:\n        throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);\n    }\n  }\n}\n"],"mappings":"2HAeO,IAAMA,EAAN,MAAMC,UAAqBC,CAAU,CAM1C,YAAYC,EAAsB,CAChC,MAAM,EACN,KAAK,UAAYA,CACnB,CAOA,cAA2B,CACzB,OAAO,KAAK,UAAU,aAAa,CACrC,CAOA,UAAmB,CACjB,OAAO,KAAK,UAAU,SAAS,CACjC,CASA,gBAAgBC,EAA+D,CAC7E,GAAM,CAAE,QAAAC,EAAS,UAAAC,CAAU,EAAIF,EAC/B,OAAO,KAAK,UAAU,gBAAgB,CAAE,QAAAC,EAAS,UAAAC,CAAU,CAAC,CAC9D,CAEA,UAAUC,EAA8B,CACtC,GAAI,KAAK,qBAAqBC,EAC5BD,EAAW,uBAAiD,EAC5D,KAAK,UAAU,UAAUA,CAAU,UAC1B,KAAK,qBAAqBE,EACnCF,EAAW,uBAAmD,EAC9D,KAAK,UAAU,UAAUA,CAAU,MAEnC,OAAM,IAAI,MAAM,yBAAyB,CAE7C,CAEA,OAAO,YAAYG,EAA0C,CAC3D,IAAMC,EAAQD,EAAa,wBAAwB,EACnD,OAAQC,EAAO,CACb,OACE,OAAO,IAAIV,EAAaO,EAAiB,KAAKE,CAAY,CAAC,EAC7D,OACE,OAAO,IAAIT,EAAaQ,EAAmB,KAAKC,CAAY,CAAC,EAC/D,QACE,MAAM,IAAI,MAAM,2CAA2CC,CAAK,EAAE,CACtE,CACF,CACF","names":["AnyPublicKey","_AnyPublicKey","PublicKey","publicKey","args","message","signature","serializer","Ed25519PublicKey","Secp256k1PublicKey","deserializer","index"]}
+{"version":3,"sources":["../../src/core/crypto/anyPublicKey.ts"],"sourcesContent":["import { Serializer, Deserializer } from \"../../bcs\";\nimport { AnyPublicKeyVariant, HexInput } from \"../../types\";\nimport { AnySignature } from \"./anySignature\";\nimport { PublicKey } from \"./asymmetricCrypto\";\nimport { Ed25519PublicKey } from \"./ed25519\";\nimport { Secp256k1PublicKey } from \"./secp256k1\";\n\n/**\n * Represents any public key supported by Aptos.\n *\n * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports\n * `Legacy` and `Unified` authentication keys.\n *\n * Any unified authentication key is represented in the SDK as `AnyPublicKey`.\n */\nexport class AnyPublicKey extends PublicKey {\n  /**\n   * Reference to the inner public key\n   */\n  public readonly publicKey: PublicKey;\n\n  constructor(publicKey: PublicKey) {\n    super();\n    this.publicKey = publicKey;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.publicKey.toUint8Array();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return this.publicKey.toString();\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   */\n  verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {\n    const { message, signature } = args;\n    return this.publicKey.verifySignature({ message, signature });\n  }\n\n  serialize(serializer: Serializer): void {\n    if (this.publicKey instanceof Ed25519PublicKey) {\n      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Ed25519);\n      this.publicKey.serialize(serializer);\n    } else if (this.publicKey instanceof Secp256k1PublicKey) {\n      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Secp256k1);\n      this.publicKey.serialize(serializer);\n    } else {\n      throw new Error(\"Unknown public key type\");\n    }\n  }\n\n  static deserialize(deserializer: Deserializer): AnyPublicKey {\n    const index = deserializer.deserializeUleb128AsU32();\n    switch (index) {\n      case AnyPublicKeyVariant.Ed25519:\n        return new AnyPublicKey(Ed25519PublicKey.load(deserializer));\n      case AnyPublicKeyVariant.Secp256k1:\n        return new AnyPublicKey(Secp256k1PublicKey.load(deserializer));\n      default:\n        throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);\n    }\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is AnyPublicKey {\n    return publicKey instanceof AnyPublicKey;\n  }\n\n  isEd25519(): this is Ed25519PublicKey {\n    return this.publicKey instanceof Ed25519PublicKey;\n  }\n\n  isSecp256k1PublicKey(): this is Secp256k1PublicKey {\n    return this.publicKey instanceof Secp256k1PublicKey;\n  }\n}\n"],"mappings":"2HAeO,IAAMA,EAAN,MAAMC,UAAqBC,CAAU,CAM1C,YAAYC,EAAsB,CAChC,MAAM,EACN,KAAK,UAAYA,CACnB,CAOA,cAA2B,CACzB,OAAO,KAAK,UAAU,aAAa,CACrC,CAOA,UAAmB,CACjB,OAAO,KAAK,UAAU,SAAS,CACjC,CASA,gBAAgBC,EAA+D,CAC7E,GAAM,CAAE,QAAAC,EAAS,UAAAC,CAAU,EAAIF,EAC/B,OAAO,KAAK,UAAU,gBAAgB,CAAE,QAAAC,EAAS,UAAAC,CAAU,CAAC,CAC9D,CAEA,UAAUC,EAA8B,CACtC,GAAI,KAAK,qBAAqBC,EAC5BD,EAAW,uBAAiD,EAC5D,KAAK,UAAU,UAAUA,CAAU,UAC1B,KAAK,qBAAqBE,EACnCF,EAAW,uBAAmD,EAC9D,KAAK,UAAU,UAAUA,CAAU,MAEnC,OAAM,IAAI,MAAM,yBAAyB,CAE7C,CAEA,OAAO,YAAYG,EAA0C,CAC3D,IAAMC,EAAQD,EAAa,wBAAwB,EACnD,OAAQC,EAAO,CACb,OACE,OAAO,IAAIV,EAAaO,EAAiB,KAAKE,CAAY,CAAC,EAC7D,OACE,OAAO,IAAIT,EAAaQ,EAAmB,KAAKC,CAAY,CAAC,EAC/D,QACE,MAAM,IAAI,MAAM,2CAA2CC,CAAK,EAAE,CACtE,CACF,CAEA,OAAO,YAAYR,EAAiD,CAClE,OAAOA,aAAqBF,CAC9B,CAEA,WAAsC,CACpC,OAAO,KAAK,qBAAqBO,CACnC,CAEA,sBAAmD,CACjD,OAAO,KAAK,qBAAqBC,CACnC,CACF","names":["AnyPublicKey","_AnyPublicKey","PublicKey","publicKey","args","message","signature","serializer","Ed25519PublicKey","Secp256k1PublicKey","deserializer","index"]}

package/dist/esm/{chunk-WL4OXZLN.mjs → chunk-OXO3Z2MF.mjs}

@@ -1,2 +1,2 @@
-import{a as i}from"./chunk-HO7K2UAK.mjs";import{a as e}from"./chunk-JZNLZMUC.mjs";import{a as r}from"./chunk-HA6JD5R6.mjs";var n=class o extends r{constructor(t,a){super();this.raw_txn=t,this.authenticator=a}serialize(t){this.raw_txn.serialize(t),this.authenticator.serialize(t)}static deserialize(t){let a=e.deserialize(t),s=i.deserialize(t);return new o(a,s)}};export{n as a};
-//# sourceMappingURL=chunk-WL4OXZLN.mjs.map
+import{a as e}from"./chunk-3QS3MFWJ.mjs";import{a as i}from"./chunk-GQI3HWOB.mjs";import{a as r}from"./chunk-IU5JZNH4.mjs";var n=class o extends r{constructor(t,a){super();this.raw_txn=t,this.authenticator=a}serialize(t){this.raw_txn.serialize(t),this.authenticator.serialize(t)}static deserialize(t){let a=e.deserialize(t),s=i.deserialize(t);return new o(a,s)}};export{n as a};
+//# sourceMappingURL=chunk-OXO3Z2MF.mjs.map

package/dist/esm/{chunk-S36IYY6K.mjs → chunk-PANYJULW.mjs}

@@ -1,2 +1,2 @@
-import{a as g}from"./chunk-VWVEDCBM.mjs";import{a as p}from"./chunk-R3KWVOFG.mjs";import{a as y}from"./chunk-EWTHPMEE.mjs";import{a as S}from"./chunk-HVADSXTB.mjs";import{a as M}from"./chunk-4ADA5BE7.mjs";import{a as F,b as d,c as T,d as E,e as _,f as w,g as x}from"./chunk-X32O46IB.mjs";import{b as u}from"./chunk-NZIJV4O2.mjs";import{a as b}from"./chunk-HA6JD5R6.mjs";function D(r){let e=r.deserializeUleb128AsU32();switch(e){case 0:return d.deserialize(r);case 1:return _.deserialize(r);case 2:return w.deserialize(r);case 3:return u.deserialize(r);case 4:return M.deserialize(r,d);case 5:return F.deserialize(r);case 6:return T.deserialize(r);case 7:return E.deserialize(r);case 8:return x.deserialize(r);default:throw new Error(`Unknown variant index for ScriptTransactionArgument: ${e}`)}}var a=class extends b{static deserialize(e){let t=e.deserializeUleb128AsU32();switch(t){case 0:return m.load(e);case 2:return A.load(e);case 3:return z.load(e);default:throw new Error(`Unknown variant index for TransactionPayload: ${t}`)}}},m=class r extends a{constructor(t){super();this.script=t}serialize(t){t.serializeU32AsUleb128(0),this.script.serialize(t)}static load(t){let i=h.deserialize(t);return new r(i)}},A=class r extends a{constructor(t){super();this.entryFunction=t}serialize(t){t.serializeU32AsUleb128(2),this.entryFunction.serialize(t)}static load(t){let i=l.deserialize(t);return new r(i)}},z=class r extends a{constructor(t){super();this.multiSig=t}serialize(t){t.serializeU32AsUleb128(3),this.multiSig.serialize(t)}static load(t){let i=U.deserialize(t);return new r(i)}},l=class r{constructor(e,t,i,n){this.module_name=e,this.function_name=t,this.type_args=i,this.args=n}static build(e,t,i,n){return new r(p.fromStr(e),new y(t),i,n)}serialize(e){this.module_name.serialize(e),this.function_name.serialize(e),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForEntryFunction(e)})}static deserialize(e){let t=p.deserialize(e),i=y.deserialize(e),n=e.deserializeVector(g),o=e.deserializeUleb128AsU32(),s=new Array;for(let c=0;c<o;c+=1){let v=e.deserializeUleb128AsU32(),B=S.deserialize(e,v);s.push(B)}return new r(t,i,n,s)}},h=class r{constructor(e,t,i){this.bytecode=e,this.type_args=t,this.args=i}serialize(e){e.serializeBytes(this.bytecode),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForScriptFunction(e)})}static deserialize(e){let t=e.deserializeBytes(),i=e.deserializeVector(g),n=e.deserializeUleb128AsU32(),o=new Array;for(let s=0;s<n;s+=1){let c=D(e);o.push(c)}return new r(t,i,o)}},U=class r{constructor(e,t){this.multisig_address=e,this.transaction_payload=t}serialize(e){this.multisig_address.serialize(e),this.transaction_payload===void 0?e.serializeBool(!1):(e.serializeBool(!0),this.transaction_payload.serialize(e))}static deserialize(e){let t=u.deserialize(e),i=e.deserializeBool(),n;return i&&(n=f.deserialize(e)),new r(t,n)}},f=class r{constructor(e){this.transaction_payload=e}serialize(e){e.serializeU32AsUleb128(0),this.transaction_payload.serialize(e)}static deserialize(e){return e.deserializeUleb128AsU32(),new r(l.deserialize(e))}};export{D as a,a as b,m as c,A as d,z as e,l as f,h as g,U as h,f as i};
-//# sourceMappingURL=chunk-S36IYY6K.mjs.map
+import{a as g}from"./chunk-C3Y52GHM.mjs";import{a as p}from"./chunk-PRKZ2KJ4.mjs";import{a as y}from"./chunk-NLONZHYT.mjs";import{b as u}from"./chunk-UR5E2UDO.mjs";import{a as S}from"./chunk-6DYNAFAP.mjs";import{a as M}from"./chunk-7B3VSBCX.mjs";import{a as F,b as d,c as T,d as E,e as _,f as w,g as x}from"./chunk-VMCFN5CT.mjs";import{a as b}from"./chunk-IU5JZNH4.mjs";function D(r){let e=r.deserializeUleb128AsU32();switch(e){case 0:return d.deserialize(r);case 1:return _.deserialize(r);case 2:return w.deserialize(r);case 3:return u.deserialize(r);case 4:return M.deserialize(r,d);case 5:return F.deserialize(r);case 6:return T.deserialize(r);case 7:return E.deserialize(r);case 8:return x.deserialize(r);default:throw new Error(`Unknown variant index for ScriptTransactionArgument: ${e}`)}}var a=class extends b{static deserialize(e){let t=e.deserializeUleb128AsU32();switch(t){case 0:return m.load(e);case 2:return A.load(e);case 3:return z.load(e);default:throw new Error(`Unknown variant index for TransactionPayload: ${t}`)}}},m=class r extends a{constructor(t){super();this.script=t}serialize(t){t.serializeU32AsUleb128(0),this.script.serialize(t)}static load(t){let i=h.deserialize(t);return new r(i)}},A=class r extends a{constructor(t){super();this.entryFunction=t}serialize(t){t.serializeU32AsUleb128(2),this.entryFunction.serialize(t)}static load(t){let i=l.deserialize(t);return new r(i)}},z=class r extends a{constructor(t){super();this.multiSig=t}serialize(t){t.serializeU32AsUleb128(3),this.multiSig.serialize(t)}static load(t){let i=U.deserialize(t);return new r(i)}},l=class r{constructor(e,t,i,n){this.module_name=e,this.function_name=t,this.type_args=i,this.args=n}static build(e,t,i,n){return new r(p.fromStr(e),new y(t),i,n)}serialize(e){this.module_name.serialize(e),this.function_name.serialize(e),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForEntryFunction(e)})}static deserialize(e){let t=p.deserialize(e),i=y.deserialize(e),n=e.deserializeVector(g),o=e.deserializeUleb128AsU32(),s=new Array;for(let c=0;c<o;c+=1){let v=e.deserializeUleb128AsU32(),B=S.deserialize(e,v);s.push(B)}return new r(t,i,n,s)}},h=class r{constructor(e,t,i){this.bytecode=e,this.type_args=t,this.args=i}serialize(e){e.serializeBytes(this.bytecode),e.serializeVector(this.type_args),e.serializeU32AsUleb128(this.args.length),this.args.forEach(t=>{t.serializeForScriptFunction(e)})}static deserialize(e){let t=e.deserializeBytes(),i=e.deserializeVector(g),n=e.deserializeUleb128AsU32(),o=new Array;for(let s=0;s<n;s+=1){let c=D(e);o.push(c)}return new r(t,i,o)}},U=class r{constructor(e,t){this.multisig_address=e,this.transaction_payload=t}serialize(e){this.multisig_address.serialize(e),this.transaction_payload===void 0?e.serializeBool(!1):(e.serializeBool(!0),this.transaction_payload.serialize(e))}static deserialize(e){let t=u.deserialize(e),i=e.deserializeBool(),n;return i&&(n=f.deserialize(e)),new r(t,n)}},f=class r{constructor(e){this.transaction_payload=e}serialize(e){e.serializeU32AsUleb128(0),this.transaction_payload.serialize(e)}static deserialize(e){return e.deserializeUleb128AsU32(),new r(l.deserialize(e))}};export{D as a,a as b,m as c,A as d,z as e,l as f,h as g,U as h,f as i};
+//# sourceMappingURL=chunk-PANYJULW.mjs.map

package/dist/esm/{chunk-DRPMIJH7.mjs → chunk-PEBXSNMJ.mjs}

@@ -1,2 +1,2 @@
-import{c as o}from"./chunk-O2B54NZT.mjs";import{a as i}from"./chunk-ZWH2ESXT.mjs";var r=class{constructor(n){this.config=n}async transaction(n){return o({aptosConfig:this.config,...n})}async multiAgentTransaction(n){return o({aptosConfig:this.config,...n})}};i([s],r.prototype,"transaction",1),i([s],r.prototype,"multiAgentTransaction",1);function s(c,n,e){let y=e.value;return e.value=async function(...t){let[a]=t;if(a.transaction.feePayerAddress&&!a.feePayerPublicKey)throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");return y.apply(this,t)},e}export{r as a};
-//# sourceMappingURL=chunk-DRPMIJH7.mjs.map
+import{f as o}from"./chunk-7IY2Y73Q.mjs";import{a as i}from"./chunk-ZWH2ESXT.mjs";var r=class{constructor(n){this.config=n}async transaction(n){return o({aptosConfig:this.config,...n})}async multiAgentTransaction(n){return o({aptosConfig:this.config,...n})}};i([s],r.prototype,"transaction",1),i([s],r.prototype,"multiAgentTransaction",1);function s(c,n,e){let y=e.value;return e.value=async function(...t){let[a]=t;if(a.transaction.feePayerAddress&&!a.feePayerPublicKey)throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");return y.apply(this,t)},e}export{r as a};
+//# sourceMappingURL=chunk-PEBXSNMJ.mjs.map

package/dist/esm/chunk-PLY7MQKE.mjs

@@ -0,0 +1,2 @@
+import{a as i,b as n,c as t,d as o}from"./chunk-XKINEFAA.mjs";import{a as s}from"./chunk-LBNMY7EM.mjs";var r=class{constructor(e){this.config=e}async getFungibleAssetMetadata(e){return await s({config:this.config,minimumLedgerVersion:e?.minimumLedgerVersion,processorTypes:["fungible_asset_processor"]}),i({aptosConfig:this.config,...e})}async getFungibleAssetMetadataByAssetType(e){return await s({config:this.config,minimumLedgerVersion:e?.minimumLedgerVersion,processorTypes:["fungible_asset_processor"]}),(await i({aptosConfig:this.config,options:{where:{asset_type:{_eq:e.assetType}}}}))[0]}async getFungibleAssetActivities(e){return await s({config:this.config,minimumLedgerVersion:e?.minimumLedgerVersion,processorTypes:["fungible_asset_processor"]}),n({aptosConfig:this.config,...e})}async getCurrentFungibleAssetBalances(e){return await s({config:this.config,minimumLedgerVersion:e?.minimumLedgerVersion,processorTypes:["fungible_asset_processor"]}),t({aptosConfig:this.config,...e})}async transferFungibleAsset(e){return o({aptosConfig:this.config,...e})}};export{r as a};
+//# sourceMappingURL=chunk-PLY7MQKE.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/fungibleAsset.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  AnyNumber,\n  GetCurrentFungibleAssetBalancesResponse,\n  GetFungibleAssetActivitiesResponse,\n  GetFungibleAssetMetadataResponse,\n  PaginationArgs,\n  WhereArg,\n} from \"../types\";\nimport {\n  getCurrentFungibleAssetBalances,\n  getFungibleAssetActivities,\n  getFungibleAssetMetadata,\n  transferFungibleAsset,\n} from \"../internal/fungibleAsset\";\nimport {\n  CurrentFungibleAssetBalancesBoolExp,\n  FungibleAssetActivitiesBoolExp,\n  FungibleAssetMetadataBoolExp,\n} from \"../types/generated/types\";\nimport { ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { Account, AccountAddress } from \"../core\";\nimport { InputGenerateTransactionOptions, SingleSignerTransaction } from \"../transactions\";\n\n/**\n * A class to query all `FungibleAsset` related queries on Aptos.\n */\nexport class FungibleAsset {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Queries all fungible asset metadata.\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getFungibleAssetMetadata(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<FungibleAssetMetadataBoolExp>;\n  }): Promise<GetFungibleAssetMetadataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],\n    });\n    return getFungibleAssetMetadata({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a fungible asset metadata\n   *\n   * This query returns the fungible asset metadata for a specific fungible asset.\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.assetType The asset type of the fungible asset.\n   * e.g\n   * \"0x1::aptos_coin::AptosCoin\" for Aptos Coin\n   * \"0xc2948283c2ce03aafbb294821de7ee684b06116bb378ab614fa2de07a99355a8\" - address format if this is fungible asset\n   *\n   * @returns A fungible asset metadata item\n   */\n  async getFungibleAssetMetadataByAssetType(args: {\n    assetType: string;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<GetFungibleAssetMetadataResponse[0]> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],\n    });\n    const data = await getFungibleAssetMetadata({\n      aptosConfig: this.config,\n      options: {\n        where: {\n          asset_type: { _eq: args.assetType },\n        },\n      },\n    });\n\n    return data[0];\n  }\n\n  /**\n   * Queries all fungible asset activities\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getFungibleAssetActivities(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<FungibleAssetActivitiesBoolExp>;\n  }): Promise<GetFungibleAssetActivitiesResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],\n    });\n    return getFungibleAssetActivities({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries all fungible asset balances\n   *\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   *\n   * @returns A list of fungible asset metadata\n   */\n  async getCurrentFungibleAssetBalances(args?: {\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n  }): Promise<GetCurrentFungibleAssetBalancesResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args?.minimumLedgerVersion,\n      processorTypes: [ProcessorType.FUNGIBLE_ASSET_PROCESSOR],\n    });\n    return getCurrentFungibleAssetBalances({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   *  Transfer `amount` of fungible asset from sender's primary store to recipient's primary store.\n   *\n   * Use this method to transfer any fungible asset including fungible token.\n   *\n   * @param sender The sender account\n   * @param fungibleAssetMetadataAddress The fungible asset account address.\n   * For example if you’re transferring USDT this would be the USDT address\n   * @param recipient The recipient account address\n   * @param amount Number of assets to transfer\n   *\n   * @returns A SingleSignerTransaction that can be simulated or submitted to chain.\n   */\n  async transferFungibleAsset(args: {\n    sender: Account;\n    fungibleAssetMetadataAddress: AccountAddress;\n    recipient: AccountAddress;\n    amount: AnyNumber;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SingleSignerTransaction> {\n    return transferFungibleAsset({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"uGA+BO,IAAMA,EAAN,KAAoB,CACzB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CAS3C,MAAM,yBAAyBC,EAGe,CAC5C,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,GAAM,qBAC5B,eAAgB,2BAAuC,CACzD,CAAC,EACME,EAAyB,CAAE,YAAa,KAAK,OAAQ,GAAGF,CAAK,CAAC,CACvE,CAeA,MAAM,oCAAoCA,EAGO,CAC/C,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,GAAM,qBAC5B,eAAgB,2BAAuC,CACzD,CAAC,GACY,MAAME,EAAyB,CAC1C,YAAa,KAAK,OAClB,QAAS,CACP,MAAO,CACL,WAAY,CAAE,IAAKF,EAAK,SAAU,CACpC,CACF,CACF,CAAC,GAEW,CAAC,CACf,CASA,MAAM,2BAA2BA,EAGe,CAC9C,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,GAAM,qBAC5B,eAAgB,2BAAuC,CACzD,CAAC,EACMG,EAA2B,CAAE,YAAa,KAAK,OAAQ,GAAGH,CAAK,CAAC,CACzE,CASA,MAAM,gCAAgCA,EAGe,CACnD,aAAMC,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBD,GAAM,qBAC5B,eAAgB,2BAAuC,CACzD,CAAC,EACMI,EAAgC,CAAE,YAAa,KAAK,OAAQ,GAAGJ,CAAK,CAAC,CAC9E,CAeA,MAAM,sBAAsBA,EAMS,CACnC,OAAOK,EAAsB,CAAE,YAAa,KAAK,OAAQ,GAAGL,CAAK,CAAC,CACpE,CACF","names":["FungibleAsset","config","args","waitForIndexerOnVersion","getFungibleAssetMetadata","getFungibleAssetActivities","getCurrentFungibleAssetBalances","transferFungibleAsset"]}

package/dist/esm/chunk-PRKZ2KJ4.mjs

@@ -0,0 +1,2 @@
+import{a as s}from"./chunk-NLONZHYT.mjs";import{b as i}from"./chunk-UR5E2UDO.mjs";import{a as d}from"./chunk-IU5JZNH4.mjs";var o=class t extends d{constructor(e,r){super();this.address=e,this.name=r}static fromStr(e){let r=e.split("::");if(r.length!==2)throw new Error("Invalid module id.");return new t(i.fromString(r[0]),new s(r[1]))}serialize(e){this.address.serialize(e),this.name.serialize(e)}static deserialize(e){let r=i.deserialize(e),n=s.deserialize(e);return new t(r,n)}};export{o as a};
+//# sourceMappingURL=chunk-PRKZ2KJ4.mjs.map

package/dist/esm/{chunk-R3KWVOFG.mjs.map → chunk-PRKZ2KJ4.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transactions/instances/moduleId.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"./identifier\";\nimport { MoveModuleId } from \"../../types\";\n\n/**\n * Representation of a ModuleId that can serialized and deserialized\n * ModuleId means the module address (e.g \"0x1\") and the module name (e.g \"coin\")\n */\nexport class ModuleId extends Serializable {\n  public readonly address: AccountAddress;\n\n  public readonly name: Identifier;\n\n  /**\n   * Full name of a module.\n   * @param address The account address. e.g \"0x1\"\n   * @param name The module name under the \"address\". e.g \"coin\"\n   */\n  constructor(address: AccountAddress, name: Identifier) {\n    super();\n    this.address = address;\n    this.name = name;\n  }\n\n  /**\n   * Converts a string literal to a ModuleId\n   * @param moduleId String literal in format \"account_address::module_name\", e.g. \"0x1::coin\"\n   * @returns ModuleId\n   */\n  static fromStr(moduleId: MoveModuleId): ModuleId {\n    const parts = moduleId.split(\"::\");\n    if (parts.length !== 2) {\n      throw new Error(\"Invalid module id.\");\n    }\n    return new ModuleId(AccountAddress.fromStringRelaxed(parts[0]), new Identifier(parts[1]));\n  }\n\n  serialize(serializer: Serializer): void {\n    this.address.serialize(serializer);\n    this.name.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): ModuleId {\n    const address = AccountAddress.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    return new ModuleId(address, name);\n  }\n}\n"],"mappings":"2HAaO,IAAMA,EAAN,MAAMC,UAAiBC,CAAa,CAUzC,YAAYC,EAAyBC,EAAkB,CACrD,MAAM,EACN,KAAK,QAAUD,EACf,KAAK,KAAOC,CACd,CAOA,OAAO,QAAQC,EAAkC,CAC/C,IAAMC,EAAQD,EAAS,MAAM,IAAI,EACjC,GAAIC,EAAM,SAAW,EACnB,MAAM,IAAI,MAAM,oBAAoB,EAEtC,OAAO,IAAIL,EAASM,EAAe,kBAAkBD,EAAM,CAAC,CAAC,EAAG,IAAIE,EAAWF,EAAM,CAAC,CAAC,CAAC,CAC1F,CAEA,UAAUG,EAA8B,CACtC,KAAK,QAAQ,UAAUA,CAAU,EACjC,KAAK,KAAK,UAAUA,CAAU,CAChC,CAEA,OAAO,YAAYC,EAAsC,CACvD,IAAMP,EAAUI,EAAe,YAAYG,CAAY,EACjDN,EAAOI,EAAW,YAAYE,CAAY,EAChD,OAAO,IAAIT,EAASE,EAASC,CAAI,CACnC,CACF","names":["ModuleId","_ModuleId","Serializable","address","name","moduleId","parts","AccountAddress","Identifier","serializer","deserializer"]}
+{"version":3,"sources":["../../src/transactions/instances/moduleId.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Serializable, Serializer } from \"../../bcs/serializer\";\nimport { Deserializer } from \"../../bcs/deserializer\";\nimport { AccountAddress } from \"../../core\";\nimport { Identifier } from \"./identifier\";\nimport { MoveModuleId } from \"../../types\";\n\n/**\n * Representation of a ModuleId that can serialized and deserialized\n * ModuleId means the module address (e.g \"0x1\") and the module name (e.g \"coin\")\n */\nexport class ModuleId extends Serializable {\n  public readonly address: AccountAddress;\n\n  public readonly name: Identifier;\n\n  /**\n   * Full name of a module.\n   * @param address The account address. e.g \"0x1\"\n   * @param name The module name under the \"address\". e.g \"coin\"\n   */\n  constructor(address: AccountAddress, name: Identifier) {\n    super();\n    this.address = address;\n    this.name = name;\n  }\n\n  /**\n   * Converts a string literal to a ModuleId\n   * @param moduleId String literal in format \"account_address::module_name\", e.g. \"0x1::coin\"\n   * @returns ModuleId\n   */\n  static fromStr(moduleId: MoveModuleId): ModuleId {\n    const parts = moduleId.split(\"::\");\n    if (parts.length !== 2) {\n      throw new Error(\"Invalid module id.\");\n    }\n    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));\n  }\n\n  serialize(serializer: Serializer): void {\n    this.address.serialize(serializer);\n    this.name.serialize(serializer);\n  }\n\n  static deserialize(deserializer: Deserializer): ModuleId {\n    const address = AccountAddress.deserialize(deserializer);\n    const name = Identifier.deserialize(deserializer);\n    return new ModuleId(address, name);\n  }\n}\n"],"mappings":"2HAaO,IAAMA,EAAN,MAAMC,UAAiBC,CAAa,CAUzC,YAAYC,EAAyBC,EAAkB,CACrD,MAAM,EACN,KAAK,QAAUD,EACf,KAAK,KAAOC,CACd,CAOA,OAAO,QAAQC,EAAkC,CAC/C,IAAMC,EAAQD,EAAS,MAAM,IAAI,EACjC,GAAIC,EAAM,SAAW,EACnB,MAAM,IAAI,MAAM,oBAAoB,EAEtC,OAAO,IAAIL,EAASM,EAAe,WAAWD,EAAM,CAAC,CAAC,EAAG,IAAIE,EAAWF,EAAM,CAAC,CAAC,CAAC,CACnF,CAEA,UAAUG,EAA8B,CACtC,KAAK,QAAQ,UAAUA,CAAU,EACjC,KAAK,KAAK,UAAUA,CAAU,CAChC,CAEA,OAAO,YAAYC,EAAsC,CACvD,IAAMP,EAAUI,EAAe,YAAYG,CAAY,EACjDN,EAAOI,EAAW,YAAYE,CAAY,EAChD,OAAO,IAAIT,EAASE,EAASC,CAAI,CACnC,CACF","names":["ModuleId","_ModuleId","Serializable","address","name","moduleId","parts","AccountAddress","Identifier","serializer","deserializer"]}

package/dist/esm/{chunk-GAI75GOG.mjs → chunk-PZ5JKQSP.mjs}

@@ -1,2 +1,2 @@
-import{a as u}from"./chunk-IBH7IOIM.mjs";import{a as n}from"./chunk-YYRDFZE6.mjs";import{a as d,b as y}from"./chunk-62SCW5NH.mjs";import{a as K}from"./chunk-U25N2VWA.mjs";import{a as p,b as o}from"./chunk-RYETO74W.mjs";import{b as l}from"./chunk-TIH6ARYP.mjs";var g=class a{constructor(t){let{privateKey:e,address:i,legacy:r}=t,c=r??!0;if(this.publicKey=e.publicKey(),this.publicKey instanceof p)c?this.signingScheme=0:(this.publicKey=new n(this.publicKey),this.signingScheme=2);else if(this.publicKey instanceof K)this.signingScheme=1;else if(this.publicKey instanceof d)this.publicKey=new n(this.publicKey),this.signingScheme=2;else throw new Error("Can not create new Account, unsupported public key type");this.privateKey=e,this.accountAddress=i}static generate(t){let e=t?.legacy??!0,i,r;switch(t?.scheme){case 2:i=y.generate(),r=new n(i.publicKey());break;default:i=o.generate(),e===!1?r=new n(i.publicKey()):r=i.publicKey()}let s=u.fromPublicKey({publicKey:r}).derivedAddress();return new a({privateKey:i,address:s,legacy:t?.legacy})}static fromPrivateKey(t){let{privateKey:e,legacy:i}=t,r=i??!0,c;if(e instanceof y)c=new n(e.publicKey());else if(e instanceof o)r?c=e.publicKey():c=new n(e.publicKey());else throw new Error(`Unsupported private key ${e}`);let m=u.fromPublicKey({publicKey:c}).derivedAddress();return new a({privateKey:e,address:m,legacy:r})}static fromPrivateKeyAndAddress(t){let{privateKey:e,address:i,legacy:r}=t;return new a({privateKey:e,address:i,legacy:r})}static fromDerivationPath(t){let{path:e,mnemonic:i,scheme:r,legacy:c}=t,s;switch(r){case 2:s=y.fromDerivationPath(e,i);break;case 0:s=o.fromDerivationPath(e,i);break;default:throw new Error(`Unsupported scheme ${r}`)}return a.fromPrivateKey({privateKey:s,legacy:c})}static authKey(t){let{publicKey:e}=t;return u.fromPublicKey({publicKey:e})}sign(t){return this.privateKey.sign(t)}verifySignature(t){let{message:e,signature:i}=t,r=l.fromHexInput(e).toUint8Array();return this.publicKey.verifySignature({message:r,signature:i})}};export{g as a};
-//# sourceMappingURL=chunk-GAI75GOG.mjs.map
+import{a as u}from"./chunk-N25GOEVL.mjs";import{a as K}from"./chunk-4K252UDE.mjs";import{a as n}from"./chunk-OWP2MKTX.mjs";import{a as d,b as y}from"./chunk-RCYWJZR4.mjs";import{a as p,b as o}from"./chunk-5HZKDT5C.mjs";import{b as l}from"./chunk-NL72WE3E.mjs";var g=class a{constructor(t){let{privateKey:e,address:i,legacy:r}=t,c=r??!0;if(this.publicKey=e.publicKey(),this.publicKey instanceof p)c?this.signingScheme=0:(this.publicKey=new n(this.publicKey),this.signingScheme=2);else if(this.publicKey instanceof K)this.signingScheme=1;else if(this.publicKey instanceof d)this.publicKey=new n(this.publicKey),this.signingScheme=2;else throw new Error("Can not create new Account, unsupported public key type");this.privateKey=e,this.accountAddress=i}static generate(t){let e=t?.legacy??!0,i,r;switch(t?.scheme){case 2:i=y.generate(),r=new n(i.publicKey());break;default:i=o.generate(),e===!1?r=new n(i.publicKey()):r=i.publicKey()}let s=u.fromPublicKey({publicKey:r}).derivedAddress();return new a({privateKey:i,address:s,legacy:t?.legacy})}static fromPrivateKey(t){let{privateKey:e,legacy:i}=t,r=i??!0,c;if(e instanceof y)c=new n(e.publicKey());else if(e instanceof o)r?c=e.publicKey():c=new n(e.publicKey());else throw new Error(`Unsupported private key ${e}`);let m=u.fromPublicKey({publicKey:c}).derivedAddress();return new a({privateKey:e,address:m,legacy:r})}static fromPrivateKeyAndAddress(t){let{privateKey:e,address:i,legacy:r}=t;return new a({privateKey:e,address:i,legacy:r})}static fromDerivationPath(t){let{path:e,mnemonic:i,scheme:r,legacy:c}=t,s;switch(r){case 2:s=y.fromDerivationPath(e,i);break;case 0:s=o.fromDerivationPath(e,i);break;default:throw new Error(`Unsupported scheme ${r}`)}return a.fromPrivateKey({privateKey:s,legacy:c})}static authKey(t){let{publicKey:e}=t;return u.fromPublicKey({publicKey:e})}sign(t){return this.privateKey.sign(t)}verifySignature(t){let{message:e,signature:i}=t,r=l.fromHexInput(e).toUint8Array();return this.publicKey.verifySignature({message:r,signature:i})}};export{g as a};
+//# sourceMappingURL=chunk-PZ5JKQSP.mjs.map

package/dist/esm/chunk-Q3R3KKKP.mjs

@@ -0,0 +1,2 @@
+import{a as n}from"./chunk-LBNMY7EM.mjs";import{a as t,b as i,c as r,d as c,e as u,f as A,g as d,h as g,i as m,j as a,k as p,l as C,m as o,n as O,o as T,p as f,q as y}from"./chunk-Y5RQOXZH.mjs";import{f as s}from"./chunk-EOC4UI5B.mjs";var R=class{constructor(e){this.config=e}async getAccountInfo(e){return t({aptosConfig:this.config,...e})}async getAccountModules(e){return i({aptosConfig:this.config,...e})}async getAccountModule(e){return r({aptosConfig:this.config,...e})}async getAccountTransactions(e){return c({aptosConfig:this.config,...e})}async getAccountResources(e){return u({aptosConfig:this.config,...e})}async getAccountResource(e){return A({aptosConfig:this.config,...e})}async lookupOriginalAccountAddress(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),d({aptosConfig:this.config,...e})}async getAccountTokensCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),g({aptosConfig:this.config,...e})}async getAccountOwnedTokens(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),m({aptosConfig:this.config,...e})}async getAccountOwnedTokensFromCollectionAddress(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),a({aptosConfig:this.config,...e})}async getAccountCollectionsWithOwnedTokens(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),p({aptosConfig:this.config,...e})}async getAccountTransactionsCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),C({aptosConfig:this.config,...e})}async getAccountCoinsData(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),O({aptosConfig:this.config,...e})}async getAccountCoinsCount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),T({aptosConfig:this.config,...e})}async getAccountAPTAmount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),o({aptosConfig:this.config,coinType:s,...e})}async getAccountCoinAmount(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),o({aptosConfig:this.config,...e})}async getAccountOwnedObjects(e){return await n({config:this.config,minimumLedgerVersion:e.minimumLedgerVersion,processorTypes:["account_transactions_processor"]}),f({aptosConfig:this.config,...e})}async deriveAccountFromPrivateKey(e){return y({aptosConfig:this.config,...e})}};export{R as a};
+//# sourceMappingURL=chunk-Q3R3KKKP.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/account.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountAddress, PrivateKey, Account as AccountModule, AccountAddressInput } from \"../core\";\nimport {\n  AccountData,\n  AnyNumber,\n  GetAccountCoinsDataResponse,\n  GetAccountCollectionsWithOwnedTokenResponse,\n  GetAccountOwnedObjectsResponse,\n  GetAccountOwnedTokensFromCollectionResponse,\n  GetAccountOwnedTokensQueryResponse,\n  LedgerVersionArg,\n  MoveModuleBytecode,\n  MoveResource,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandardArg,\n  TransactionResponse,\n  WhereArg,\n} from \"../types\";\nimport {\n  deriveAccountFromPrivateKey,\n  getAccountCoinAmount,\n  getAccountCoinsCount,\n  getAccountCoinsData,\n  getAccountCollectionsWithOwnedTokens,\n  getAccountOwnedObjects,\n  getAccountOwnedTokens,\n  getAccountOwnedTokensFromCollectionAddress,\n  getAccountTokensCount,\n  getAccountTransactionsCount,\n  getInfo,\n  getModule,\n  getModules,\n  getResource,\n  getResources,\n  getTransactions,\n  lookupOriginalAccountAddress,\n} from \"../internal/account\";\nimport { APTOS_COIN, ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\nimport { CurrentFungibleAssetBalancesBoolExp } from \"../types/generated/types\";\n\n/**\n * A class to query all `Account` related queries on Aptos.\n */\nexport class Account {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Queries the current state for an Aptos account given its account address\n   *\n   * @param args.accountAddress Aptos account address\n   *\n   * @returns The account data\n   *\n   * @example An example of the returned account\n   * ```\n   * {\n   *    sequence_number: \"1\",\n   *    authentication_key: \"0x5307b5f4bc67829097a8ba9b43dba3b88261eeccd1f709d9bde240fc100fbb69\"\n   * }\n   * ```\n   */\n  async getAccountInfo(args: { accountAddress: AccountAddressInput }): Promise<AccountData> {\n    return getInfo({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for all modules in an account given an account address\n   *\n   * Note: In order to get all account modules, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number module to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account modules\n   */\n\n  async getAccountModules(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveModuleBytecode[]> {\n    return getModules({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries for a specific account module given account address and module name\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.moduleName The name of the module\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account module\n   *\n   * @example An example of an account module\n   * ```\n   * {\n   *    bytecode: \"0xa11ceb0b0600000006010002030206050807070f0d081c200\",\n   *    abi: { address: \"0x1\" }\n   * }\n   * ```\n   */\n  async getAccountModule(args: {\n    accountAddress: AccountAddressInput;\n    moduleName: string;\n    options?: LedgerVersionArg;\n  }): Promise<MoveModuleBytecode> {\n    return getModule({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries account transactions given an account address\n   *\n   * Note: In order to get all account transactions, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number transaction to start returning results from\n   * @param args.options.limit The number of results to return\n   *\n   * @returns The account transactions\n   */\n  async getAccountTransactions(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs;\n  }): Promise<TransactionResponse[]> {\n    return getTransactions({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all account resources given an account address\n   *\n   * Note: In order to get all account resources, this function may call the API\n   * multiple times as it auto paginates.\n   *\n   * @param args.accountAddress Aptos account address\n   * @param args.options.offset The number resource to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Account resources\n   */\n  async getAccountResources(args: {\n    accountAddress: AccountAddressInput;\n    options?: PaginationArgs & LedgerVersionArg;\n  }): Promise<MoveResource[]> {\n    return getResources({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a specific account resource given account address and resource type. Note that the default is `any` in order\n   * to allow for ease of accessing properties of the object.\n   *\n   * @type The typed output of the resource\n   * @param args.accountAddress Aptos account address\n   * @param args.resourceType String representation of an on-chain Move struct type, i.e \"0x1::aptos_coin::AptosCoin\"\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   *\n   * @returns Account resource\n   *\n   * @example An example of an account resource\n   * ```\n   * {\n   *    value: 6\n   * }\n   * ```\n   */\n  async getAccountResource<T extends {} = any>(args: {\n    accountAddress: AccountAddressInput;\n    resourceType: MoveStructId;\n    options?: LedgerVersionArg;\n  }): Promise<T> {\n    return getResource<T>({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Looks up the account address for a given authentication key\n   *\n   * This handles both if the account's authentication key has been rotated or not.\n   *\n   * @param args.authenticationKey The authentication key\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version\n   * @returns Promise<AccountAddress> The accountAddress associated with the authentication key\n   */\n  async lookupOriginalAccountAddress(args: {\n    authenticationKey: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: LedgerVersionArg;\n  }): Promise<AccountAddress> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n\n    return lookupOriginalAccountAddress({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the current count of tokens owned by an account\n   *\n   * @param args.accountAddress The account address\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of tokens owned by the account\n   */\n  async getAccountTokensCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountTokensCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the account's current owned tokens.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;\n  }): Promise<GetAccountOwnedTokensQueryResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries all current tokens of a specific collection that an account owns by the collection address\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @param args.accountAddress The account address we want to get the tokens for\n   * @param args.collectionAddress The address of the collection being queried\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number token to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Tokens array with the token data\n   */\n  async getAccountOwnedTokensFromCollectionAddress(args: {\n    accountAddress: AccountAddressInput;\n    collectionAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;\n  }): Promise<GetAccountOwnedTokensFromCollectionResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountOwnedTokensFromCollectionAddress({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries for all collections that an account currently has tokens for.\n   *\n   * This query returns all tokens (v1 and v2 standards) an account owns, including NFTs, fungible, soulbound, etc.\n   * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param\n   *\n   * @param args.accountAddress The account address we want to get the collections for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard The NFT standard to query for\n   * @param args.options.offset The number collection to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the tokens by\n   * @returns Collections array with the collections data\n   */\n  async getAccountCollectionsWithOwnedTokens(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;\n  }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountCollectionsWithOwnedTokens({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of transactions submitted by an account\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of transactions made by an account\n   */\n  async getAccountTransactionsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountTransactionsCount({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries an account's coins data\n   *\n   * @param args.accountAddress The account address we want to get the coins data for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset optional. The number coin to start returning results from\n   * @param args.options.limit optional. The number of results to return\n   * @param args.options.orderBy optional. The order to sort the coins by\n   * @param args.options.where optional. Filter the results by\n   * @returns Array with the coins data\n   */\n  async getAccountCoinsData(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs &\n      OrderByArg<GetAccountCoinsDataResponse[0]> &\n      WhereArg<CurrentFungibleAssetBalancesBoolExp>;\n  }): Promise<GetAccountCoinsDataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountCoinsData({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Queries the current count of an account's coins aggregated\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current count of the aggregated count of all account's coins\n   */\n  async getAccountCoinsCount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountCoinsCount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries the account's APT amount\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's APT\n   */\n  async getAccountAPTAmount(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountCoinAmount({ aptosConfig: this.config, coinType: APTOS_COIN, ...args });\n  }\n\n  /**\n   * Queries the account's coin amount by the coin type\n   *\n   * @param args.accountAddress The account address we want to get the total count for\n   * @param args.coinType The coin type to query\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns Current amount of account's coin\n   */\n  async getAccountCoinAmount(args: {\n    accountAddress: AccountAddressInput;\n    coinType: MoveStructId;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<number> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountCoinAmount({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries an account's owned objects\n   *\n   * @param args.accountAddress The account address we want to get the objects for\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.offset The starting position to start returning results from\n   * @param args.options.limit The number of results to return\n   * @param args.options.orderBy The order to sort the objects by\n   * @returns Objects array with the object data\n   */\n  async getAccountOwnedObjects(args: {\n    accountAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;\n  }): Promise<GetAccountOwnedObjectsResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],\n    });\n    return getAccountOwnedObjects({\n      aptosConfig: this.config,\n      ...args,\n    });\n  }\n\n  /**\n   * Derives an account by providing a private key.\n   * This functions resolves the provided private key type and derives the public key from it.\n   *\n   * If the privateKey is a Secp256k1 type, it derives the account using the derived public key and\n   * auth key using the SingleKey scheme locally.\n   *\n   * If the privateKey is a ED25519 type, it looks up the authentication key on chain, and uses it to resolve\n   * whether it is a Legacy ED25519 key or a Unified ED25519 key. It then derives the account based\n   * on that.\n   *\n   * @param args.privateKey An account private key\n   * @returns Account type\n   */\n  async deriveAccountFromPrivateKey(args: { privateKey: PrivateKey }): Promise<AccountModule> {\n    return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":"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","names":["Account","config","args","getInfo","getModules","getModule","getTransactions","getResources","getResource","waitForIndexerOnVersion","lookupOriginalAccountAddress","getAccountTokensCount","getAccountOwnedTokens","getAccountOwnedTokensFromCollectionAddress","getAccountCollectionsWithOwnedTokens","getAccountTransactionsCount","getAccountCoinsData","getAccountCoinsCount","getAccountCoinAmount","APTOS_COIN","getAccountOwnedObjects","deriveAccountFromPrivateKey"]}

package/dist/esm/chunk-RCYWJZR4.mjs

@@ -0,0 +1,2 @@
+import{e as d,j as m}from"./chunk-LR65XHSF.mjs";import{a as p,b as g,c as h}from"./chunk-EHJEK7FU.mjs";import{b as s}from"./chunk-NL72WE3E.mjs";import{sha3_256 as f}from"@noble/hashes/sha3";import{secp256k1 as o}from"@noble/curves/secp256k1";import{HDKey as H}from"@scure/bip32";var i=class i extends p{constructor(e){super();let t=s.fromHexInput(e);if(t.toUint8Array().length!==i.LENGTH)throw new Error(`PublicKey length should be ${i.LENGTH}`);this.key=t}toUint8Array(){return this.key.toUint8Array()}toString(){return this.key.toString()}verifySignature(e){let{message:t,signature:a}=e,y=s.fromHexInput(t).toUint8Array(),v=f(y),x=a.toUint8Array();return o.verify(x,v,this.toUint8Array())}serialize(e){e.serializeBytes(this.key.toUint8Array())}static deserialize(e){let t=e.deserializeBytes();return new i(t)}static load(e){let t=e.deserializeBytes();return new i(t)}static isPublicKey(e){return e instanceof i}};i.LENGTH=65;var u=i,r=class r extends g{constructor(e){super();let t=s.fromHexInput(e);if(t.toUint8Array().length!==r.LENGTH)throw new Error(`PrivateKey length should be ${r.LENGTH}`);this.key=t}toUint8Array(){return this.key.toUint8Array()}toString(){return this.key.toString()}sign(e){let t=s.fromHexInput(e),a=f(t.toUint8Array()),y=o.sign(a,this.key.toUint8Array());return new c(y.toCompactRawBytes())}serialize(e){e.serializeBytes(this.toUint8Array())}static deserialize(e){let t=e.deserializeBytes();return new r(t)}static generate(){let e=o.utils.randomPrivateKey();return new r(e)}publicKey(){let e=o.getPublicKey(this.key.toUint8Array(),!1);return new u(e)}static fromDerivationPath(e,t){if(!d(e))throw new Error(`Invalid derivation path ${e}`);return r.fromDerivationPathInner(e,m(t))}static fromDerivationPathInner(e,t){let{privateKey:a}=H.fromMasterSeed(t).derive(e);if(a===null)throw new Error("Invalid key");return new r(a)}static isPrivateKey(e){return e instanceof r}};r.LENGTH=32;var S=r,n=class n extends h{constructor(e){super();let t=s.fromHexInput(e);if(t.toUint8Array().length!==n.LENGTH)throw new Error(`Signature length should be ${n.LENGTH}, recieved ${t.toUint8Array().length}`);this.data=t}toUint8Array(){return this.data.toUint8Array()}toString(){return this.data.toString()}serialize(e){e.serializeBytes(this.data.toUint8Array())}static deserialize(e){let t=e.deserializeBytes();return new n(t)}static load(e){let t=e.deserializeBytes();return new n(t)}static isSignature(e){return e instanceof n}};n.LENGTH=64;var c=n;export{u as a,S as b,c};
+//# sourceMappingURL=chunk-RCYWJZR4.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/crypto/secp256k1.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sha3_256 } from \"@noble/hashes/sha3\";\nimport { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { HDKey } from \"@scure/bip32\";\nimport { PrivateKey, PublicKey, Signature } from \"./asymmetricCrypto\";\nimport { Deserializer, Serializer } from \"../../bcs\";\nimport { Hex } from \"../hex\";\nimport { HexInput } from \"../../types\";\nimport { isValidBIP44Path, mnemonicToSeed } from \"./hdKey\";\n\n/**\n * Represents the Secp256k1 ecdsa public key\n *\n * Secp256k1 authentication key is represented in the SDK as `AnyPublicKey`.\n */\nexport class Secp256k1PublicKey extends PublicKey {\n  // Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.\n  static readonly LENGTH: number = 65;\n\n  // Hex value of the public key\n  private readonly key: Hex;\n\n  /**\n   * Create a new PublicKey instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const hex = Hex.fromHexInput(hexInput);\n    if (hex.toUint8Array().length !== Secp256k1PublicKey.LENGTH) {\n      throw new Error(`PublicKey length should be ${Secp256k1PublicKey.LENGTH}`);\n    }\n    this.key = hex;\n  }\n\n  /**\n   * Get the public key in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the public key\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  /**\n   * Get the public key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the public key\n   */\n  toString(): string {\n    return this.key.toString();\n  }\n\n  /**\n   * Verifies a signed data with a public key\n   *\n   * @param args.message message\n   * @param args.signature The signature\n   * @returns true if the signature is valid\n   */\n  verifySignature(args: { message: HexInput; signature: Secp256k1Signature }): boolean {\n    const { message, signature } = args;\n    const msgHex = Hex.fromHexInput(message).toUint8Array();\n    const sha3Message = sha3_256(msgHex);\n    const rawSignature = signature.toUint8Array();\n    return secp256k1.verify(rawSignature, sha3Message, this.toUint8Array());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.key.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1PublicKey(bytes);\n  }\n\n  static load(deserializer: Deserializer): Secp256k1PublicKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1PublicKey(bytes);\n  }\n\n  static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {\n    return publicKey instanceof Secp256k1PublicKey;\n  }\n}\n\n/**\n * A Secp256k1 ecdsa private key\n */\nexport class Secp256k1PrivateKey extends PrivateKey {\n  /**\n   * Length of Secp256k1 ecdsa private key\n   */\n  static readonly LENGTH: number = 32;\n\n  /**\n   * The private key bytes\n   * @private\n   */\n  private readonly key: Hex;\n\n  /**\n   * Create a new PrivateKey instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const privateKeyHex = Hex.fromHexInput(hexInput);\n    if (privateKeyHex.toUint8Array().length !== Secp256k1PrivateKey.LENGTH) {\n      throw new Error(`PrivateKey length should be ${Secp256k1PrivateKey.LENGTH}`);\n    }\n\n    this.key = privateKeyHex;\n  }\n\n  /**\n   * Get the private key in bytes (Uint8Array).\n   *\n   * @returns\n   */\n  toUint8Array(): Uint8Array {\n    return this.key.toUint8Array();\n  }\n\n  /**\n   * Get the private key as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the private key\n   */\n  toString(): string {\n    return this.key.toString();\n  }\n\n  /**\n   * Sign the given message with the private key.\n   *\n   * @param message in HexInput format\n   * @returns Signature\n   */\n  sign(message: HexInput): Secp256k1Signature {\n    const msgHex = Hex.fromHexInput(message);\n    const sha3Message = sha3_256(msgHex.toUint8Array());\n    const signature = secp256k1.sign(sha3Message, this.key.toUint8Array());\n    return new Secp256k1Signature(signature.toCompactRawBytes());\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1PrivateKey {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1PrivateKey(bytes);\n  }\n\n  /**\n   * Generate a new random private key.\n   *\n   * @returns Secp256k1PrivateKey\n   */\n  static generate(): Secp256k1PrivateKey {\n    const hexInput = secp256k1.utils.randomPrivateKey();\n    return new Secp256k1PrivateKey(hexInput);\n  }\n\n  /**\n   * Derive the Secp256k1PublicKey from this private key.\n   *\n   * @returns Secp256k1PublicKey\n   */\n  publicKey(): Secp256k1PublicKey {\n    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);\n    return new Secp256k1PublicKey(bytes);\n  }\n\n  /**\n   * Derives a private key from a mnemonic seed phrase.\n   *\n   * @param path the BIP44 path\n   * @param mnemonics the mnemonic seed phrase\n   *\n   * @returns The generated key\n   */\n  static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey {\n    if (!isValidBIP44Path(path)) {\n      throw new Error(`Invalid derivation path ${path}`);\n    }\n    return Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));\n  }\n\n  /**\n   * A private inner function so we can separate from the main fromDerivationPath() method\n   * to add tests to verify we create the keys correctly.\n   *\n   * @param path the BIP44 path\n   * @param seed the seed phrase created by the mnemonics\n   *\n   * @returns The generated key\n   */\n  private static fromDerivationPathInner(path: string, seed: Uint8Array): Secp256k1PrivateKey {\n    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);\n    // library returns privateKey as Uint8Array | null\n    if (privateKey === null) {\n      throw new Error(\"Invalid key\");\n    }\n\n    return new Secp256k1PrivateKey(privateKey);\n  }\n\n  static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {\n    return privateKey instanceof Secp256k1PrivateKey;\n  }\n}\n\n/**\n * A signature of a message signed using an Secp256k1 ecdsa private key\n */\nexport class Secp256k1Signature extends Signature {\n  /**\n   * Secp256k1 ecdsa signatures are 256-bit.\n   */\n  static readonly LENGTH = 64;\n\n  /**\n   * The signature bytes\n   * @private\n   */\n  private readonly data: Hex;\n\n  /**\n   * Create a new Signature instance from a Uint8Array or String.\n   *\n   * @param hexInput A HexInput (string or Uint8Array)\n   */\n  constructor(hexInput: HexInput) {\n    super();\n\n    const hex = Hex.fromHexInput(hexInput);\n    if (hex.toUint8Array().length !== Secp256k1Signature.LENGTH) {\n      throw new Error(`Signature length should be ${Secp256k1Signature.LENGTH}, recieved ${hex.toUint8Array().length}`);\n    }\n    this.data = hex;\n  }\n\n  /**\n   * Get the signature in bytes (Uint8Array).\n   *\n   * @returns Uint8Array representation of the signature\n   */\n  toUint8Array(): Uint8Array {\n    return this.data.toUint8Array();\n  }\n\n  /**\n   * Get the signature as a hex string with the 0x prefix.\n   *\n   * @returns string representation of the signature\n   */\n  toString(): string {\n    return this.data.toString();\n  }\n\n  serialize(serializer: Serializer): void {\n    serializer.serializeBytes(this.data.toUint8Array());\n  }\n\n  static deserialize(deserializer: Deserializer): Secp256k1Signature {\n    const hex = deserializer.deserializeBytes();\n    return new Secp256k1Signature(hex);\n  }\n\n  static load(deserializer: Deserializer): Secp256k1Signature {\n    const bytes = deserializer.deserializeBytes();\n    return new Secp256k1Signature(bytes);\n  }\n\n  static isSignature(signature: Signature): signature is Secp256k1Signature {\n    return signature instanceof Secp256k1Signature;\n  }\n}\n"],"mappings":"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","names":["sha3_256","secp256k1","HDKey","_Secp256k1PublicKey","PublicKey","hexInput","hex","Hex","args","message","signature","msgHex","sha3Message","sha3_256","rawSignature","secp256k1","serializer","deserializer","bytes","publicKey","Secp256k1PublicKey","_Secp256k1PrivateKey","PrivateKey","privateKeyHex","Secp256k1Signature","path","mnemonics","isValidBIP44Path","mnemonicToSeed","seed","privateKey","HDKey","Secp256k1PrivateKey","_Secp256k1Signature","Signature"]}

package/dist/esm/chunk-TNUGIBLO.mjs

@@ -0,0 +1,2 @@
+import{a as t,b as r,c as s,d as c,e as a,f as d,g as m,h as g,i as p}from"./chunk-26GRNGPL.mjs";import{a as e}from"./chunk-LBNMY7EM.mjs";var u=class{constructor(n){this.config=n}async createCollectionTransaction(n){return d({aptosConfig:this.config,...n})}async getCollectionData(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(n.options?.tokenStandard)}),m({aptosConfig:this.config,...n})}async getCollectionId(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(n.options?.tokenStandard)}),g({aptosConfig:this.config,...n})}async mintTokenTransaction(n){return t({aptosConfig:this.config,...n})}async getTokenData(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(void 0)}),r({aptosConfig:this.config,...n})}async getCurrentTokenOwnership(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(void 0)}),s({aptosConfig:this.config,...n})}async getOwnedTokens(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(void 0)}),c({aptosConfig:this.config,...n})}async getTokenActivity(n){return await e({config:this.config,minimumLedgerVersion:n.minimumLedgerVersion,processorTypes:o(void 0)}),a({aptosConfig:this.config,...n})}async transferDigitalAsset(n){return p({aptosConfig:this.config,...n})}};function o(i){switch(i){case"v1":return["token_processor"];case"v2":return["token_v2_processor"];default:return["token_processor","token_v2_processor"]}}export{u as a};
+//# sourceMappingURL=chunk-TNUGIBLO.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/api/digitalAsset.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  AnyNumber,\n  GetCollectionDataResponse,\n  GetCurrentTokenOwnershipResponse,\n  GetOwnedTokensResponse,\n  GetTokenActivityResponse,\n  GetTokenDataResponse,\n  MoveStructId,\n  OrderByArg,\n  PaginationArgs,\n  TokenStandard,\n  TokenStandardArg,\n} from \"../types\";\nimport { Account, AccountAddress, AccountAddressInput } from \"../core\";\nimport { InputGenerateTransactionOptions, SingleSignerTransaction } from \"../transactions/types\";\nimport {\n  CreateCollectionOptions,\n  createCollectionTransaction,\n  getCollectionData,\n  getCollectionId,\n  getCurrentTokenOwnership,\n  getOwnedTokens,\n  getTokenActivity,\n  getTokenData,\n  mintTokenTransaction,\n  transferDigitalAsset,\n} from \"../internal/digitalAsset\";\nimport { ProcessorType } from \"../utils/const\";\nimport { AptosConfig } from \"./aptosConfig\";\nimport { waitForIndexerOnVersion } from \"./utils\";\n\n/**\n * A class to query all `DigitalAsset` related queries on Aptos.\n */\nexport class DigitalAsset {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Creates a new collection within the specified account\n   *\n   * @param args.creator the account of the collection's creator\n   * @param args.description the description of the collection\n   * @param args.name the name of the collection\n   * @param args.uri the URI to additional info about the collection\n   *\n   * The parameters below are optional.\n   * @param args.maxSupply controls the max supply of the tokens - defaults MAX_U64_BIG_INT\n   * @param args.mutableDescription controls mutability of the collection's description - defaults true\n   * @param args.mutableRoyalty controls mutability of the collection's description - defaults true\n   * @param args.mutableUri controls mutability of the collection's URI - defaults true\n   * @param args.mutableTokenDescription controls mutability of the token's description - defaults true\n   * @param args.mutableTokenName controls mutability of the token's name - defaults true\n   * @param args.mutableTokenProperties controls mutability of token's properties - defaults true\n   * @param args.mutableTokenUri controls mutability of the token's URI - defaults true\n   * @param args.tokensBurnableByCreator controls whether tokens can be burnable by the creator - defaults true\n   * @param args.tokensFreezableByCreator controls whether tokens can be frozen by the creator - defaults true\n   * @param args.royaltyNumerator the numerator of the royalty to be paid to the creator when a token is transferred - defaults 0\n   * @param args.royaltyDenominator the denominator of the royalty to be paid to the creator when a token is transferred -\n   *    defaults 1\n   *\n   * @returns A SingleSignerTransaction that when submitted will create the collection.\n   */\n  async createCollectionTransaction(\n    args: {\n      creator: Account;\n      description: string;\n      name: string;\n      uri: string;\n      options?: InputGenerateTransactionOptions;\n    } & CreateCollectionOptions,\n  ): Promise<SingleSignerTransaction> {\n    return createCollectionTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries data of a specific collection by the collection creator address and the collection name.\n   *\n   * If, for some reason, a creator account has 2 collections with the same name in v1 and v2,\n   * can pass an optional `tokenStandard` parameter to query a specific standard\n   *\n   * @param args.creatorAddress the address of the collection's creator\n   * @param args.collectionName the name of the collection\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard the token standard to query\n   * @returns GetCollectionDataResponse response type\n   */\n  async getCollectionData(args: {\n    creatorAddress: AccountAddressInput;\n    collectionName: string;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg;\n  }): Promise<GetCollectionDataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: getTokenProcessorTypes(args.options?.tokenStandard),\n    });\n    return getCollectionData({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Queries a collection's ID.\n   *\n   * This is the same as the collection's object address in V2, but V1 does\n   * not use objects, and does not have an address\n   *\n   * @param args.creatorAddress the address of the collection's creator\n   * @param args.collectionName the name of the collection\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @param args.options.tokenStandard the token standard to query\n   * @returns the collection id\n   */\n  async getCollectionId(args: {\n    creatorAddress: AccountAddressInput;\n    collectionName: string;\n    minimumLedgerVersion?: AnyNumber;\n    options?: TokenStandardArg;\n  }): Promise<string> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      processorTypes: getTokenProcessorTypes(args.options?.tokenStandard),\n    });\n    return getCollectionId({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Create a transaction to mint a token into the creators account within an existing collection.\n   *\n   * @param args.creator the creator of the collection\n   * @param args.collection the name of the collection the token belongs to\n   * @param args.description the description of the token\n   * @param args.name the name of the token\n   * @param args.uri the URI to additional info about the token\n   *\n   * @returns A SingleSignerTransaction that can be simulated or submitted to chain\n   */\n  async mintTokenTransaction(args: {\n    creator: Account;\n    collection: string;\n    description: string;\n    name: string;\n    uri: string;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SingleSignerTransaction> {\n    return mintTokenTransaction({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Gets token data given the address of a token.\n   *\n   * @param args.tokenAddress The address of the token\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns GetTokenDataResponse containing relevant data to the token.\n   */\n  async getTokenData(args: {\n    tokenAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<GetTokenDataResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      // TODO(greg): Should take in a consistent input for token queries\n      processorTypes: getTokenProcessorTypes(undefined),\n    });\n    return getTokenData({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Gets token ownership data given the address of a token.\n   *\n   * @param args.tokenAddress The address of the token\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns GetCurrentTokenOwnershipResponse containing relevant ownership data of the token.\n   */\n  async getCurrentTokenOwnership(args: {\n    tokenAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n  }): Promise<GetCurrentTokenOwnershipResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      // TODO(greg): Should take in a consistent input for token queries\n      processorTypes: getTokenProcessorTypes(undefined),\n    });\n    return getCurrentTokenOwnership({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Gets the tokens that the given address owns.\n   *\n   * @param args.ownerAddress The address of the owner\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns GetOwnedTokensResponse containing ownership data of the tokens belonging to the ownerAddresss.\n   */\n  async getOwnedTokens(args: {\n    ownerAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetOwnedTokensResponse[0]>;\n  }): Promise<GetOwnedTokensResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      // TODO(greg): Should take in a consistent input for token queries\n      processorTypes: getTokenProcessorTypes(undefined),\n    });\n    return getOwnedTokens({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Gets the activity data given the address of a token.\n   *\n   * @param args.tokenAddress The address of the token\n   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying\n   * @returns GetTokenActivityResponse containing relevant activity data to the token.\n   */\n  async getTokenActivity(args: {\n    tokenAddress: AccountAddressInput;\n    minimumLedgerVersion?: AnyNumber;\n    options?: PaginationArgs & OrderByArg<GetTokenActivityResponse[0]>;\n  }): Promise<GetTokenActivityResponse> {\n    await waitForIndexerOnVersion({\n      config: this.config,\n      minimumLedgerVersion: args.minimumLedgerVersion,\n      // TODO(greg): Should take in a consistent input for token queries\n      processorTypes: getTokenProcessorTypes(undefined),\n    });\n    return getTokenActivity({ aptosConfig: this.config, ...args });\n  }\n\n  /**\n   * Transfer a digital asset (non fungible token) ownership.\n   *\n   * We can transfer a digital asset only when the digital asset is not frozen\n   * (i.e. owner transfer is not disabled such as for soul bound tokens)\n   *\n   * @param args.sender The sender account of the current digital asset owner\n   * @param args.digitalAssetAddress The digital asset address\n   * @param args.recipient The recipient account address\n   * @param args.digitalAssetType optional. The digital asset type, default to \"0x4::token::Token\"\n   *\n   * @returns A SingleSignerTransaction that can be simulated or submitted to chain\n   */\n  async transferDigitalAsset(args: {\n    sender: Account;\n    digitalAssetAddress: AccountAddressInput;\n    recipient: AccountAddress;\n    digitalAssetType?: MoveStructId;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SingleSignerTransaction> {\n    return transferDigitalAsset({ aptosConfig: this.config, ...args });\n  }\n}\n\nfunction getTokenProcessorTypes(tokenStandard?: TokenStandard) {\n  switch (tokenStandard) {\n    case \"v1\":\n      return [ProcessorType.TOKEN_PROCESSOR];\n    case \"v2\":\n      return [ProcessorType.TOKEN_V2_PROCESSOR];\n    default:\n      // If it's something we don't recognize, or undefined, just do both\n      return [ProcessorType.TOKEN_PROCESSOR, ProcessorType.TOKEN_V2_PROCESSOR];\n  }\n}\n"],"mappings":"0IAqCO,IAAMA,EAAN,KAAmB,CACxB,YAAqBC,EAAqB,CAArB,YAAAA,CAAsB,CA2B3C,MAAM,4BACJC,EAOkC,CAClC,OAAOC,EAA4B,CAAE,YAAa,KAAK,OAAQ,GAAGD,CAAK,CAAC,CAC1E,CAcA,MAAM,kBAAkBA,EAKe,CACrC,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAC3B,eAAgBG,EAAuBH,EAAK,SAAS,aAAa,CACpE,CAAC,EACMI,EAAkB,CAAE,YAAa,KAAK,OAAQ,GAAGJ,CAAK,CAAC,CAChE,CAcA,MAAM,gBAAgBA,EAKF,CAClB,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAC3B,eAAgBG,EAAuBH,EAAK,SAAS,aAAa,CACpE,CAAC,EACMK,EAAgB,CAAE,YAAa,KAAK,OAAQ,GAAGL,CAAK,CAAC,CAC9D,CAaA,MAAM,qBAAqBA,EAOU,CACnC,OAAOM,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGN,CAAK,CAAC,CACnE,CASA,MAAM,aAAaA,EAGe,CAChC,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAE3B,eAAgBG,EAAuB,MAAS,CAClD,CAAC,EACMI,EAAa,CAAE,YAAa,KAAK,OAAQ,GAAGP,CAAK,CAAC,CAC3D,CASA,MAAM,yBAAyBA,EAGe,CAC5C,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAE3B,eAAgBG,EAAuB,MAAS,CAClD,CAAC,EACMK,EAAyB,CAAE,YAAa,KAAK,OAAQ,GAAGR,CAAK,CAAC,CACvE,CASA,MAAM,eAAeA,EAIe,CAClC,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAE3B,eAAgBG,EAAuB,MAAS,CAClD,CAAC,EACMM,EAAe,CAAE,YAAa,KAAK,OAAQ,GAAGT,CAAK,CAAC,CAC7D,CASA,MAAM,iBAAiBA,EAIe,CACpC,aAAME,EAAwB,CAC5B,OAAQ,KAAK,OACb,qBAAsBF,EAAK,qBAE3B,eAAgBG,EAAuB,MAAS,CAClD,CAAC,EACMO,EAAiB,CAAE,YAAa,KAAK,OAAQ,GAAGV,CAAK,CAAC,CAC/D,CAeA,MAAM,qBAAqBA,EAMU,CACnC,OAAOW,EAAqB,CAAE,YAAa,KAAK,OAAQ,GAAGX,CAAK,CAAC,CACnE,CACF,EAEA,SAASG,EAAuBS,EAA+B,CAC7D,OAAQA,EAAe,CACrB,IAAK,KACH,MAAO,kBAA8B,EACvC,IAAK,KACH,MAAO,qBAAiC,EAC1C,QAEE,MAAO,uCAAgE,CAC3E,CACF","names":["DigitalAsset","config","args","createCollectionTransaction","waitForIndexerOnVersion","getTokenProcessorTypes","getCollectionData","getCollectionId","mintTokenTransaction","getTokenData","getCurrentTokenOwnership","getOwnedTokens","getTokenActivity","transferDigitalAsset","tokenStandard"]}

package/dist/esm/{chunk-3732I6BR.mjs → chunk-TTICPGX6.mjs}

@@ -1,2 +1,2 @@
-import{a as d}from"./chunk-5LO7FR2P.mjs";import{a as y}from"./chunk-3VZ3OZKC.mjs";import{a as b}from"./chunk-DRPMIJH7.mjs";import{a as A}from"./chunk-4KTQIWUP.mjs";import{a as c}from"./chunk-J5BH7V37.mjs";import{a as g}from"./chunk-PZCMSHY6.mjs";import{a as f}from"./chunk-67OGU66P.mjs";import{a as m}from"./chunk-M2V2POWK.mjs";import{a as u}from"./chunk-RKKU2SY5.mjs";import{a as h}from"./chunk-Y2HRRUZ6.mjs";import{a as p}from"./chunk-OCW2L33Q.mjs";import{a as e}from"./chunk-ZLW65YCO.mjs";import{a as l}from"./chunk-ZUHN56GM.mjs";import{a as S}from"./chunk-ARVSIDVB.mjs";import{a as r}from"./chunk-72F5YXGC.mjs";import{a}from"./chunk-OSTH5JRX.mjs";var i=class{constructor(n){this.config=new S(n),this.account=new e(this.config),this.ans=new l(this.config),this.coin=new r(this.config),this.digitalAsset=new a(this.config),this.event=new c(this.config),this.faucet=new g(this.config),this.fungibleAsset=new f(this.config),this.general=new m(this.config),this.staking=new u(this.config),this.transaction=new h(this.config),this.transactionSubmission=new p(this.config),this.build=new d(this.config),this.sign=new y(this.config),this.simulate=new b(this.config),this.submit=new A(this.config)}};function t(w,n,v){Object.getOwnPropertyNames(n.prototype).forEach(o=>{let s=Object.getOwnPropertyDescriptor(n.prototype,o);s&&(s.value=function(...k){return this[v][o](...k)},Object.defineProperty(w.prototype,o,s))})}t(i,e,"account");t(i,l,"ans");t(i,r,"coin");t(i,a,"digitalAsset");t(i,c,"event");t(i,g,"faucet");t(i,f,"fungibleAsset");t(i,m,"general");t(i,u,"staking");t(i,h,"transaction");t(i,p,"transactionSubmission");t(i,d,"build");t(i,y,"sign");t(i,b,"simulate");t(i,A,"submit");export{i as a};
-//# sourceMappingURL=chunk-3732I6BR.mjs.map
+import{a as d}from"./chunk-W44E6YAW.mjs";import{a as y}from"./chunk-4XQ5IV6C.mjs";import{a as b}from"./chunk-PEBXSNMJ.mjs";import{a as A}from"./chunk-NZ36UN4C.mjs";import{a as p}from"./chunk-NBSXZKMQ.mjs";import{a}from"./chunk-TNUGIBLO.mjs";import{a as c}from"./chunk-GMOHGD73.mjs";import{a as g}from"./chunk-5SRMD5C6.mjs";import{a as f}from"./chunk-PLY7MQKE.mjs";import{a as m}from"./chunk-32A35CPU.mjs";import{a as u}from"./chunk-BA4TDBYB.mjs";import{a as h}from"./chunk-WXISFVRU.mjs";import{a as e}from"./chunk-Q3R3KKKP.mjs";import{a as l}from"./chunk-2X3FRUKX.mjs";import{a as S}from"./chunk-3RMXGSHK.mjs";import{a as r}from"./chunk-2AMFCGJ3.mjs";var i=class{constructor(n){this.config=new S(n),this.account=new e(this.config),this.ans=new l(this.config),this.coin=new r(this.config),this.digitalAsset=new a(this.config),this.event=new c(this.config),this.faucet=new g(this.config),this.fungibleAsset=new f(this.config),this.general=new m(this.config),this.staking=new u(this.config),this.transaction=new h(this.config),this.transactionSubmission=new p(this.config),this.build=new d(this.config),this.sign=new y(this.config),this.simulate=new b(this.config),this.submit=new A(this.config)}};function t(w,n,v){Object.getOwnPropertyNames(n.prototype).forEach(o=>{let s=Object.getOwnPropertyDescriptor(n.prototype,o);s&&(s.value=function(...k){return this[v][o](...k)},Object.defineProperty(w.prototype,o,s))})}t(i,e,"account");t(i,l,"ans");t(i,r,"coin");t(i,a,"digitalAsset");t(i,c,"event");t(i,g,"faucet");t(i,f,"fungibleAsset");t(i,m,"general");t(i,u,"staking");t(i,h,"transaction");t(i,p,"transactionSubmission");t(i,d,"build");t(i,y,"sign");t(i,b,"simulate");t(i,A,"submit");export{i as a};
+//# sourceMappingURL=chunk-TTICPGX6.mjs.map

package/dist/esm/chunk-U6Z4FNB7.mjs

@@ -0,0 +1,2 @@
+var i=class{constructor(){this.queue=[];this.pendingDequeue=[];this.cancelled=!1}enqueue(e){if(this.cancelled=!1,this.pendingDequeue.length>0){this.pendingDequeue.shift()?.resolve(e);return}this.queue.push(e)}async dequeue(){return this.queue.length>0?Promise.resolve(this.queue.shift()):new Promise((e,u)=>{this.pendingDequeue.push({resolve:e,reject:u})})}isEmpty(){return this.queue.length===0}cancel(){this.cancelled=!0,this.pendingDequeue.forEach(async({reject:e})=>{e(new n("Task cancelled"))}),this.pendingDequeue=[],this.queue.length=0}isCancelled(){return this.cancelled}pendingDequeueLength(){return this.pendingDequeue.length}},n=class extends Error{};export{i as a,n as b};
+//# sourceMappingURL=chunk-U6Z4FNB7.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/management/asyncQueue.ts"],"sourcesContent":["/**\n * The AsyncQueue class is an async-aware data structure that provides a queue-like\n * behavior for managing asynchronous tasks or operations.\n * It allows to enqueue items and dequeue them asynchronously.\n * This is not thread-safe but it is async concurrency safe and\n * it does not guarantee ordering for those that call into and await on enqueue.\n */\n\ninterface PendingDequeue<T> {\n  resolve: (value: T) => void;\n  reject: (reason?: AsyncQueueCancelledError) => void;\n}\n\nexport class AsyncQueue<T> {\n  readonly queue: T[] = [];\n\n  // The pendingDequeue is used to handle the resolution of promises when items are enqueued and dequeued.\n  private pendingDequeue: PendingDequeue<T>[] = [];\n\n  private cancelled: boolean = false;\n\n  /**\n   * The enqueue method adds an item to the queue. If there are pending dequeued promises,\n   * in the pendingDequeue, it resolves the oldest promise with the enqueued item immediately.\n   * Otherwise, it adds the item to the queue.\n   *\n   * @param item T\n   */\n  enqueue(item: T): void {\n    this.cancelled = false;\n\n    if (this.pendingDequeue.length > 0) {\n      const promise = this.pendingDequeue.shift();\n\n      promise?.resolve(item);\n\n      return;\n    }\n\n    this.queue.push(item);\n  }\n\n  /**\n   * The dequeue method returns a promise that resolves to the next item in the queue.\n   * If the queue is not empty, it resolves the promise immediately with the next item.\n   * Otherwise, it creates a new promise. The promise's resolve function is stored\n   * in the pendingDequeue with a unique counter value as the key.\n   * The newly created promise is then returned, and it will be resolved later when an item is enqueued.\n   *\n   * @returns Promise<T>\n   */\n  async dequeue(): Promise<T> {\n    if (this.queue.length > 0) {\n      return Promise.resolve(this.queue.shift()!);\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      this.pendingDequeue.push({ resolve, reject });\n    });\n  }\n\n  /**\n   * The isEmpty method returns whether the queue is empty or not.\n   *\n   * @returns boolean\n   */\n  isEmpty(): boolean {\n    return this.queue.length === 0;\n  }\n\n  /**\n   * The cancel method cancels all pending promises in the queue.\n   * It rejects the promises with a AsyncQueueCancelledError error,\n   * ensuring that any awaiting code can handle the cancellation appropriately.\n   */\n  cancel(): void {\n    this.cancelled = true;\n\n    this.pendingDequeue.forEach(async ({ reject }) => {\n      reject(new AsyncQueueCancelledError(\"Task cancelled\"));\n    });\n\n    this.pendingDequeue = [];\n\n    this.queue.length = 0;\n  }\n\n  /**\n   * The isCancelled method returns whether the queue is cancelled or not.\n   *\n   * @returns boolean\n   */\n  isCancelled(): boolean {\n    return this.cancelled;\n  }\n\n  /**\n   * The pendingDequeueLength method returns the length of the pendingDequeue.\n   *\n   * @returns number\n   */\n  pendingDequeueLength(): number {\n    return this.pendingDequeue.length;\n  }\n}\n\nexport class AsyncQueueCancelledError extends Error {}\n"],"mappings":"AAaO,IAAMA,EAAN,KAAoB,CAApB,cACL,KAAS,MAAa,CAAC,EAGvB,KAAQ,eAAsC,CAAC,EAE/C,KAAQ,UAAqB,GAS7B,QAAQC,EAAe,CAGrB,GAFA,KAAK,UAAY,GAEb,KAAK,eAAe,OAAS,EAAG,CAClB,KAAK,eAAe,MAAM,GAEjC,QAAQA,CAAI,EAErB,MACF,CAEA,KAAK,MAAM,KAAKA,CAAI,CACtB,CAWA,MAAM,SAAsB,CAC1B,OAAI,KAAK,MAAM,OAAS,EACf,QAAQ,QAAQ,KAAK,MAAM,MAAM,CAAE,EAGrC,IAAI,QAAW,CAACC,EAASC,IAAW,CACzC,KAAK,eAAe,KAAK,CAAE,QAAAD,EAAS,OAAAC,CAAO,CAAC,CAC9C,CAAC,CACH,CAOA,SAAmB,CACjB,OAAO,KAAK,MAAM,SAAW,CAC/B,CAOA,QAAe,CACb,KAAK,UAAY,GAEjB,KAAK,eAAe,QAAQ,MAAO,CAAE,OAAAA,CAAO,IAAM,CAChDA,EAAO,IAAIC,EAAyB,gBAAgB,CAAC,CACvD,CAAC,EAED,KAAK,eAAiB,CAAC,EAEvB,KAAK,MAAM,OAAS,CACtB,CAOA,aAAuB,CACrB,OAAO,KAAK,SACd,CAOA,sBAA+B,CAC7B,OAAO,KAAK,eAAe,MAC7B,CACF,EAEaA,EAAN,cAAuC,KAAM,CAAC","names":["AsyncQueue","item","resolve","reject","AsyncQueueCancelledError"]}

package/dist/esm/{chunk-GTC7WHMV.mjs → chunk-UDMADMVO.mjs}

@@ -1,2 +1,2 @@
 import{c as t}from"./chunk-DNDWTM7A.mjs";var n=class{constructor(e){this.buffer=new ArrayBuffer(e.length),new Uint8Array(this.buffer).set(e,0),this.offset=0}read(e){if(this.offset+e>this.buffer.byteLength)throw new Error("Reached to the end of buffer");let i=this.buffer.slice(this.offset,this.offset+e);return this.offset+=e,i}deserializeStr(){let e=this.deserializeBytes();return new TextDecoder().decode(e)}deserializeBytes(){let e=this.deserializeUleb128AsU32();return new Uint8Array(this.read(e))}deserializeFixedBytes(e){return new Uint8Array(this.read(e))}deserializeBool(){let e=new Uint8Array(this.read(1))[0];if(e!==1&&e!==0)throw new Error("Invalid boolean value");return e===1}deserializeU8(){return new DataView(this.read(1)).getUint8(0)}deserializeU16(){return new DataView(this.read(2)).getUint16(0,!0)}deserializeU32(){return new DataView(this.read(4)).getUint32(0,!0)}deserializeU64(){let e=this.deserializeU32(),i=this.deserializeU32();return BigInt(BigInt(i)<<BigInt(32)|BigInt(e))}deserializeU128(){let e=this.deserializeU64(),i=this.deserializeU64();return BigInt(i<<BigInt(64)|e)}deserializeU256(){let e=this.deserializeU128(),i=this.deserializeU128();return BigInt(i<<BigInt(128)|e)}deserializeUleb128AsU32(){let e=BigInt(0),i=0;for(;e<t;){let r=this.deserializeU8();if(e|=BigInt(r&127)<<BigInt(i),!(r&128))break;i+=7}if(e>t)throw new Error("Overflow while parsing uleb128-encoded uint32 value");return Number(e)}deserialize(e){return e.deserialize(this)}deserializeVector(e){let i=this.deserializeUleb128AsU32(),r=new Array;for(let s=0;s<i;s+=1)r.push(this.deserialize(e));return r}};export{n as a};
-//# sourceMappingURL=chunk-GTC7WHMV.mjs.map
+//# sourceMappingURL=chunk-UDMADMVO.mjs.map