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

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":"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","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-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-I25AX6PQ.mjs

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

package/dist/esm/chunk-I5G7XFGT.mjs

@@ -1,86 +0,0 @@
-import {
-  fundAccount
-} from "./chunk-JAZJE3OR.mjs";
-import {
-  waitForIndexer
-} from "./chunk-BU43ZFDJ.mjs";
-
-// src/api/faucet.ts
-var Faucet = class {
-  /**
-   * Initializes a new instance of the Aptos client with the specified configuration.
-   *
-   * Note that only devnet has a publicly accessible faucet. For testnet, you must use
-   * the minting page at https://aptos.dev/network/faucet.
-   *
-   * @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 configuration for the Aptos client
-   *     const config = new AptosConfig({ network: Network.DEVNET }); // specify your own network if needed
-   *
-   *     // Initialize the Aptos client with the configuration
-   *     const aptos = new Aptos(config);
-   *
-   *     console.log("Aptos client initialized:", aptos);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Faucet
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * This function creates an account if it does not exist and mints the specified amount of coins into that account.
-   *
-   * Note that only devnet has a publicly accessible faucet. For testnet, you must use
-   * the minting page at https://aptos.dev/network/faucet.
-   *
-   * @param args - The arguments for funding the account.
-   * @param args.accountAddress - The address of the account to fund.
-   * @param args.amount - The amount of tokens to fund the account with.
-   * @param args.options - Configuration options for waiting for the transaction.
-   * @returns Transaction hash of the transaction that funded the account.
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.DEVNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Fund an account with a specified amount of tokens
-   *   const transaction = await aptos.fundAccount({
-   *     accountAddress: "0x1", // replace with your account address
-   *     amount: 100,
-   *   });
-   *
-   *   console.log("Transaction hash:", transaction.hash);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   * @group Faucet
-   */
-  async fundAccount(args) {
-    const fundTxn = await fundAccount({ aptosConfig: this.config, ...args });
-    if (args.options?.waitForIndexer === void 0 || args.options?.waitForIndexer) {
-      await waitForIndexer({
-        aptosConfig: this.config,
-        minimumLedgerVersion: BigInt(fundTxn.version),
-        processorType: "fungible_asset_processor" /* FUNGIBLE_ASSET_PROCESSOR */
-      });
-    }
-    return fundTxn;
-  }
-};
-
-export {
-  Faucet
-};
-//# sourceMappingURL=chunk-I5G7XFGT.mjs.map