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

package/dist/esm/chunk-HKQY5GXT.mjs

@@ -1,231 +0,0 @@
-import {
-  buildTransaction,
-  generateSignedTransaction,
-  generateSignedTransactionForSimulation,
-  generateTransactionPayload
-} from "./chunk-IJ7XCPP3.mjs";
-import {
-  AbstractKeylessAccount,
-  isKeylessSigner
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-F4VI7BNX.mjs";
-import {
-  SignedTransaction
-} from "./chunk-R45SPK6Q.mjs";
-import {
-  TypeTagVector
-} from "./chunk-DDZGHA66.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  KeylessPublicKey
-} from "./chunk-T573PCIR.mjs";
-import {
-  postAptosFullNode
-} from "./chunk-6T3V5LXK.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveVector
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-
-// src/internal/transactionSubmission.ts
-async function generateTransaction(args) {
-  const payload = await buildTransactionPayload(args);
-  return buildRawTransaction(args, payload);
-}
-async function buildTransactionPayload(args) {
-  const { aptosConfig, data } = args;
-  let generateTransactionPayloadData;
-  let payload;
-  if ("bytecode" in data) {
-    payload = await generateTransactionPayload(data);
-  } else if ("multisigAddress" in data) {
-    generateTransactionPayloadData = {
-      aptosConfig,
-      multisigAddress: data.multisigAddress,
-      function: data.function,
-      functionArguments: data.functionArguments,
-      typeArguments: data.typeArguments,
-      abi: data.abi
-    };
-    payload = await generateTransactionPayload(generateTransactionPayloadData);
-  } else {
-    generateTransactionPayloadData = {
-      aptosConfig,
-      function: data.function,
-      functionArguments: data.functionArguments,
-      typeArguments: data.typeArguments,
-      abi: data.abi
-    };
-    payload = await generateTransactionPayload(generateTransactionPayloadData);
-  }
-  return payload;
-}
-async function buildRawTransaction(args, payload) {
-  const { aptosConfig, sender, options } = args;
-  let feePayerAddress;
-  if (isFeePayerTransactionInput(args)) {
-    feePayerAddress = AccountAddress.ZERO.toString();
-  }
-  if (isMultiAgentTransactionInput(args)) {
-    const { secondarySignerAddresses } = args;
-    return buildTransaction({
-      aptosConfig,
-      sender,
-      payload,
-      options,
-      secondarySignerAddresses,
-      feePayerAddress
-    });
-  }
-  return buildTransaction({
-    aptosConfig,
-    sender,
-    payload,
-    options,
-    feePayerAddress
-  });
-}
-function isFeePayerTransactionInput(data) {
-  return data.withFeePayer === true;
-}
-function isMultiAgentTransactionInput(data) {
-  return "secondarySignerAddresses" in data;
-}
-function getSigningMessage(args) {
-  const { transaction } = args;
-  return generateSigningMessageForTransaction(transaction);
-}
-function signTransaction(args) {
-  const { signer, transaction } = args;
-  return signer.signTransactionWithAuthenticator(transaction);
-}
-function signAsFeePayer(args) {
-  const { signer, transaction } = args;
-  if (!transaction.feePayerAddress) {
-    throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
-  }
-  transaction.feePayerAddress = signer.accountAddress;
-  return signTransaction({
-    signer,
-    transaction
-  });
-}
-async function simulateTransaction(args) {
-  const { aptosConfig, transaction, signerPublicKey, secondarySignersPublicKeys, feePayerPublicKey, options } = args;
-  const signedTransaction = generateSignedTransactionForSimulation({
-    transaction,
-    signerPublicKey,
-    secondarySignersPublicKeys,
-    feePayerPublicKey,
-    options
-  });
-  const { data } = await postAptosFullNode({
-    aptosConfig,
-    body: signedTransaction,
-    path: "transactions/simulate",
-    params: {
-      estimate_gas_unit_price: args.options?.estimateGasUnitPrice ?? false,
-      estimate_max_gas_amount: args.options?.estimateMaxGasAmount ?? false,
-      estimate_prioritized_gas_unit_price: args.options?.estimatePrioritizedGasUnitPrice ?? false
-    },
-    originMethod: "simulateTransaction",
-    contentType: "application/x.aptos.signed_transaction+bcs" /* BCS_SIGNED_TRANSACTION */
-  });
-  return data;
-}
-async function submitTransaction(args) {
-  const { aptosConfig } = args;
-  const signedTransaction = generateSignedTransaction({ ...args });
-  try {
-    const { data } = await postAptosFullNode({
-      aptosConfig,
-      body: signedTransaction,
-      path: "transactions",
-      originMethod: "submitTransaction",
-      contentType: "application/x.aptos.signed_transaction+bcs" /* BCS_SIGNED_TRANSACTION */
-    });
-    return data;
-  } catch (e) {
-    const signedTxn = SignedTransaction.deserialize(new Deserializer(signedTransaction));
-    if (signedTxn.authenticator.isSingleSender() && signedTxn.authenticator.sender.isSingleKey() && (signedTxn.authenticator.sender.public_key.publicKey instanceof KeylessPublicKey || signedTxn.authenticator.sender.public_key.publicKey instanceof FederatedKeylessPublicKey)) {
-      await AbstractKeylessAccount.fetchJWK({
-        aptosConfig,
-        publicKey: signedTxn.authenticator.sender.public_key.publicKey,
-        kid: signedTxn.authenticator.sender.signature.signature.getJwkKid()
-      });
-    }
-    throw e;
-  }
-}
-async function signAndSubmitTransaction(args) {
-  const { aptosConfig, signer, feePayer, transaction } = args;
-  if (isKeylessSigner(signer)) {
-    await signer.checkKeylessAccountValidity(aptosConfig);
-  }
-  if (isKeylessSigner(feePayer)) {
-    await feePayer.checkKeylessAccountValidity(aptosConfig);
-  }
-  const feePayerAuthenticator = args.feePayerAuthenticator || feePayer && signAsFeePayer({ signer: feePayer, transaction });
-  const senderAuthenticator = signTransaction({ signer, transaction });
-  return submitTransaction({
-    aptosConfig,
-    transaction,
-    senderAuthenticator,
-    feePayerAuthenticator
-  });
-}
-async function signAndSubmitAsFeePayer(args) {
-  const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;
-  if (isKeylessSigner(feePayer)) {
-    await feePayer.checkKeylessAccountValidity(aptosConfig);
-  }
-  const feePayerAuthenticator = signAsFeePayer({ signer: feePayer, transaction });
-  return submitTransaction({
-    aptosConfig,
-    transaction,
-    senderAuthenticator,
-    feePayerAuthenticator
-  });
-}
-var packagePublishAbi = {
-  typeParameters: [],
-  parameters: [TypeTagVector.u8(), new TypeTagVector(TypeTagVector.u8())]
-};
-async function publicPackageTransaction(args) {
-  const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;
-  const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));
-  return generateTransaction({
-    aptosConfig,
-    sender: AccountAddress.from(account),
-    data: {
-      function: "0x1::code::publish_package_txn",
-      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
-      abi: packagePublishAbi
-    },
-    options
-  });
-}
-
-export {
-  generateTransaction,
-  buildTransactionPayload,
-  buildRawTransaction,
-  getSigningMessage,
-  signTransaction,
-  signAsFeePayer,
-  simulateTransaction,
-  submitTransaction,
-  signAndSubmitTransaction,
-  signAndSubmitAsFeePayer,
-  publicPackageTransaction
-};
-//# sourceMappingURL=chunk-HKQY5GXT.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internal/transactionSubmission.ts"],"sourcesContent":["/**\n * This file contains the underlying implementations for exposed submission API surface in\n * the {@link api/transaction}. By moving the methods out into a separate file,\n * other namespaces and processes can access these methods without depending on the entire\n * transaction namespace and without having a dependency cycle error.\n * @group Implementation\n */\n\nimport { AptosConfig } from \"../api/aptosConfig\";\nimport { Deserializer, MoveVector } from \"../bcs\";\nimport { postAptosFullNode } from \"../client\";\nimport { Account, AbstractKeylessAccount, isKeylessSigner } from \"../account\";\nimport { AccountAddress, AccountAddressInput } from \"../core/accountAddress\";\nimport { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature } from \"../core/crypto\";\nimport { AccountAuthenticator } from \"../transactions/authenticator/account\";\nimport {\n  buildTransaction,\n  generateTransactionPayload,\n  generateSignedTransactionForSimulation,\n  generateSignedTransaction,\n} from \"../transactions/transactionBuilder/transactionBuilder\";\nimport {\n  InputGenerateTransactionData,\n  AnyRawTransaction,\n  InputSimulateTransactionData,\n  InputGenerateTransactionOptions,\n  InputGenerateTransactionPayloadDataWithRemoteABI,\n  InputSubmitTransactionData,\n  InputGenerateMultiAgentRawTransactionData,\n  InputGenerateSingleSignerRawTransactionData,\n  AnyTransactionPayloadInstance,\n  EntryFunctionABI,\n} from \"../transactions/types\";\nimport { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput } from \"../types\";\nimport { SignedTransaction, TypeTagVector, generateSigningMessageForTransaction } from \"../transactions\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\nimport { MultiAgentTransaction } from \"../transactions/instances/multiAgentTransaction\";\n\n/**\n * We are defining function signatures, each with its specific input and output.\n * These are the possible function signature for `generateTransaction` function.\n * When we call `generateTransaction` function with the relevant type properties,\n * Typescript can infer the return type based on the appropriate function overload.\n * @group Implementation\n */\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateSingleSignerRawTransactionData,\n): Promise<SimpleTransaction>;\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateMultiAgentRawTransactionData,\n): Promise<MultiAgentTransaction>;\n/**\n * Generates any transaction by passing in the required arguments\n *\n * @param args.sender The transaction sender's account address as a AccountAddressInput\n * @param args.data EntryFunctionData | ScriptData | MultiSigData\n * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction\n * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions\n * @param args.options optional. GenerateTransactionOptions type\n *\n * @example\n * For a single signer entry function\n * move function name, move function type arguments, move function arguments\n * `\n * data: {\n *  function:\"0x1::aptos_account::transfer\",\n *  typeArguments:[]\n *  functionArguments :[receiverAddress,10]\n * }\n * `\n *\n * @example\n * For a single signer script function\n * module bytecode, move function type arguments, move function arguments\n * ```\n * data: {\n *  bytecode:\"0x001234567\",\n *  typeArguments:[],\n *  functionArguments :[receiverAddress,10]\n * }\n * ```\n *\n * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses\n * ```\n * {\n *  rawTransaction: RawTransaction,\n *  secondarySignerAddresses?: Array<AccountAddress>,\n *  feePayerAddress?: AccountAddress\n * }\n * ```\n * @group Implementation\n */\nexport async function generateTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n): Promise<AnyRawTransaction> {\n  const payload = await buildTransactionPayload(args);\n  return buildRawTransaction(args, payload);\n}\n\n/**\n * Builds a transaction payload based on the provided configuration and input data.\n * This function is essential for preparing transaction data for execution on the Aptos blockchain.\n *\n * @param args - The arguments for building the transaction payload.\n * @param args.aptosConfig - Configuration settings for the Aptos network.\n * @param args.data - Input data required to generate the transaction payload, which may include bytecode, multisig address,\n * function name, function arguments, type arguments, and ABI.\n * @returns A promise that resolves to the generated transaction payload instance.\n * @group Implementation\n */\nexport async function buildTransactionPayload(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n): Promise<AnyTransactionPayloadInstance> {\n  const { aptosConfig, data } = args;\n  // Merge in aptosConfig for remote ABI on non-script payloads\n  let generateTransactionPayloadData: InputGenerateTransactionPayloadDataWithRemoteABI;\n  let payload: AnyTransactionPayloadInstance;\n\n  if (\"bytecode\" in data) {\n    // TODO: Add ABI checking later\n    payload = await generateTransactionPayload(data);\n  } else if (\"multisigAddress\" in data) {\n    generateTransactionPayloadData = {\n      aptosConfig,\n      multisigAddress: data.multisigAddress,\n      function: data.function,\n      functionArguments: data.functionArguments,\n      typeArguments: data.typeArguments,\n      abi: data.abi,\n    };\n    payload = await generateTransactionPayload(generateTransactionPayloadData);\n  } else {\n    generateTransactionPayloadData = {\n      aptosConfig,\n      function: data.function,\n      functionArguments: data.functionArguments,\n      typeArguments: data.typeArguments,\n      abi: data.abi,\n    };\n    payload = await generateTransactionPayload(generateTransactionPayloadData);\n  }\n  return payload;\n}\n\n/**\n * Builds a raw transaction based on the provided configuration and payload.\n * This function helps in creating a transaction that can be sent to the Aptos blockchain.\n *\n * @param args - The arguments for generating the transaction.\n * @param args.aptosConfig - The configuration settings for Aptos.\n * @param args.sender - The address of the sender of the transaction.\n * @param args.options - Additional options for the transaction.\n * @param payload - The payload of the transaction, which defines the action to be performed.\n * @group Implementation\n */\nexport async function buildRawTransaction(\n  args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,\n  payload: AnyTransactionPayloadInstance,\n): Promise<AnyRawTransaction> {\n  const { aptosConfig, sender, options } = args;\n\n  let feePayerAddress;\n  if (isFeePayerTransactionInput(args)) {\n    feePayerAddress = AccountAddress.ZERO.toString();\n  }\n\n  if (isMultiAgentTransactionInput(args)) {\n    const { secondarySignerAddresses } = args;\n    return buildTransaction({\n      aptosConfig,\n      sender,\n      payload,\n      options,\n      secondarySignerAddresses,\n      feePayerAddress,\n    });\n  }\n\n  return buildTransaction({\n    aptosConfig,\n    sender,\n    payload,\n    options,\n    feePayerAddress,\n  });\n}\n\n/**\n * Determine if the transaction input includes a fee payer.\n *\n * @param data - The input data for generating a transaction.\n * @param data.withFeePayer - Indicates whether a fee payer is included in the transaction input.\n * @returns A boolean value indicating if the transaction input has a fee payer.\n * @group Implementation\n */\nfunction isFeePayerTransactionInput(data: InputGenerateTransactionData): boolean {\n  return data.withFeePayer === true;\n}\n\n/**\n * Determines whether the provided transaction input data includes multiple agent signatures.\n *\n * @param data - The transaction input data to evaluate.\n * @param data.secondarySignerAddresses - An array of secondary signer addresses, indicating multiple agents.\n * @group Implementation\n */\nfunction isMultiAgentTransactionInput(\n  data: InputGenerateTransactionData,\n): data is InputGenerateMultiAgentRawTransactionData {\n  return \"secondarySignerAddresses\" in data;\n}\n\n/**\n * Builds a signing message that can be signed by external signers.\n *\n * Note: Please prefer using `signTransaction` unless signing outside the SDK.\n *\n * @param args - The arguments for generating the signing message.\n * @param args.transaction - AnyRawTransaction, as generated by `generateTransaction()`.\n *\n * @returns The message to be signed.\n * @group Implementation\n */\nexport function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {\n  const { transaction } = args;\n  return generateSigningMessageForTransaction(transaction);\n}\n\n/**\n * Sign a transaction that can later be submitted to the chain.\n *\n * @param args The arguments for signing the transaction.\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 * @return The signer AccountAuthenticator.\n * @group Implementation\n */\nexport function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n  const { signer, transaction } = args;\n  return signer.signTransactionWithAuthenticator(transaction);\n}\n\nexport function signAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {\n  const { signer, transaction } = args;\n\n  // if transaction doesn't hold a \"feePayerAddress\" prop it means\n  // this is not a fee payer transaction\n  if (!transaction.feePayerAddress) {\n    throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);\n  }\n\n  // Set the feePayerAddress to the signer account address\n  transaction.feePayerAddress = signer.accountAddress;\n\n  return signTransaction({\n    signer,\n    transaction,\n  });\n}\n\n/**\n * Simulates a transaction before signing it to evaluate its potential outcome.\n *\n * @param args The arguments for simulating the transaction.\n * @param args.aptosConfig The configuration for the Aptos network.\n * @param args.transaction The raw transaction to simulate.\n * @param args.signerPublicKey Optional. The signer public key.\n * @param args.secondarySignersPublicKeys Optional. For when the transaction involves multiple signers.\n * @param args.feePayerPublicKey Optional. For when the transaction is sponsored by a fee payer.\n * @param args.options Optional. A configuration object to customize the simulation process.\n * @param args.options.estimateGasUnitPrice Optional. Indicates whether to estimate the gas unit price.\n * @param args.options.estimateMaxGasAmount Optional. Indicates whether to estimate the maximum gas amount.\n * @param args.options.estimatePrioritizedGasUnitPrice Optional. Indicates whether to estimate the prioritized gas unit price.\n * @group Implementation\n */\nexport async function simulateTransaction(\n  args: { aptosConfig: AptosConfig } & InputSimulateTransactionData,\n): Promise<Array<UserTransactionResponse>> {\n  const { aptosConfig, transaction, signerPublicKey, secondarySignersPublicKeys, feePayerPublicKey, options } = args;\n\n  const signedTransaction = generateSignedTransactionForSimulation({\n    transaction,\n    signerPublicKey,\n    secondarySignersPublicKeys,\n    feePayerPublicKey,\n    options,\n  });\n\n  const { data } = await postAptosFullNode<Uint8Array, Array<UserTransactionResponse>>({\n    aptosConfig,\n    body: signedTransaction,\n    path: \"transactions/simulate\",\n    params: {\n      estimate_gas_unit_price: args.options?.estimateGasUnitPrice ?? false,\n      estimate_max_gas_amount: args.options?.estimateMaxGasAmount ?? false,\n      estimate_prioritized_gas_unit_price: args.options?.estimatePrioritizedGasUnitPrice ?? false,\n    },\n    originMethod: \"simulateTransaction\",\n    contentType: MimeType.BCS_SIGNED_TRANSACTION,\n  });\n  return data;\n}\n\n/**\n * Submit a transaction to the Aptos blockchain.\n *\n * @param args - The arguments for submitting the transaction.\n * @param args.aptosConfig - The configuration for connecting to the Aptos network.\n * @param args.transaction - The Aptos transaction data to be submitted.\n * @param args.senderAuthenticator - The account authenticator of the transaction sender.\n * @param args.secondarySignerAuthenticators - Optional. Authenticators for additional signers in a multi-signer transaction.\n *\n * @returns PendingTransactionResponse - The response containing the status of the submitted transaction.\n * @group Implementation\n */\nexport async function submitTransaction(\n  args: {\n    aptosConfig: AptosConfig;\n  } & InputSubmitTransactionData,\n): Promise<PendingTransactionResponse> {\n  const { aptosConfig } = args;\n  const signedTransaction = generateSignedTransaction({ ...args });\n  try {\n    const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({\n      aptosConfig,\n      body: signedTransaction,\n      path: \"transactions\",\n      originMethod: \"submitTransaction\",\n      contentType: MimeType.BCS_SIGNED_TRANSACTION,\n    });\n    return data;\n  } catch (e) {\n    const signedTxn = SignedTransaction.deserialize(new Deserializer(signedTransaction));\n    if (\n      signedTxn.authenticator.isSingleSender() &&\n      signedTxn.authenticator.sender.isSingleKey() &&\n      (signedTxn.authenticator.sender.public_key.publicKey instanceof KeylessPublicKey ||\n        signedTxn.authenticator.sender.public_key.publicKey instanceof FederatedKeylessPublicKey)\n    ) {\n      await AbstractKeylessAccount.fetchJWK({\n        aptosConfig,\n        publicKey: signedTxn.authenticator.sender.public_key.publicKey,\n        kid: (signedTxn.authenticator.sender.signature.signature as KeylessSignature).getJwkKid(),\n      });\n    }\n    throw e;\n  }\n}\n\nexport type FeePayerOrFeePayerAuthenticatorOrNeither =\n  | { feePayer: Account; feePayerAuthenticator?: never }\n  | { feePayer?: never; feePayerAuthenticator: AccountAuthenticator }\n  | { feePayer?: never; feePayerAuthenticator?: never };\n\nexport async function signAndSubmitTransaction(\n  args: FeePayerOrFeePayerAuthenticatorOrNeither & {\n    aptosConfig: AptosConfig;\n    signer: Account;\n    transaction: AnyRawTransaction;\n  },\n): Promise<PendingTransactionResponse> {\n  const { aptosConfig, signer, feePayer, transaction } = args;\n  // If the signer contains a KeylessAccount, await proof fetching in case the proof\n  // was fetched asynchronously.\n  if (isKeylessSigner(signer)) {\n    await signer.checkKeylessAccountValidity(aptosConfig);\n  }\n  if (isKeylessSigner(feePayer)) {\n    await feePayer.checkKeylessAccountValidity(aptosConfig);\n  }\n  const feePayerAuthenticator =\n    args.feePayerAuthenticator || (feePayer && signAsFeePayer({ signer: feePayer, transaction }));\n\n  const senderAuthenticator = signTransaction({ signer, transaction });\n  return submitTransaction({\n    aptosConfig,\n    transaction,\n    senderAuthenticator,\n    feePayerAuthenticator,\n  });\n}\n\nexport async function signAndSubmitAsFeePayer(args: {\n  aptosConfig: AptosConfig;\n  feePayer: Account;\n  senderAuthenticator: AccountAuthenticator;\n  transaction: AnyRawTransaction;\n}): Promise<PendingTransactionResponse> {\n  const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;\n\n  if (isKeylessSigner(feePayer)) {\n    await feePayer.checkKeylessAccountValidity(aptosConfig);\n  }\n\n  const feePayerAuthenticator = signAsFeePayer({ signer: feePayer, transaction });\n\n  return submitTransaction({\n    aptosConfig,\n    transaction,\n    senderAuthenticator,\n    feePayerAuthenticator,\n  });\n}\n\nconst packagePublishAbi: EntryFunctionABI = {\n  typeParameters: [],\n  parameters: [TypeTagVector.u8(), new TypeTagVector(TypeTagVector.u8())],\n};\n\n/**\n * Publishes a package transaction to the Aptos blockchain.\n * This function allows you to create and send a transaction that publishes a package with the specified metadata and bytecode.\n *\n * @param args - The arguments for the package transaction.\n * @param args.aptosConfig - The configuration settings for the Aptos client.\n * @param args.account - The address of the account sending the transaction.\n * @param args.metadataBytes - The metadata associated with the package, represented as hexadecimal input.\n * @param args.moduleBytecode - An array of module bytecode, each represented as hexadecimal input.\n * @param args.options - Optional parameters for generating the transaction.\n * @group Implementation\n */\nexport async function publicPackageTransaction(args: {\n  aptosConfig: AptosConfig;\n  account: AccountAddressInput;\n  metadataBytes: HexInput;\n  moduleBytecode: Array<HexInput>;\n  options?: InputGenerateTransactionOptions;\n}): Promise<SimpleTransaction> {\n  const { aptosConfig, account, metadataBytes, moduleBytecode, options } = args;\n\n  const totalByteCode = moduleBytecode.map((bytecode) => MoveVector.U8(bytecode));\n\n  return generateTransaction({\n    aptosConfig,\n    sender: AccountAddress.from(account),\n    data: {\n      function: \"0x1::code::publish_package_txn\",\n      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],\n      abi: packagePublishAbi,\n    },\n    options,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,eAAsB,oBACpB,MAC4B;AAC5B,QAAM,UAAU,MAAM,wBAAwB,IAAI;AAClD,SAAO,oBAAoB,MAAM,OAAO;AAC1C;AAaA,eAAsB,wBACpB,MACwC;AACxC,QAAM,EAAE,aAAa,KAAK,IAAI;AAE9B,MAAI;AACJ,MAAI;AAEJ,MAAI,cAAc,MAAM;AAEtB,cAAU,MAAM,2BAA2B,IAAI;AAAA,EACjD,WAAW,qBAAqB,MAAM;AACpC,qCAAiC;AAAA,MAC/B;AAAA,MACA,iBAAiB,KAAK;AAAA,MACtB,UAAU,KAAK;AAAA,MACf,mBAAmB,KAAK;AAAA,MACxB,eAAe,KAAK;AAAA,MACpB,KAAK,KAAK;AAAA,IACZ;AACA,cAAU,MAAM,2BAA2B,8BAA8B;AAAA,EAC3E,OAAO;AACL,qCAAiC;AAAA,MAC/B;AAAA,MACA,UAAU,KAAK;AAAA,MACf,mBAAmB,KAAK;AAAA,MACxB,eAAe,KAAK;AAAA,MACpB,KAAK,KAAK;AAAA,IACZ;AACA,cAAU,MAAM,2BAA2B,8BAA8B;AAAA,EAC3E;AACA,SAAO;AACT;AAaA,eAAsB,oBACpB,MACA,SAC4B;AAC5B,QAAM,EAAE,aAAa,QAAQ,QAAQ,IAAI;AAEzC,MAAI;AACJ,MAAI,2BAA2B,IAAI,GAAG;AACpC,sBAAkB,eAAe,KAAK,SAAS;AAAA,EACjD;AAEA,MAAI,6BAA6B,IAAI,GAAG;AACtC,UAAM,EAAE,yBAAyB,IAAI;AACrC,WAAO,iBAAiB;AAAA,MACtB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO,iBAAiB;AAAA,IACtB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAUA,SAAS,2BAA2B,MAA6C;AAC/E,SAAO,KAAK,iBAAiB;AAC/B;AASA,SAAS,6BACP,MACmD;AACnD,SAAO,8BAA8B;AACvC;AAaO,SAAS,kBAAkB,MAAsD;AACtF,QAAM,EAAE,YAAY,IAAI;AACxB,SAAO,qCAAqC,WAAW;AACzD;AAYO,SAAS,gBAAgB,MAAiF;AAC/G,QAAM,EAAE,QAAQ,YAAY,IAAI;AAChC,SAAO,OAAO,iCAAiC,WAAW;AAC5D;AAEO,SAAS,eAAe,MAAiF;AAC9G,QAAM,EAAE,QAAQ,YAAY,IAAI;AAIhC,MAAI,CAAC,YAAY,iBAAiB;AAChC,UAAM,IAAI,MAAM,eAAe,WAAW,iCAAiC;AAAA,EAC7E;AAGA,cAAY,kBAAkB,OAAO;AAErC,SAAO,gBAAgB;AAAA,IACrB;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAiBA,eAAsB,oBACpB,MACyC;AACzC,QAAM,EAAE,aAAa,aAAa,iBAAiB,4BAA4B,mBAAmB,QAAQ,IAAI;AAE9G,QAAM,oBAAoB,uCAAuC;AAAA,IAC/D;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,EAAE,KAAK,IAAI,MAAM,kBAA8D;AAAA,IACnF;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,IACN,QAAQ;AAAA,MACN,yBAAyB,KAAK,SAAS,wBAAwB;AAAA,MAC/D,yBAAyB,KAAK,SAAS,wBAAwB;AAAA,MAC/D,qCAAqC,KAAK,SAAS,mCAAmC;AAAA,IACxF;AAAA,IACA,cAAc;AAAA,IACd;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAcA,eAAsB,kBACpB,MAGqC;AACrC,QAAM,EAAE,YAAY,IAAI;AACxB,QAAM,oBAAoB,0BAA0B,EAAE,GAAG,KAAK,CAAC;AAC/D,MAAI;AACF,UAAM,EAAE,KAAK,IAAI,MAAM,kBAA0D;AAAA,MAC/E;AAAA,MACA,MAAM;AAAA,MACN,MAAM;AAAA,MACN,cAAc;AAAA,MACd;AAAA,IACF,CAAC;AACD,WAAO;AAAA,EACT,SAAS,GAAG;AACV,UAAM,YAAY,kBAAkB,YAAY,IAAI,aAAa,iBAAiB,CAAC;AACnF,QACE,UAAU,cAAc,eAAe,KACvC,UAAU,cAAc,OAAO,YAAY,MAC1C,UAAU,cAAc,OAAO,WAAW,qBAAqB,oBAC9D,UAAU,cAAc,OAAO,WAAW,qBAAqB,4BACjE;AACA,YAAM,uBAAuB,SAAS;AAAA,QACpC;AAAA,QACA,WAAW,UAAU,cAAc,OAAO,WAAW;AAAA,QACrD,KAAM,UAAU,cAAc,OAAO,UAAU,UAA+B,UAAU;AAAA,MAC1F,CAAC;AAAA,IACH;AACA,UAAM;AAAA,EACR;AACF;AAOA,eAAsB,yBACpB,MAKqC;AACrC,QAAM,EAAE,aAAa,QAAQ,UAAU,YAAY,IAAI;AAGvD,MAAI,gBAAgB,MAAM,GAAG;AAC3B,UAAM,OAAO,4BAA4B,WAAW;AAAA,EACtD;AACA,MAAI,gBAAgB,QAAQ,GAAG;AAC7B,UAAM,SAAS,4BAA4B,WAAW;AAAA,EACxD;AACA,QAAM,wBACJ,KAAK,yBAA0B,YAAY,eAAe,EAAE,QAAQ,UAAU,YAAY,CAAC;AAE7F,QAAM,sBAAsB,gBAAgB,EAAE,QAAQ,YAAY,CAAC;AACnE,SAAO,kBAAkB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAEA,eAAsB,wBAAwB,MAKN;AACtC,QAAM,EAAE,aAAa,qBAAqB,UAAU,YAAY,IAAI;AAEpE,MAAI,gBAAgB,QAAQ,GAAG;AAC7B,UAAM,SAAS,4BAA4B,WAAW;AAAA,EACxD;AAEA,QAAM,wBAAwB,eAAe,EAAE,QAAQ,UAAU,YAAY,CAAC;AAE9E,SAAO,kBAAkB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;AAEA,IAAM,oBAAsC;AAAA,EAC1C,gBAAgB,CAAC;AAAA,EACjB,YAAY,CAAC,cAAc,GAAG,GAAG,IAAI,cAAc,cAAc,GAAG,CAAC,CAAC;AACxE;AAcA,eAAsB,yBAAyB,MAMhB;AAC7B,QAAM,EAAE,aAAa,SAAS,eAAe,gBAAgB,QAAQ,IAAI;AAEzE,QAAM,gBAAgB,eAAe,IAAI,CAAC,aAAa,WAAW,GAAG,QAAQ,CAAC;AAE9E,SAAO,oBAAoB;AAAA,IACzB;AAAA,IACA,QAAQ,eAAe,KAAK,OAAO;AAAA,IACnC,MAAM;AAAA,MACJ,UAAU;AAAA,MACV,mBAAmB,CAAC,WAAW,GAAG,aAAa,GAAG,IAAI,WAAW,aAAa,CAAC;AAAA,MAC/E,KAAK;AAAA,IACP;AAAA,IACA;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/esm/chunk-HL337SEM.mjs

@@ -1,219 +0,0 @@
-import {
-  addAuthenticationFunctionTransaction,
-  removeAuthenticationFunctionTransaction,
-  removeDispatchableAuthenticatorTransaction
-} from "./chunk-TL4Z4KHK.mjs";
-import {
-  view
-} from "./chunk-ORCQEMJL.mjs";
-import {
-  TypeTagAddress
-} from "./chunk-DDZGHA66.mjs";
-import {
-  getFunctionParts
-} from "./chunk-RQS33JAS.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-
-// src/api/account/abstraction.ts
-var AccountAbstraction = class {
-  constructor(config) {
-    this.config = config;
-    /**
-     * Will return true if the account is abstracted, otherwise false.
-     *
-     * @example
-     * ```ts
-     * const isAccountAbstractionEnabled = await aptos.abstraction.isAccountAbstractionEnabled({
-     *   accountAddress: alice.accountAddress,
-     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
-     * });
-     * if (isAccountAbstractionEnabled) {
-     *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
-     * } else {
-     *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
-     * }
-     * ```
-     *
-     * @param args.accountAddress - The account to check.
-     * @returns Whether the account is abstracted.
-     */
-    this.isAccountAbstractionEnabled = async (args) => {
-      const functionInfos = await this.getAuthenticationFunction(args);
-      const { moduleAddress, moduleName, functionName } = getFunctionParts(args.authenticationFunction);
-      return functionInfos?.some(
-        (functionInfo) => AccountAddress.fromString(moduleAddress).equals(functionInfo.moduleAddress) && moduleName === functionInfo.moduleName && functionName === functionInfo.functionName
-      ) ?? false;
-    };
-    /**
-     * Creates a transaction to enable account abstraction with the given authentication function.
-     *
-     * @example
-     * ```ts
-     * const txn = await aptos.abstraction.enableAccountAbstractionTransaction({
-     *   accountAddress: alice.accountAddress,
-     *   authenticationFunction: `{alice.accountAddress}::any_authenticator::authenticate`,
-     * });
-     *
-     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
-     * await aptos.waitForTransaction({ transactionHash: txn.hash });
-     * ```
-     *
-     * @param args.accountAddress - The account to enable account abstraction for.
-     * @param args.authenticationFunction - The authentication function info to use.
-     * @param args.options - The options for the transaction.
-     * @returns A transaction to enable account abstraction for the account.
-     */
-    this.enableAccountAbstractionTransaction = this.addAuthenticationFunctionTransaction;
-    /**
-     * Creates a transaction to disable account abstraction. If an authentication function is provided, it will specify to
-     * remove the authentication function.
-     *
-     * @example
-     * ```ts
-     * const txn = await aptos.abstraction.disableAccountAbstractionTransaction({
-     *   accountAddress: alice.accountAddress,
-     *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
-     * });
-     *
-     * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
-     * await aptos.waitForTransaction({ transactionHash: txn.hash });
-     * ```
-     *
-     * @param args.accountAddress - The account to disable account abstraction for.
-     * @param args.authenticationFunction - The authentication function info to remove.
-     * @param args.options - The options for the transaction.
-     * @returns A transaction to disable account abstraction for the account.
-     */
-    this.disableAccountAbstractionTransaction = async (args) => {
-      const { accountAddress, authenticationFunction, options } = args;
-      if (authenticationFunction) {
-        return this.removeAuthenticationFunctionTransaction({
-          accountAddress,
-          authenticationFunction,
-          options
-        });
-      }
-      return this.removeDispatchableAuthenticatorTransaction({ accountAddress, options });
-    };
-  }
-  /**
-   * Adds a dispatchable authentication function to the account.
-   *
-   * @example
-   * ```ts
-   * const txn = await aptos.abstraction.addAuthenticationFunctionTransaction({
-   *   accountAddress: alice.accountAddress,
-   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
-   * });
-   *
-   * const txn =  await aptos.signAndSubmitTransaction({ signer: alice, transaction});
-   * await aptos.waitForTransaction({ transactionHash: txn.hash });
-   * ```
-   *
-   * @param args.accountAddress - The account to add the authentication function to.
-   * @param args.authenticationFunction - The authentication function info to add.
-   * @param args.options - The options for the transaction.
-   * @returns A transaction to add the authentication function to the account.
-   */
-  async addAuthenticationFunctionTransaction(args) {
-    const { accountAddress, authenticationFunction, options } = args;
-    return addAuthenticationFunctionTransaction({
-      aptosConfig: this.config,
-      authenticationFunction,
-      sender: accountAddress,
-      options
-    });
-  }
-  /**
-   * Removes a dispatchable authentication function from the account.
-   *
-   * @example
-   * ```ts
-   * const txn = await aptos.abstraction.removeAuthenticationFunctionTransaction({
-   *   accountAddress: alice.accountAddress,
-   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
-   * });
-   *
-   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
-   * await aptos.waitForTransaction({ transactionHash: txn.hash });
-   * ```
-   *
-   * @param args.accountAddress - The account to remove the authentication function from.
-   * @param args.authenticationFunction - The authentication function info to remove.
-   * @param args.options - The options for the transaction.
-   * @returns A transaction to remove the authentication function from the account.
-   */
-  async removeAuthenticationFunctionTransaction(args) {
-    const { accountAddress, authenticationFunction, options } = args;
-    return removeAuthenticationFunctionTransaction({
-      aptosConfig: this.config,
-      sender: accountAddress,
-      authenticationFunction,
-      options
-    });
-  }
-  /**
-   * Removes a dispatchable authenticator from the account.
-   *
-   * @example
-   * ```ts
-   * const txn = await aptos.abstraction.removeDispatchableAuthenticatorTransaction({
-   *   accountAddress: alice.accountAddress,
-   * });
-   *
-   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
-   * await aptos.waitForTransaction({ transactionHash: txn.hash });
-   * ```
-   *
-   * @param args.accountAddress - The account to remove the authenticator from.
-   * @param args.options - The options for the transaction.
-   * @returns A transaction to remove the authenticator from the account.
-   */
-  async removeDispatchableAuthenticatorTransaction(args) {
-    const { accountAddress, options } = args;
-    return removeDispatchableAuthenticatorTransaction({ aptosConfig: this.config, sender: accountAddress, options });
-  }
-  /**
-   * Gets the dispatchable authentication function for the account.
-   *
-   * @example
-   * ```ts
-   * const functionInfos = await aptos.abstraction.getAuthenticationFunction({
-   *   accountAddress: alice.accountAddress,
-   * });
-   *
-   * if (functionInfos) {
-   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
-   * } else {
-   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
-   * }
-   * ```
-   *
-   * @param args.accountAddress - The account to get the dispatchable authentication function for.
-   * @returns The dispatchable authentication function for the account.
-   */
-  async getAuthenticationFunction(args) {
-    const { accountAddress } = args;
-    const [{ vec: functionInfoOption }] = await view({
-      aptosConfig: this.config,
-      payload: {
-        function: "0x1::account_abstraction::dispatchable_authenticator",
-        functionArguments: [AccountAddress.from(accountAddress)],
-        abi: { typeParameters: [], parameters: [new TypeTagAddress()], returnTypes: [] }
-      }
-    });
-    if (functionInfoOption.length === 0) return void 0;
-    return functionInfoOption[0].map((functionInfo) => ({
-      moduleAddress: AccountAddress.fromString(functionInfo.module_address),
-      moduleName: functionInfo.module_name,
-      functionName: functionInfo.function_name
-    }));
-  }
-};
-
-export {
-  AccountAbstraction
-};
-//# sourceMappingURL=chunk-HL337SEM.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/account/abstraction.ts"],"sourcesContent":["import { AccountAddress, AccountAddressInput } from \"../../core\";\nimport {\n  addAuthenticationFunctionTransaction,\n  removeAuthenticationFunctionTransaction,\n  removeDispatchableAuthenticatorTransaction,\n} from \"../../internal/abstraction\";\nimport { view } from \"../../internal/view\";\nimport { InputGenerateTransactionOptions, TypeTagAddress } from \"../../transactions\";\nimport { MoveFunctionId } from \"../../types\";\nimport { getFunctionParts } from \"../../utils/helpers\";\nimport { AptosConfig } from \"../aptosConfig\";\n\nexport class AccountAbstraction {\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Adds a dispatchable authentication function to the account.\n   *\n   * @example\n   * ```ts\n   * const txn = await aptos.abstraction.addAuthenticationFunctionTransaction({\n   *   accountAddress: alice.accountAddress,\n   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,\n   * });\n   *\n   * const txn =  await aptos.signAndSubmitTransaction({ signer: alice, transaction});\n   * await aptos.waitForTransaction({ transactionHash: txn.hash });\n   * ```\n   *\n   * @param args.accountAddress - The account to add the authentication function to.\n   * @param args.authenticationFunction - The authentication function info to add.\n   * @param args.options - The options for the transaction.\n   * @returns A transaction to add the authentication function to the account.\n   */\n  public async addAuthenticationFunctionTransaction(args: {\n    accountAddress: AccountAddressInput;\n    authenticationFunction: string;\n    options?: InputGenerateTransactionOptions;\n  }) {\n    const { accountAddress, authenticationFunction, options } = args;\n    return addAuthenticationFunctionTransaction({\n      aptosConfig: this.config,\n      authenticationFunction,\n      sender: accountAddress,\n      options,\n    });\n  }\n\n  /**\n   * Removes a dispatchable authentication function from the account.\n   *\n   * @example\n   * ```ts\n   * const txn = await aptos.abstraction.removeAuthenticationFunctionTransaction({\n   *   accountAddress: alice.accountAddress,\n   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,\n   * });\n   *\n   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });\n   * await aptos.waitForTransaction({ transactionHash: txn.hash });\n   * ```\n   *\n   * @param args.accountAddress - The account to remove the authentication function from.\n   * @param args.authenticationFunction - The authentication function info to remove.\n   * @param args.options - The options for the transaction.\n   * @returns A transaction to remove the authentication function from the account.\n   */\n  public async removeAuthenticationFunctionTransaction(args: {\n    accountAddress: AccountAddressInput;\n    authenticationFunction: string;\n    options?: InputGenerateTransactionOptions;\n  }) {\n    const { accountAddress, authenticationFunction, options } = args;\n    return removeAuthenticationFunctionTransaction({\n      aptosConfig: this.config,\n      sender: accountAddress,\n      authenticationFunction,\n      options,\n    });\n  }\n\n  /**\n   * Removes a dispatchable authenticator from the account.\n   *\n   * @example\n   * ```ts\n   * const txn = await aptos.abstraction.removeDispatchableAuthenticatorTransaction({\n   *   accountAddress: alice.accountAddress,\n   * });\n   *\n   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });\n   * await aptos.waitForTransaction({ transactionHash: txn.hash });\n   * ```\n   *\n   * @param args.accountAddress - The account to remove the authenticator from.\n   * @param args.options - The options for the transaction.\n   * @returns A transaction to remove the authenticator from the account.\n   */\n  public async removeDispatchableAuthenticatorTransaction(args: {\n    accountAddress: AccountAddressInput;\n    options?: InputGenerateTransactionOptions;\n  }) {\n    const { accountAddress, options } = args;\n    return removeDispatchableAuthenticatorTransaction({ aptosConfig: this.config, sender: accountAddress, options });\n  }\n\n  /**\n   * Gets the dispatchable authentication function for the account.\n   *\n   * @example\n   * ```ts\n   * const functionInfos = await aptos.abstraction.getAuthenticationFunction({\n   *   accountAddress: alice.accountAddress,\n   * });\n   *\n   * if (functionInfos) {\n   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);\n   * } else {\n   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);\n   * }\n   * ```\n   *\n   * @param args.accountAddress - The account to get the dispatchable authentication function for.\n   * @returns The dispatchable authentication function for the account.\n   */\n  public async getAuthenticationFunction(args: { accountAddress: AccountAddressInput }) {\n    const { accountAddress } = args;\n    const [{ vec: functionInfoOption }] = await view<\n      [{ vec: { function_name: string; module_name: string; module_address: string }[][] }]\n    >({\n      aptosConfig: this.config,\n      payload: {\n        function: \"0x1::account_abstraction::dispatchable_authenticator\",\n        functionArguments: [AccountAddress.from(accountAddress)],\n        abi: { typeParameters: [], parameters: [new TypeTagAddress()], returnTypes: [] },\n      },\n    });\n\n    if (functionInfoOption.length === 0) return undefined;\n\n    return functionInfoOption[0].map((functionInfo) => ({\n      moduleAddress: AccountAddress.fromString(functionInfo.module_address),\n      moduleName: functionInfo.module_name,\n      functionName: functionInfo.function_name,\n    }));\n  }\n\n  /**\n   * Will return true if the account is abstracted, otherwise false.\n   *\n   * @example\n   * ```ts\n   * const isAccountAbstractionEnabled = await aptos.abstraction.isAccountAbstractionEnabled({\n   *   accountAddress: alice.accountAddress,\n   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,\n   * });\n   * if (isAccountAbstractionEnabled) {\n   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);\n   * } else {\n   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);\n   * }\n   * ```\n   *\n   * @param args.accountAddress - The account to check.\n   * @returns Whether the account is abstracted.\n   */\n  public isAccountAbstractionEnabled = async (args: {\n    accountAddress: AccountAddressInput;\n    authenticationFunction: string;\n  }) => {\n    const functionInfos = await this.getAuthenticationFunction(args);\n    const { moduleAddress, moduleName, functionName } = getFunctionParts(args.authenticationFunction as MoveFunctionId);\n    return (\n      functionInfos?.some(\n        (functionInfo) =>\n          AccountAddress.fromString(moduleAddress).equals(functionInfo.moduleAddress) &&\n          moduleName === functionInfo.moduleName &&\n          functionName === functionInfo.functionName,\n      ) ?? false\n    );\n  };\n\n  /**\n   * Creates a transaction to enable account abstraction with the given authentication function.\n   *\n   * @example\n   * ```ts\n   * const txn = await aptos.abstraction.enableAccountAbstractionTransaction({\n   *   accountAddress: alice.accountAddress,\n   *   authenticationFunction: `{alice.accountAddress}::any_authenticator::authenticate`,\n   * });\n   *\n   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });\n   * await aptos.waitForTransaction({ transactionHash: txn.hash });\n   * ```\n   *\n   * @param args.accountAddress - The account to enable account abstraction for.\n   * @param args.authenticationFunction - The authentication function info to use.\n   * @param args.options - The options for the transaction.\n   * @returns A transaction to enable account abstraction for the account.\n   */\n  public enableAccountAbstractionTransaction = this.addAuthenticationFunctionTransaction;\n\n  /**\n   * Creates a transaction to disable account abstraction. If an authentication function is provided, it will specify to\n   * remove the authentication function.\n   *\n   * @example\n   * ```ts\n   * const txn = await aptos.abstraction.disableAccountAbstractionTransaction({\n   *   accountAddress: alice.accountAddress,\n   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,\n   * });\n   *\n   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });\n   * await aptos.waitForTransaction({ transactionHash: txn.hash });\n   * ```\n   *\n   * @param args.accountAddress - The account to disable account abstraction for.\n   * @param args.authenticationFunction - The authentication function info to remove.\n   * @param args.options - The options for the transaction.\n   * @returns A transaction to disable account abstraction for the account.\n   */\n  public disableAccountAbstractionTransaction = async (args: {\n    accountAddress: AccountAddressInput;\n    authenticationFunction?: string;\n    options?: InputGenerateTransactionOptions;\n  }) => {\n    const { accountAddress, authenticationFunction, options } = args;\n    if (authenticationFunction) {\n      return this.removeAuthenticationFunctionTransaction({\n        accountAddress,\n        authenticationFunction,\n        options,\n      });\n    }\n    return this.removeDispatchableAuthenticatorTransaction({ accountAddress, options });\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/esm/chunk-HQDHSKVS.mjs

@@ -1,74 +0,0 @@
-import {
-  transferCoinTransaction
-} from "./chunk-ZRBUAZZD.mjs";
-
-// src/api/coin.ts
-var Coin = class {
-  /**
-   * Initializes a new instance of the Aptos client with the specified configuration.
-   * This allows you to interact with the Aptos blockchain using the provided settings.
-   *
-   * @param config - The configuration settings for the Aptos client.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * async function runExample() {
-   *     // Create a new Aptos client with testnet configuration
-   *     const config = new AptosConfig({ network: Network.TESTNET });
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Coin
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Generate a transfer coin transaction that can be simulated, signed, and submitted.
-   * This function helps you create a transaction to transfer a specified amount of coins
-   * from one account to another within the Aptos network.
-   *
-   * @param args The arguments for the transfer transaction.
-   * @param args.sender The sender account address.
-   * @param args.recipient The recipient account address.
-   * @param args.amount The amount of coins to transfer.
-   * @param args.coinType Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.
-   * @param args.options Optional. Additional options for generating the transaction.
-   *
-   * @returns SimpleTransaction
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Generate a transfer coin transaction
-   *   const transaction = await aptos.transferCoinTransaction({
-   *     sender: "0x1", // replace with a real sender account address
-   *     recipient: "0x2", // replace with a real recipient account address
-   *     amount: 10,
-   *   });
-   *
-   *   console.log(transaction);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Coin
-   */
-  async transferCoinTransaction(args) {
-    return transferCoinTransaction({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Coin
-};
-//# sourceMappingURL=chunk-HQDHSKVS.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/api/coin.ts"],"sourcesContent":["// Copyright © Aptos Foundation\n// SPDX-License-Identifier: Apache-2.0\n\nimport { AccountAddressInput } from \"../core\";\nimport { transferCoinTransaction } from \"../internal/coin\";\nimport { SimpleTransaction } from \"../transactions/instances/simpleTransaction\";\nimport { InputGenerateTransactionOptions } from \"../transactions/types\";\nimport { AnyNumber, MoveStructId } from \"../types\";\nimport { AptosConfig } from \"./aptosConfig\";\n\n/**\n * A class to handle all `Coin` operations.\n * @group Coin\n */\nexport class Coin {\n  /**\n   * Initializes a new instance of the Aptos client with the specified configuration.\n   * This allows you to interact with the Aptos blockchain using the provided settings.\n   *\n   * @param config - The configuration settings for the Aptos client.\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * async function runExample() {\n   *     // Create a new Aptos client with testnet configuration\n   *     const config = new AptosConfig({ network: Network.TESTNET });\n   *     const aptos = new Aptos(config);\n   *\n   *     console.log(\"Aptos client initialized:\", aptos);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Coin\n   */\n  constructor(readonly config: AptosConfig) {}\n\n  /**\n   * Generate a transfer coin transaction that can be simulated, signed, and submitted.\n   * This function helps you create a transaction to transfer a specified amount of coins\n   * from one account to another within the Aptos network.\n   *\n   * @param args The arguments for the transfer transaction.\n   * @param args.sender The sender account address.\n   * @param args.recipient The recipient account address.\n   * @param args.amount The amount of coins to transfer.\n   * @param args.coinType Optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin.\n   * @param args.options Optional. Additional options for generating the transaction.\n   *\n   * @returns SimpleTransaction\n   *\n   * @example\n   * ```typescript\n   * import { Aptos, AptosConfig, Network } from \"@aptos-labs/ts-sdk\";\n   *\n   * const config = new AptosConfig({ network: Network.TESTNET });\n   * const aptos = new Aptos(config);\n   *\n   * async function runExample() {\n   *   // Generate a transfer coin transaction\n   *   const transaction = await aptos.transferCoinTransaction({\n   *     sender: \"0x1\", // replace with a real sender account address\n   *     recipient: \"0x2\", // replace with a real recipient account address\n   *     amount: 10,\n   *   });\n   *\n   *   console.log(transaction);\n   * }\n   * runExample().catch(console.error);\n   * ```\n   * @group Coin\n   */\n  async transferCoinTransaction(args: {\n    sender: AccountAddressInput;\n    recipient: AccountAddressInput;\n    amount: AnyNumber;\n    coinType?: MoveStructId;\n    options?: InputGenerateTransactionOptions;\n  }): Promise<SimpleTransaction> {\n    return transferCoinTransaction({ aptosConfig: this.config, ...args });\n  }\n}\n"],"mappings":";;;;;AAcO,IAAM,OAAN,MAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBhB,YAAqB,QAAqB;AAArB;AAAA,EAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqC3C,MAAM,wBAAwB,MAMC;AAC7B,WAAO,wBAAwB,EAAE,aAAa,KAAK,QAAQ,GAAG,KAAK,CAAC;AAAA,EACtE;AACF;","names":[]}

package/dist/esm/chunk-I25AX6PQ.mjs

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