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

package/dist/common/index.js

@@ -7417,9 +7417,9 @@ var MultiKeyAccount = class _MultiKeyAccount {
    * @category Account (On-Chain Model)
    */
   static fromPublicKeysAndSigners(args) {
-    const { publicKeys, signaturesRequired, signers } = args;
+    const { address, publicKeys, signaturesRequired, signers } = args;
     const multiKey = new MultiKey({ publicKeys, signaturesRequired });
-    return new _MultiKeyAccount({ multiKey, signers });
+    return new _MultiKeyAccount({ multiKey, signers, address });
   }
   /**
    * Determines if the provided account is a multi-key account.
@@ -8535,6 +8535,51 @@ async function getProcessorStatus(args) {
   return data.processor_status[0];
 }
 
+// src/internal/utils/utils.ts
+async function getModules(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor({
+    aptosConfig,
+    originMethod: "getModules",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: _optionalChain([options, 'optionalAccess', _63 => _63.ledgerVersion]),
+      offset: _optionalChain([options, 'optionalAccess', _64 => _64.offset]),
+      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _65 => _65.limit]), () => ( 1e3))
+    }
+  });
+}
+async function getInfo(args) {
+  const { aptosConfig, accountAddress } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    originMethod: "getInfo",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}`
+  });
+  return data;
+}
+async function getModule(args) {
+  if (_optionalChain([args, 'access', _66 => _66.options, 'optionalAccess', _67 => _67.ledgerVersion]) !== void 0) {
+    return getModuleInner(args);
+  }
+  return memoizeAsync(
+    async () => getModuleInner(args),
+    `module-${args.accountAddress}-${args.moduleName}`,
+    1e3 * 60 * 5
+    // 5 minutes
+  )();
+}
+async function getModuleInner(args) {
+  const { aptosConfig, accountAddress, moduleName, options } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    originMethod: "getModule",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
+    params: { ledger_version: _optionalChain([options, 'optionalAccess', _68 => _68.ledgerVersion]) }
+  });
+  return data;
+}
+
 // src/internal/table.ts
 async function getTableItem(args) {
   const { aptosConfig, handle, data, options } = args;
@@ -8542,7 +8587,7 @@ async function getTableItem(args) {
     aptosConfig,
     originMethod: "getTableItem",
     path: `tables/${handle}/item`,
-    params: { ledger_version: _optionalChain([options, 'optionalAccess', _63 => _63.ledgerVersion]) },
+    params: { ledger_version: _optionalChain([options, 'optionalAccess', _69 => _69.ledgerVersion]) },
     body: data
   });
   return response.data;
@@ -8552,10 +8597,10 @@ async function getTableItemsData(args) {
   const graphqlQuery = {
     query: GetTableItemsData,
     variables: {
-      where_condition: _optionalChain([options, 'optionalAccess', _64 => _64.where]),
-      offset: _optionalChain([options, 'optionalAccess', _65 => _65.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _66 => _66.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _67 => _67.orderBy])
+      where_condition: _optionalChain([options, 'optionalAccess', _70 => _70.where]),
+      offset: _optionalChain([options, 'optionalAccess', _71 => _71.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _72 => _72.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _73 => _73.orderBy])
     }
   };
   const data = await queryIndexer({
@@ -8570,10 +8615,10 @@ async function getTableItemsMetadata(args) {
   const graphqlQuery = {
     query: GetTableItemsMetadata,
     variables: {
-      where_condition: _optionalChain([options, 'optionalAccess', _68 => _68.where]),
-      offset: _optionalChain([options, 'optionalAccess', _69 => _69.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _70 => _70.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _71 => _71.orderBy])
+      where_condition: _optionalChain([options, 'optionalAccess', _74 => _74.where]),
+      offset: _optionalChain([options, 'optionalAccess', _75 => _75.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _76 => _76.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _77 => _77.orderBy])
     }
   };
   const data = await queryIndexer({
@@ -8591,7 +8636,7 @@ async function getTransactions(args) {
     aptosConfig,
     originMethod: "getTransactions",
     path: "transactions",
-    params: { start: _optionalChain([options, 'optionalAccess', _72 => _72.offset]), limit: _optionalChain([options, 'optionalAccess', _73 => _73.limit]) }
+    params: { start: _optionalChain([options, 'optionalAccess', _78 => _78.offset]), limit: _optionalChain([options, 'optionalAccess', _79 => _79.limit]) }
   });
 }
 async function getGasPriceEstimation(args) {
@@ -8634,7 +8679,7 @@ async function isTransactionPending(args) {
     const transaction = await getTransactionByHash({ aptosConfig, transactionHash });
     return transaction.type === "pending_transaction" /* Pending */;
   } catch (e) {
-    if (_optionalChain([e, 'optionalAccess', _74 => _74.status]) === 404) {
+    if (_optionalChain([e, 'optionalAccess', _80 => _80.status]) === 404) {
       return true;
     }
     throw e;
@@ -8651,8 +8696,8 @@ async function longWaitForTransaction(args) {
 }
 async function waitForTransaction(args) {
   const { aptosConfig, transactionHash, options } = args;
-  const timeoutSecs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _75 => _75.timeoutSecs]), () => ( DEFAULT_TXN_TIMEOUT_SEC));
-  const checkSuccess = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _76 => _76.checkSuccess]), () => ( true));
+  const timeoutSecs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.timeoutSecs]), () => ( DEFAULT_TXN_TIMEOUT_SEC));
+  const checkSuccess = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.checkSuccess]), () => ( true));
   let isPending = true;
   let timeElapsed = 0;
   let lastTxn;
@@ -8777,7 +8822,7 @@ async function getBlockByVersion(args) {
     aptosConfig,
     originMethod: "getBlockByVersion",
     path: `blocks/by_version/${ledgerVersion}`,
-    params: { with_transactions: _optionalChain([options, 'optionalAccess', _77 => _77.withTransactions]) }
+    params: { with_transactions: _optionalChain([options, 'optionalAccess', _83 => _83.withTransactions]) }
   });
   return fillBlockTransactions({ block, ...args });
 }
@@ -8787,18 +8832,18 @@ async function getBlockByHeight(args) {
     aptosConfig,
     originMethod: "getBlockByHeight",
     path: `blocks/by_height/${blockHeight}`,
-    params: { with_transactions: _optionalChain([options, 'optionalAccess', _78 => _78.withTransactions]) }
+    params: { with_transactions: _optionalChain([options, 'optionalAccess', _84 => _84.withTransactions]) }
   });
   return fillBlockTransactions({ block, ...args });
 }
 async function fillBlockTransactions(args) {
   const { aptosConfig, block, options } = args;
-  if (_optionalChain([options, 'optionalAccess', _79 => _79.withTransactions])) {
+  if (_optionalChain([options, 'optionalAccess', _85 => _85.withTransactions])) {
     block.transactions = _nullishCoalesce(block.transactions, () => ( []));
     const lastTxn = block.transactions[block.transactions.length - 1];
     const firstVersion = BigInt(block.first_version);
     const lastVersion = BigInt(block.last_version);
-    const curVersion = _optionalChain([lastTxn, 'optionalAccess', _80 => _80.version]);
+    const curVersion = _optionalChain([lastTxn, 'optionalAccess', _86 => _86.version]);
     let latestVersion;
     if (curVersion === void 0) {
       latestVersion = firstVersion - 1n;
@@ -8829,794 +8874,47 @@ async function fillBlockTransactions(args) {
   return block;
 }
 
-// src/internal/account.ts
-async function getInfo(args) {
-  const { aptosConfig, accountAddress } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getInfo",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}`
-  });
-  return data;
-}
-async function getModules(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithObfuscatedCursor({
-    aptosConfig,
-    originMethod: "getModules",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/modules`,
-    params: {
-      ledger_version: _optionalChain([options, 'optionalAccess', _81 => _81.ledgerVersion]),
-      offset: _optionalChain([options, 'optionalAccess', _82 => _82.offset]),
-      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _83 => _83.limit]), () => ( 1e3))
-    }
-  });
-}
-async function getModule(args) {
-  if (_optionalChain([args, 'access', _84 => _84.options, 'optionalAccess', _85 => _85.ledgerVersion]) !== void 0) {
-    return getModuleInner(args);
-  }
-  return memoizeAsync(
-    async () => getModuleInner(args),
-    `module-${args.accountAddress}-${args.moduleName}`,
-    1e3 * 60 * 5
-    // 5 minutes
-  )();
-}
-async function getModuleInner(args) {
-  const { aptosConfig, accountAddress, moduleName, options } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getModule",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
-    params: { ledger_version: _optionalChain([options, 'optionalAccess', _86 => _86.ledgerVersion]) }
-  });
-  return data;
-}
-async function getTransactions2(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithCursor({
-    aptosConfig,
-    originMethod: "getTransactions",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/transactions`,
-    params: { start: _optionalChain([options, 'optionalAccess', _87 => _87.offset]), limit: _optionalChain([options, 'optionalAccess', _88 => _88.limit]) }
-  });
-}
-async function getResources(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithObfuscatedCursor({
-    aptosConfig,
-    originMethod: "getResources",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/resources`,
-    params: {
-      ledger_version: _optionalChain([options, 'optionalAccess', _89 => _89.ledgerVersion]),
-      offset: _optionalChain([options, 'optionalAccess', _90 => _90.offset]),
-      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _91 => _91.limit]), () => ( 999))
-    }
-  });
+// src/transactions/transactionBuilder/transactionBuilder.ts
+
+
+// src/transactions/typeTag/parser.ts
+function isValidIdentifier(str) {
+  return !!str.match(/^[_a-zA-Z0-9]+$/);
 }
-async function getResource(args) {
-  const { aptosConfig, accountAddress, resourceType, options } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getResource",
-    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,
-    params: { ledger_version: _optionalChain([options, 'optionalAccess', _92 => _92.ledgerVersion]) }
-  });
-  return data.data;
+function isValidWhitespaceCharacter(char) {
+  return !!char.match(/\s/);
 }
-async function lookupOriginalAccountAddress(args) {
-  const { aptosConfig, authenticationKey, options } = args;
-  const resource = await getResource({
-    aptosConfig,
-    accountAddress: "0x1",
-    resourceType: "0x1::account::OriginatingAddress",
-    options
-  });
-  const {
-    address_map: { handle }
-  } = resource;
-  const authKeyAddress = _chunkJMOQXLEDjs.AccountAddress.from(authenticationKey);
-  try {
-    const originalAddress = await getTableItem({
-      aptosConfig,
-      handle,
-      data: {
-        key: authKeyAddress.toString(),
-        key_type: "address",
-        value_type: "address"
-      },
-      options
-    });
-    return _chunkJMOQXLEDjs.AccountAddress.from(originalAddress);
-  } catch (err) {
-    if (err instanceof AptosApiError && err.data.error_code === "table_item_not_found") {
-      return authKeyAddress;
-    }
-    throw err;
-  }
+function isGeneric(str) {
+  return !!str.match(/^T[0-9]+$/);
 }
-async function getAccountTokensCount(args) {
-  const { aptosConfig, accountAddress } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address },
-    amount: { _gt: 0 }
-  };
-  const graphqlQuery = {
-    query: GetAccountTokensCount,
-    variables: { where_condition: whereCondition }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountTokensCount"
-  });
-  return data.current_token_ownerships_v2_aggregate.aggregate ? data.current_token_ownerships_v2_aggregate.aggregate.count : 0;
+function isRef(str) {
+  return !!str.match(/^&.+$/);
 }
-async function getAccountOwnedTokens(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address },
-    amount: { _gt: 0 }
-  };
-  if (_optionalChain([options, 'optionalAccess', _93 => _93.tokenStandard])) {
-    whereCondition.token_standard = { _eq: _optionalChain([options, 'optionalAccess', _94 => _94.tokenStandard]) };
+function isPrimitive(str) {
+  switch (str) {
+    case "signer":
+    case "address":
+    case "bool":
+    case "u8":
+    case "u16":
+    case "u32":
+    case "u64":
+    case "u128":
+    case "u256":
+      return true;
+    default:
+      return false;
   }
-  const graphqlQuery = {
-    query: GetAccountOwnedTokens,
-    variables: {
-      where_condition: whereCondition,
-      offset: _optionalChain([options, 'optionalAccess', _95 => _95.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _96 => _96.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _97 => _97.orderBy])
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountOwnedTokens"
-  });
-  return data.current_token_ownerships_v2;
 }
-async function getAccountOwnedTokensFromCollectionAddress(args) {
-  const { aptosConfig, accountAddress, collectionAddress, options } = args;
-  const ownerAddress = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const collAddress = _chunkJMOQXLEDjs.AccountAddress.from(collectionAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: ownerAddress },
-    current_token_data: { collection_id: { _eq: collAddress } },
-    amount: { _gt: 0 }
-  };
-  if (_optionalChain([options, 'optionalAccess', _98 => _98.tokenStandard])) {
-    whereCondition.token_standard = { _eq: _optionalChain([options, 'optionalAccess', _99 => _99.tokenStandard]) };
-  }
-  const graphqlQuery = {
-    query: GetAccountOwnedTokensFromCollection,
-    variables: {
-      where_condition: whereCondition,
-      offset: _optionalChain([options, 'optionalAccess', _100 => _100.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _101 => _101.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _102 => _102.orderBy])
+function consumeWhitespace(tagStr, pos) {
+  let i = pos;
+  for (; i < tagStr.length; i += 1) {
+    const innerChar = tagStr[i];
+    if (!isValidWhitespaceCharacter(innerChar)) {
+      break;
     }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountOwnedTokensFromCollectionAddress"
-  });
-  return data.current_token_ownerships_v2;
-}
-async function getAccountCollectionsWithOwnedTokens(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address }
-  };
-  if (_optionalChain([options, 'optionalAccess', _103 => _103.tokenStandard])) {
-    whereCondition.current_collection = {
-      token_standard: { _eq: _optionalChain([options, 'optionalAccess', _104 => _104.tokenStandard]) }
-    };
   }
-  const graphqlQuery = {
-    query: GetAccountCollectionsWithOwnedTokens,
-    variables: {
-      where_condition: whereCondition,
-      offset: _optionalChain([options, 'optionalAccess', _105 => _105.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _106 => _106.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _107 => _107.orderBy])
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountCollectionsWithOwnedTokens"
-  });
-  return data.current_collection_ownership_v2_view;
-}
-async function getAccountTransactionsCount(args) {
-  const { aptosConfig, accountAddress } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const graphqlQuery = {
-    query: GetAccountTransactionsCount,
-    variables: { address }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountTransactionsCount"
-  });
-  return data.account_transactions_aggregate.aggregate ? data.account_transactions_aggregate.aggregate.count : 0;
-}
-async function getAccountCoinsData(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    ..._optionalChain([options, 'optionalAccess', _108 => _108.where]),
-    owner_address: { _eq: address }
-  };
-  const graphqlQuery = {
-    query: GetAccountCoinsData,
-    variables: {
-      where_condition: whereCondition,
-      offset: _optionalChain([options, 'optionalAccess', _109 => _109.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _110 => _110.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _111 => _111.orderBy])
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountCoinsData"
-  });
-  return data.current_fungible_asset_balances;
-}
-async function getAccountCoinsCount(args) {
-  const { aptosConfig, accountAddress } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const graphqlQuery = {
-    query: GetAccountCoinsCount,
-    variables: { address }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountCoinsCount"
-  });
-  if (!data.current_fungible_asset_balances_aggregate.aggregate) {
-    throw Error("Failed to get the count of account coins");
-  }
-  return data.current_fungible_asset_balances_aggregate.aggregate.count;
-}
-async function getAccountOwnedObjects(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address }
-  };
-  const graphqlQuery = {
-    query: GetObjectData,
-    variables: {
-      where_condition: whereCondition,
-      offset: _optionalChain([options, 'optionalAccess', _112 => _112.offset]),
-      limit: _optionalChain([options, 'optionalAccess', _113 => _113.limit]),
-      order_by: _optionalChain([options, 'optionalAccess', _114 => _114.orderBy])
-    }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountOwnedObjects"
-  });
-  return data.current_objects;
-}
-async function deriveAccountFromPrivateKey(args) {
-  const { aptosConfig, privateKey } = args;
-  const publicKey = new AnyPublicKey(privateKey.publicKey());
-  if (privateKey instanceof Secp256k1PrivateKey) {
-    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
-    const address = authKey.derivedAddress();
-    return Account.fromPrivateKey({ privateKey, address });
-  }
-  if (privateKey instanceof Ed25519PrivateKey) {
-    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKey({
-      publicKey
-    });
-    const isSingleSenderTransactionAuthenticator = await isAccountExist({
-      authKey: singleSenderTransactionAuthenticatorAuthKey,
-      aptosConfig
-    });
-    if (isSingleSenderTransactionAuthenticator) {
-      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();
-      return Account.fromPrivateKey({ privateKey, address, legacy: false });
-    }
-    const legacyAuthKey = AuthenticationKey.fromPublicKey({
-      publicKey: publicKey.publicKey
-    });
-    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
-    if (isLegacyEd25519) {
-      const address = legacyAuthKey.derivedAddress();
-      return Account.fromPrivateKey({ privateKey, address, legacy: true });
-    }
-  }
-  throw new Error(`Can't derive account from private key ${privateKey}`);
-}
-async function isAccountExist(args) {
-  const { aptosConfig, authKey } = args;
-  const accountAddress = await lookupOriginalAccountAddress({
-    aptosConfig,
-    authenticationKey: authKey.derivedAddress()
-  });
-  try {
-    await getInfo({
-      aptosConfig,
-      accountAddress
-    });
-    return true;
-  } catch (error) {
-    if (error.status === 404) {
-      return false;
-    }
-    throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);
-  }
-}
-async function getMultiKeysForAuthenticationKeys(args) {
-  const { aptosConfig, authKeys } = args;
-  if (authKeys.length === 0) {
-    throw new Error("No authentication keys provided");
-  }
-  const whereCondition = {
-    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) }
-  };
-  const graphqlQuery = {
-    query: GetMultiKeyForAuthKey,
-    variables: {
-      where_condition: whereCondition
-    }
-  };
-  const { auth_key_multikey_layout: data } = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getMultiKeysForAuthenticationKeys"
-  });
-  const authKeyToMultiKey = new Map(data.map((entry) => [entry.auth_key, entry]));
-  const result = [];
-  for (let i = 0; i < authKeys.length; i += 1) {
-    const entry = authKeyToMultiKey.get(authKeys[i].toString());
-    if (!entry) {
-      throw new Error(`Failed to find multikey for authentication key ${authKeys[i]}`);
-    }
-    const publicKey = extractMultiKeyFromData(entry);
-    result.push({ authKey: authKeys[i], publicKey });
-  }
-  return result;
-}
-function extractMultiKeyFromData(data) {
-  const signaturesRequired = data.signatures_required;
-  const multikeyLayout = data.multikey_layout_with_prefixes;
-  const multikeyType = data.multikey_type;
-  if (multikeyType === "multi_ed25519") {
-    const ed25519PublicKeys = [];
-    for (const key of multikeyLayout) {
-      ed25519PublicKeys.push(new Ed25519PublicKey(key));
-    }
-    return new MultiEd25519PublicKey({
-      publicKeys: ed25519PublicKeys,
-      threshold: signaturesRequired
-    });
-  }
-  if (multikeyType === "multi_key") {
-    const publicKeys = [];
-    for (const key of multikeyLayout) {
-      const deserializer = Deserializer.fromHex(key);
-      const variantIndex = deserializer.deserializeUleb128AsU32();
-      let publicKey;
-      switch (variantIndex) {
-        case 0 /* Ed25519 */:
-          publicKey = new Ed25519PublicKey(deserializer.deserializeFixedBytes(32));
-          break;
-        case 1 /* Secp256k1 */:
-          publicKey = new Secp256k1PublicKey(deserializer.deserializeFixedBytes(65));
-          break;
-        case 3 /* Keyless */:
-          publicKey = KeylessPublicKey.deserialize(deserializer);
-          break;
-        case 4 /* FederatedKeyless */:
-          publicKey = FederatedKeylessPublicKey.deserialize(deserializer);
-          break;
-        default:
-          throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
-      }
-      publicKeys.push(new AnyPublicKey(publicKey));
-    }
-    return new MultiKey({
-      publicKeys,
-      signaturesRequired
-    });
-  }
-  throw new Error("Unknown multikey type");
-}
-async function getAuthKeysForPublicKey(args) {
-  const { aptosConfig, publicKey, options } = args;
-  const verified = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _115 => _115.verified]), () => ( true));
-  let baseKey = publicKey;
-  if (publicKey instanceof AnyPublicKey) {
-    baseKey = publicKey.publicKey;
-  }
-  const whereCondition = {
-    public_key: { _eq: baseKey.toString() },
-    verified: { _eq: verified }
-  };
-  const graphqlQuery = {
-    query: GetAuthKeysForPublicKey,
-    variables: {
-      where_condition: whereCondition
-    }
-  };
-  const { public_key_auth_keys: data } = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAuthKeysForPublicKey"
-  });
-  const sortedData = data.sort((a, b) => Number(b.last_transaction_version) - Number(a.last_transaction_version));
-  const authKeys = sortedData.map((entry) => new AuthenticationKey({ data: entry.auth_key }));
-  return authKeys;
-}
-async function getLastestTransactionVersionForAddress(args) {
-  const { aptosConfig, accountAddress } = args;
-  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString();
-  const whereCondition = {
-    signer: { _eq: accountAddress.toString() }
-  };
-  const graphqlQuery = {
-    query: GetSignatures,
-    variables: {
-      where_condition: whereCondition,
-      limit: 1,
-      order_by: { transaction_version: "desc" }
-    }
-  };
-  const { signatures: data } = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getSignatures"
-  });
-  if (data.length !== 1) {
-    throw new Error(`Expected 1 account address for address ${address}, got ${data.length}`);
-  }
-  return Number(data[0].transaction_version);
-}
-async function getAccountAddressesForAuthKeys(args) {
-  const { aptosConfig, options, authKeys } = args;
-  const verified = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _116 => _116.verified]), () => ( true));
-  if (authKeys.length === 0) {
-    throw new Error("No authentication keys provided");
-  }
-  const whereCondition = {
-    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },
-    verified: { _eq: verified }
-  };
-  const graphqlQuery = {
-    query: GetAccountAddressesForAuthKey,
-    variables: {
-      where_condition: whereCondition
-    }
-  };
-  const { auth_key_account_addresses: data } = await queryIndexer({
-    aptosConfig,
-    query: graphqlQuery,
-    originMethod: "getAccountAddressesForAuthKeys"
-  });
-  return data.map((entry) => ({
-    authKey: new AuthenticationKey({ data: entry.auth_key }),
-    accountAddress: new (0, _chunkJMOQXLEDjs.AccountAddress)(_chunkJMOQXLEDjs.Hex.hexInputToUint8Array(entry.address)),
-    verified: entry.verified,
-    lastTransactionVersion: Number(entry.last_transaction_version)
-  }));
-}
-async function getAccountsForPublicKey(args) {
-  const { aptosConfig, publicKey } = args;
-  let baseKey = publicKey;
-  if (publicKey instanceof AnyPublicKey) {
-    baseKey = publicKey.publicKey;
-  }
-  const singleKeyPublicKeys = [];
-  if (baseKey instanceof Ed25519PublicKey) {
-    singleKeyPublicKeys.push(baseKey);
-  }
-  const anyPublicKey = new AnyPublicKey(baseKey);
-  singleKeyPublicKeys.push(anyPublicKey);
-  const singleKeyAuthKeyPublicKeyPairs = singleKeyPublicKeys.map((pubKey) => {
-    const authKey = pubKey.authKey();
-    return { authKey, publicKey: pubKey };
-  });
-  const multiKeyAuthKeys = await getAuthKeysForPublicKey({ aptosConfig, publicKey });
-  const [multiKeyPairs, authKeyAccountAddressPairs] = await Promise.all([
-    getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: multiKeyAuthKeys }),
-    getAccountAddressesForAuthKeys({
-      aptosConfig,
-      authKeys: multiKeyAuthKeys.concat(singleKeyAuthKeyPublicKeyPairs.map((pair) => pair.publicKey.authKey()))
-    })
-  ]);
-  const authKeyPublicKeyPairs = singleKeyAuthKeyPublicKeyPairs.concat(multiKeyPairs);
-  const result = [];
-  const authKeyToPublicKey = new Map(authKeyPublicKeyPairs.map((pair) => [pair.authKey.toString(), pair.publicKey]));
-  for (const authKeyAccountAddressPair of authKeyAccountAddressPairs) {
-    if (!authKeyToPublicKey.has(authKeyAccountAddressPair.authKey.toString())) {
-      throw new Error(`No publicKey found for authentication key ${authKeyAccountAddressPair.authKey}.`);
-    }
-    result.push({
-      accountAddress: authKeyAccountAddressPair.accountAddress,
-      publicKey: authKeyToPublicKey.get(authKeyAccountAddressPair.authKey.toString()),
-      verified: authKeyAccountAddressPair.verified,
-      lastTransactionVersion: authKeyAccountAddressPair.lastTransactionVersion
-    });
-  }
-  return result;
-}
-async function getPublicKeyFromAccountAddress(args) {
-  const { aptosConfig, accountAddress } = args;
-  const accountData = await getInfo({ aptosConfig, accountAddress });
-  const lastTransactionVersion = await getLastestTransactionVersionForAddress({
-    aptosConfig,
-    accountAddress
-  });
-  console.log("lastTransactionVersion", lastTransactionVersion);
-  const transaction = await getTransactionByVersion({ aptosConfig, ledgerVersion: lastTransactionVersion });
-  if (!_chunkJMOQXLEDjs.isUserTransactionResponse.call(void 0, transaction)) {
-    throw new Error("Transaction is not a user transaction");
-  }
-  const { signature } = transaction;
-  if (!signature) {
-    throw new Error("Transaction has no signature");
-  }
-  let publicKey;
-  if (_chunkJMOQXLEDjs.isEd25519Signature.call(void 0, signature)) {
-    publicKey = new Ed25519PublicKey(signature.public_key);
-  } else if (_chunkJMOQXLEDjs.isMultiEd25519Signature.call(void 0, signature)) {
-    publicKey = new MultiEd25519PublicKey({
-      publicKeys: signature.public_keys.map((pk) => new Ed25519PublicKey(pk)),
-      threshold: signature.threshold
-    });
-  } else if (_chunkJMOQXLEDjs.isSingleSenderSingleKeySignature.call(void 0, signature)) {
-    publicKey = parsePublicKey(signature.public_key);
-  } else if (_chunkJMOQXLEDjs.isSingleSenderMultiKeySignature.call(void 0, signature)) {
-    const publicKeys = [];
-    for (const pk of signature.public_keys) {
-      publicKeys.push(parsePublicKey(pk));
-    }
-    publicKey = new MultiKey({
-      publicKeys,
-      signaturesRequired: signature.signatures_required
-    });
-  } else {
-    throw new Error("Unknown signature type");
-  }
-  if (publicKey.authKey().toString() !== accountData.authentication_key) {
-    throw new Error(
-      "Derived public key does not match authentication key. The most recent signature was likely a key rotation."
-    );
-  }
-  return publicKey;
-}
-function parsePublicKey(data) {
-  if (data.type === "keyless") {
-    const deserializer = Deserializer.fromHex(data.value);
-    return new AnyPublicKey(KeylessPublicKey.deserialize(deserializer));
-  }
-  if (data.type === "ed25519") {
-    return new AnyPublicKey(new Ed25519PublicKey(data.value));
-  }
-  if (data.type === "secp256k1_ecdsa") {
-    return new AnyPublicKey(new Secp256k1PublicKey(data.value));
-  }
-  throw new Error("Unknown public key type");
-}
-
-// src/api/utils.ts
-async function waitForIndexerOnVersion(args) {
-  if (args.minimumLedgerVersion !== void 0) {
-    await waitForIndexer({
-      aptosConfig: args.config,
-      minimumLedgerVersion: args.minimumLedgerVersion,
-      processorType: args.processorType
-    });
-  }
-}
-
-// src/transactions/transactionBuilder/helpers.ts
-function isBool(arg) {
-  return typeof arg === "boolean";
-}
-function isString(arg) {
-  return typeof arg === "string";
-}
-function isNumber(arg) {
-  return typeof arg === "number";
-}
-function convertNumber(arg) {
-  if (isNumber(arg)) {
-    return arg;
-  }
-  if (isString(arg) && arg !== "") {
-    return Number.parseInt(arg, 10);
-  }
-  return void 0;
-}
-function isLargeNumber(arg) {
-  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
-}
-function isEmptyOption(arg) {
-  return arg === null || arg === void 0;
-}
-function isEncodedEntryFunctionArgument(arg) {
-  return (
-    /**
-     * Determines if the provided argument is an instance of the Bool class.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsBool(arg) || /**
-     * Determines if the provided argument is an instance of U8.
-     * This function helps validate the type of the argument passed to ensure it is a U8 type.
-     *
-     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU8(arg) || /**
-     * Determines if the provided argument is an instance of U16.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU16(arg) || /**
-     * Determines if the provided argument is an instance of U32.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @returns A boolean indicating whether the argument is a U32 instance.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU32(arg) || /**
-     * Determine if the provided argument is an instance of U64.
-     * This function helps validate that the argument conforms to the expected U64 type.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU64(arg) || /**
-     * Determines if the provided argument is an instance of U128.
-     * This function helps validate the type of the argument passed to ensure it is a U128 type.
-     *
-     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU128(arg) || /**
-     * Determines if the provided argument is an instance of U256.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @returns A boolean indicating whether the argument is a U256 instance.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsU256(arg) || /**
-     * Determines if the provided argument is an instance of AccountAddress.
-     * This function helps validate whether a given input corresponds to a valid BCS address type.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsAddress(arg) || /**
-     * Determine if the provided argument is an instance of MoveString.
-     *
-     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsString(arg) || /**
-     * Determine if the provided argument is an instance of FixedBytes.
-     * This function helps to validate the type of the argument being passed.
-     *
-     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
-     * @group Implementation
-     * @category Transactions
-     */
-    isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption
-  );
-}
-function isBcsBool(arg) {
-  return arg instanceof Bool;
-}
-function isBcsAddress(arg) {
-  return arg instanceof _chunkJMOQXLEDjs.AccountAddress;
-}
-function isBcsString(arg) {
-  return arg instanceof MoveString;
-}
-function isBcsFixedBytes(arg) {
-  return arg instanceof FixedBytes;
-}
-function isBcsU8(arg) {
-  return arg instanceof U8;
-}
-function isBcsU16(arg) {
-  return arg instanceof U16;
-}
-function isBcsU32(arg) {
-  return arg instanceof U32;
-}
-function isBcsU64(arg) {
-  return arg instanceof U64;
-}
-function isBcsU128(arg) {
-  return arg instanceof U128;
-}
-function isBcsU256(arg) {
-  return arg instanceof U256;
-}
-function isScriptDataInput(arg) {
-  return "bytecode" in arg;
-}
-function throwTypeMismatch(expectedType, position) {
-  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
-}
-function findFirstNonSignerArg(functionAbi) {
-  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
-  if (index < 0) {
-    return functionAbi.params.length;
-  }
-  return index;
-}
-
-// src/transactions/transactionBuilder/transactionBuilder.ts
-
-
-// src/transactions/typeTag/parser.ts
-function isValidIdentifier(str) {
-  return !!str.match(/^[_a-zA-Z0-9]+$/);
-}
-function isValidWhitespaceCharacter(char) {
-  return !!char.match(/\s/);
-}
-function isGeneric(str) {
-  return !!str.match(/^T[0-9]+$/);
-}
-function isRef(str) {
-  return !!str.match(/^&.+$/);
-}
-function isPrimitive(str) {
-  switch (str) {
-    case "signer":
-    case "address":
-    case "bool":
-    case "u8":
-    case "u16":
-    case "u32":
-    case "u64":
-    case "u128":
-    case "u256":
-      return true;
-    default:
-      return false;
-  }
-}
-function consumeWhitespace(tagStr, pos) {
-  let i = pos;
-  for (; i < tagStr.length; i += 1) {
-    const innerChar = tagStr[i];
-    if (!isValidWhitespaceCharacter(innerChar)) {
-      break;
-    }
-  }
-  return i;
+  return i;
 }
 var TypeTagParserErrorType = /* @__PURE__ */ ((TypeTagParserErrorType2) => {
   TypeTagParserErrorType2["InvalidTypeTag"] = "unknown type";
@@ -9650,7 +8948,7 @@ var TypeTagParserError = class extends Error {
   }
 };
 function parseTypeTag(typeStr, options) {
-  const allowGenerics = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _117 => _117.allowGenerics]), () => ( false));
+  const allowGenerics = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.allowGenerics]), () => ( false));
   const saved = [];
   let innerTypes = [];
   let curTypes = [];
@@ -9800,10 +9098,161 @@ function parseTypeTagInner(str, types, allowGenerics) {
   }
 }
 
+// src/transactions/transactionBuilder/helpers.ts
+function isBool(arg) {
+  return typeof arg === "boolean";
+}
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+function convertNumber(arg) {
+  if (isNumber(arg)) {
+    return arg;
+  }
+  if (isString(arg) && arg !== "") {
+    return Number.parseInt(arg, 10);
+  }
+  return void 0;
+}
+function isLargeNumber(arg) {
+  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
+}
+function isEmptyOption(arg) {
+  return arg === null || arg === void 0;
+}
+function isEncodedEntryFunctionArgument(arg) {
+  return (
+    /**
+     * Determines if the provided argument is an instance of the Bool class.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsBool(arg) || /**
+     * Determines if the provided argument is an instance of U8.
+     * This function helps validate the type of the argument passed to ensure it is a U8 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU8(arg) || /**
+     * Determines if the provided argument is an instance of U16.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU16(arg) || /**
+     * Determines if the provided argument is an instance of U32.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U32 instance.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU32(arg) || /**
+     * Determine if the provided argument is an instance of U64.
+     * This function helps validate that the argument conforms to the expected U64 type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU64(arg) || /**
+     * Determines if the provided argument is an instance of U128.
+     * This function helps validate the type of the argument passed to ensure it is a U128 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU128(arg) || /**
+     * Determines if the provided argument is an instance of U256.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U256 instance.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsU256(arg) || /**
+     * Determines if the provided argument is an instance of AccountAddress.
+     * This function helps validate whether a given input corresponds to a valid BCS address type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsAddress(arg) || /**
+     * Determine if the provided argument is an instance of MoveString.
+     *
+     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsString(arg) || /**
+     * Determine if the provided argument is an instance of FixedBytes.
+     * This function helps to validate the type of the argument being passed.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @group Implementation
+     * @category Transactions
+     */
+    isBcsFixedBytes(arg) || arg instanceof MoveVector || arg instanceof MoveOption
+  );
+}
+function isBcsBool(arg) {
+  return arg instanceof Bool;
+}
+function isBcsAddress(arg) {
+  return arg instanceof _chunkJMOQXLEDjs.AccountAddress;
+}
+function isBcsString(arg) {
+  return arg instanceof MoveString;
+}
+function isBcsFixedBytes(arg) {
+  return arg instanceof FixedBytes;
+}
+function isBcsU8(arg) {
+  return arg instanceof U8;
+}
+function isBcsU16(arg) {
+  return arg instanceof U16;
+}
+function isBcsU32(arg) {
+  return arg instanceof U32;
+}
+function isBcsU64(arg) {
+  return arg instanceof U64;
+}
+function isBcsU128(arg) {
+  return arg instanceof U128;
+}
+function isBcsU256(arg) {
+  return arg instanceof U256;
+}
+function isScriptDataInput(arg) {
+  return "bytecode" in arg;
+}
+function throwTypeMismatch(expectedType, position) {
+  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
+}
+function findFirstNonSignerArg(functionAbi) {
+  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+  if (index < 0) {
+    return functionAbi.params.length;
+  }
+  return index;
+}
+
 // src/transactions/transactionBuilder/remoteAbi.ts
 var TEXT_ENCODER = new TextEncoder();
 function standardizeTypeTags(typeArguments) {
-  return _nullishCoalesce(_optionalChain([typeArguments, 'optionalAccess', _118 => _118.map, 'call', _119 => _119((typeArg) => {
+  return _nullishCoalesce(_optionalChain([typeArguments, 'optionalAccess', _88 => _88.map, 'call', _89 => _89((typeArg) => {
     if (isString(typeArg)) {
       return parseTypeTag(typeArg);
     }
@@ -10198,7 +9647,7 @@ function generateViewFunctionPayloadWithABI(args) {
       `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
     );
   }
-  const functionArguments = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _120 => _120.functionArguments, 'optionalAccess', _121 => _121.map, 'call', _122 => _122((arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments))]), () => ( []));
+  const functionArguments = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _90 => _90.functionArguments, 'optionalAccess', _91 => _91.map, 'call', _92 => _92((arg, i) => convertArgument(args.function, functionAbi, arg, i, typeArguments))]), () => ( []));
   if (functionArguments.length !== functionAbi.parameters.length) {
     throw new Error(
       // eslint-disable-next-line max-len
@@ -10226,7 +9675,7 @@ async function generateRawTransaction(args) {
     return { chainId: info.chain_id };
   };
   const getGasUnitPrice = async () => {
-    if (_optionalChain([options, 'optionalAccess', _123 => _123.gasUnitPrice])) {
+    if (_optionalChain([options, 'optionalAccess', _93 => _93.gasUnitPrice])) {
       return { gasEstimate: options.gasUnitPrice };
     }
     const estimation = await getGasPriceEstimation({ aptosConfig });
@@ -10234,7 +9683,7 @@ async function generateRawTransaction(args) {
   };
   const getSequenceNumberForAny = async () => {
     const getSequenceNumber = async () => {
-      if (_optionalChain([options, 'optionalAccess', _124 => _124.accountSequenceNumber]) !== void 0) {
+      if (_optionalChain([options, 'optionalAccess', _94 => _94.accountSequenceNumber]) !== void 0) {
         return options.accountSequenceNumber;
       }
       return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;
@@ -10255,9 +9704,9 @@ async function generateRawTransaction(args) {
     getSequenceNumberForAny()
   ]);
   const { maxGasAmount, gasUnitPrice, expireTimestamp } = {
-    maxGasAmount: _optionalChain([options, 'optionalAccess', _125 => _125.maxGasAmount]) ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),
-    gasUnitPrice: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _126 => _126.gasUnitPrice]), () => ( BigInt(gasEstimate))),
-    expireTimestamp: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _127 => _127.expireTimestamp]), () => ( BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_TXN_EXP_SEC_FROM_NOW)))
+    maxGasAmount: _optionalChain([options, 'optionalAccess', _95 => _95.maxGasAmount]) ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),
+    gasUnitPrice: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.gasUnitPrice]), () => ( BigInt(gasEstimate))),
+    expireTimestamp: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _97 => _97.expireTimestamp]), () => ( BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_TXN_EXP_SEC_FROM_NOW)))
   };
   return new RawTransaction(
     _chunkJMOQXLEDjs.AccountAddress.from(sender),
@@ -10279,7 +9728,7 @@ async function buildTransaction(args) {
     feePayerAddress
   });
   if ("secondarySignerAddresses" in args) {
-    const signers = _nullishCoalesce(_optionalChain([args, 'access', _128 => _128.secondarySignerAddresses, 'optionalAccess', _129 => _129.map, 'call', _130 => _130((signer) => _chunkJMOQXLEDjs.AccountAddress.from(signer))]), () => ( []));
+    const signers = _nullishCoalesce(_optionalChain([args, 'access', _98 => _98.secondarySignerAddresses, 'optionalAccess', _99 => _99.map, 'call', _100 => _100((signer) => _chunkJMOQXLEDjs.AccountAddress.from(signer))]), () => ( []));
     return new MultiAgentTransaction(
       rawTxn,
       signers,
@@ -10383,7 +9832,12 @@ function getAuthenticatorForSimulation(publicKey) {
     return new AccountAuthenticatorMultiKey(
       accountPublicKey,
       new MultiKeySignature({
-        signatures: accountPublicKey.publicKeys.map(() => new AnySignature(invalidSignature)),
+        signatures: accountPublicKey.publicKeys.map((pubKey) => {
+          if (KeylessPublicKey.isInstance(pubKey.publicKey) || FederatedKeylessPublicKey.isInstance(pubKey.publicKey)) {
+            return new AnySignature(KeylessSignature.getSimulationSignature());
+          }
+          return new AnySignature(invalidSignature);
+        }),
         bitmap: accountPublicKey.createBitmap({
           bits: Array(accountPublicKey.publicKeys.length).fill(0).map((_, i) => i)
         })
@@ -10495,91 +9949,36 @@ var AptosScriptComposer = class _AptosScriptComposer {
   // or the regular entry function arguments.
   //
   // The function would also return a list of `CallArgument` that can be passed on to future calls.
-  async addBatchedCalls(input) {
-    const { moduleAddress, moduleName, functionName } = _chunkJMOQXLEDjs.getFunctionParts.call(void 0, input.function);
-    const nodeUrl = this.config.getRequestUrl("Fullnode" /* FULLNODE */);
-    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
-    if (input.typeArguments !== void 0) {
-      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
-    }
-    const typeArguments = standardizeTypeTags(input.typeArguments);
-    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
-    if (typeArguments.length !== functionAbi.typeParameters.length) {
-      throw new Error(
-        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
-      );
-    }
-    const functionArguments = input.functionArguments.map(
-      (arg, i) => convertCallArgument(arg, functionName, functionAbi, i, typeArguments)
-    );
-    return this.builder.add_batched_call(
-      `${moduleAddress}::${moduleName}`,
-      functionName,
-      typeArguments.map((arg) => arg.toString()),
-      functionArguments
-    );
-  }
-  build() {
-    return this.builder.generate_batched_calls(true);
-  }
-};
-
-// src/internal/view.ts
-async function view(args) {
-  const { aptosConfig, payload, options } = args;
-  const viewFunctionPayload = await generateViewFunctionPayload({
-    ...payload,
-    aptosConfig
-  });
-  const serializer = new (0, _chunkJMOQXLEDjs.Serializer)();
-  viewFunctionPayload.serialize(serializer);
-  const bytes = serializer.toUint8Array();
-  const { data } = await postAptosFullNode({
-    aptosConfig,
-    path: "view",
-    originMethod: "view",
-    contentType: "application/x.aptos.view_function+bcs" /* BCS_VIEW_FUNCTION */,
-    params: { ledger_version: _optionalChain([options, 'optionalAccess', _131 => _131.ledgerVersion]) },
-    body: bytes
-  });
-  return data;
-}
-async function viewJson(args) {
-  const { aptosConfig, payload, options } = args;
-  const { data } = await postAptosFullNode({
-    aptosConfig,
-    originMethod: "viewJson",
-    path: "view",
-    params: { ledger_version: _optionalChain([options, 'optionalAccess', _132 => _132.ledgerVersion]) },
-    body: {
-      function: payload.function,
-      type_arguments: _nullishCoalesce(payload.typeArguments, () => ( [])),
-      arguments: _nullishCoalesce(payload.functionArguments, () => ( []))
+  async addBatchedCalls(input) {
+    const { moduleAddress, moduleName, functionName } = _chunkJMOQXLEDjs.getFunctionParts.call(void 0, input.function);
+    const nodeUrl = this.config.getRequestUrl("Fullnode" /* FULLNODE */);
+    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
+    if (input.typeArguments !== void 0) {
+      for (const typeArgument of input.typeArguments) {
+        await this.builder.load_type_tag(nodeUrl, typeArgument.toString());
+      }
     }
-  });
-  return data;
-}
-
-// src/internal/coin.ts
-var coinTransferAbi = {
-  typeParameters: [{ constraints: [] }],
-  parameters: [new TypeTagAddress(), new TypeTagU64()]
+    const typeArguments = standardizeTypeTags(input.typeArguments);
+    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    if (typeArguments.length !== functionAbi.typeParameters.length) {
+      throw new Error(
+        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`
+      );
+    }
+    const functionArguments = input.functionArguments.map(
+      (arg, i) => convertCallArgument(arg, functionName, functionAbi, i, typeArguments)
+    );
+    return this.builder.add_batched_call(
+      `${moduleAddress}::${moduleName}`,
+      functionName,
+      typeArguments.map((arg) => arg.toString()),
+      functionArguments
+    );
+  }
+  build() {
+    return this.builder.generate_batched_calls(true);
+  }
 };
-async function transferCoinTransaction(args) {
-  const { aptosConfig, sender, recipient, amount, coinType, options } = args;
-  const coinStructType = _nullishCoalesce(coinType, () => ( APTOS_COIN));
-  return generateTransaction({
-    aptosConfig,
-    sender,
-    data: {
-      function: "0x1::aptos_account::transfer_coins",
-      typeArguments: [coinStructType],
-      functionArguments: [recipient, amount],
-      abi: coinTransferAbi
-    },
-    options
-  });
-}
 
 // src/internal/transactionSubmission.ts
 async function generateTransaction(args) {
@@ -10678,9 +10077,9 @@ async function simulateTransaction(args) {
     body: signedTransaction,
     path: "transactions/simulate",
     params: {
-      estimate_gas_unit_price: _nullishCoalesce(_optionalChain([args, 'access', _133 => _133.options, 'optionalAccess', _134 => _134.estimateGasUnitPrice]), () => ( false)),
-      estimate_max_gas_amount: _nullishCoalesce(_optionalChain([args, 'access', _135 => _135.options, 'optionalAccess', _136 => _136.estimateMaxGasAmount]), () => ( false)),
-      estimate_prioritized_gas_unit_price: _nullishCoalesce(_optionalChain([args, 'access', _137 => _137.options, 'optionalAccess', _138 => _138.estimatePrioritizedGasUnitPrice]), () => ( false))
+      estimate_gas_unit_price: _nullishCoalesce(_optionalChain([args, 'access', _101 => _101.options, 'optionalAccess', _102 => _102.estimateGasUnitPrice]), () => ( false)),
+      estimate_max_gas_amount: _nullishCoalesce(_optionalChain([args, 'access', _103 => _103.options, 'optionalAccess', _104 => _104.estimateMaxGasAmount]), () => ( false)),
+      estimate_prioritized_gas_unit_price: _nullishCoalesce(_optionalChain([args, 'access', _105 => _105.options, 'optionalAccess', _106 => _106.estimatePrioritizedGasUnitPrice]), () => ( false))
     },
     originMethod: "simulateTransaction",
     contentType: "application/x.aptos.signed_transaction+bcs" /* BCS_SIGNED_TRANSACTION */
@@ -10723,41 +10122,340 @@ async function signAndSubmitTransaction(args) {
   const senderAuthenticator = signTransaction({ signer, transaction });
   return submitTransaction({
     aptosConfig,
-    transaction,
-    senderAuthenticator,
-    feePayerAuthenticator
+    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: _chunkJMOQXLEDjs.AccountAddress.from(account),
+    data: {
+      function: "0x1::code::publish_package_txn",
+      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
+      abi: packagePublishAbi
+    },
+    options
+  });
+}
+
+// src/internal/account.ts
+async function getInfo2(args) {
+  return getInfo(args);
+}
+async function getModules2(args) {
+  return getModules(args);
+}
+async function getModule2(args) {
+  return getModule(args);
+}
+async function getTransactions2(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithCursor({
+    aptosConfig,
+    originMethod: "getTransactions",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/transactions`,
+    params: { start: _optionalChain([options, 'optionalAccess', _107 => _107.offset]), limit: _optionalChain([options, 'optionalAccess', _108 => _108.limit]) }
+  });
+}
+async function getResources(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor({
+    aptosConfig,
+    originMethod: "getResources",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/resources`,
+    params: {
+      ledger_version: _optionalChain([options, 'optionalAccess', _109 => _109.ledgerVersion]),
+      offset: _optionalChain([options, 'optionalAccess', _110 => _110.offset]),
+      limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _111 => _111.limit]), () => ( 999))
+    }
+  });
+}
+async function getResource(args) {
+  const { aptosConfig, accountAddress, resourceType, options } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    originMethod: "getResource",
+    path: `accounts/${_chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,
+    params: { ledger_version: _optionalChain([options, 'optionalAccess', _112 => _112.ledgerVersion]) }
+  });
+  return data.data;
+}
+async function lookupOriginalAccountAddress(args) {
+  const { aptosConfig, authenticationKey, options } = args;
+  const resource = await getResource({
+    aptosConfig,
+    accountAddress: "0x1",
+    resourceType: "0x1::account::OriginatingAddress",
+    options
+  });
+  const {
+    address_map: { handle }
+  } = resource;
+  const authKeyAddress = _chunkJMOQXLEDjs.AccountAddress.from(authenticationKey);
+  try {
+    const originalAddress = await getTableItem({
+      aptosConfig,
+      handle,
+      data: {
+        key: authKeyAddress.toString(),
+        key_type: "address",
+        value_type: "address"
+      },
+      options
+    });
+    return _chunkJMOQXLEDjs.AccountAddress.from(originalAddress);
+  } catch (err) {
+    if (err instanceof AptosApiError && err.data.error_code === "table_item_not_found") {
+      return authKeyAddress;
+    }
+    throw err;
+  }
+}
+async function getAccountTokensCount(args) {
+  const { aptosConfig, accountAddress } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const whereCondition = {
+    owner_address: { _eq: address },
+    amount: { _gt: 0 }
+  };
+  const graphqlQuery = {
+    query: GetAccountTokensCount,
+    variables: { where_condition: whereCondition }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountTokensCount"
+  });
+  return data.current_token_ownerships_v2_aggregate.aggregate ? data.current_token_ownerships_v2_aggregate.aggregate.count : 0;
+}
+async function getAccountOwnedTokens(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const whereCondition = {
+    owner_address: { _eq: address },
+    amount: { _gt: 0 }
+  };
+  if (_optionalChain([options, 'optionalAccess', _113 => _113.tokenStandard])) {
+    whereCondition.token_standard = { _eq: _optionalChain([options, 'optionalAccess', _114 => _114.tokenStandard]) };
+  }
+  const graphqlQuery = {
+    query: GetAccountOwnedTokens,
+    variables: {
+      where_condition: whereCondition,
+      offset: _optionalChain([options, 'optionalAccess', _115 => _115.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _116 => _116.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _117 => _117.orderBy])
+    }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountOwnedTokens"
+  });
+  return data.current_token_ownerships_v2;
+}
+async function getAccountOwnedTokensFromCollectionAddress(args) {
+  const { aptosConfig, accountAddress, collectionAddress, options } = args;
+  const ownerAddress = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const collAddress = _chunkJMOQXLEDjs.AccountAddress.from(collectionAddress).toStringLong();
+  const whereCondition = {
+    owner_address: { _eq: ownerAddress },
+    current_token_data: { collection_id: { _eq: collAddress } },
+    amount: { _gt: 0 }
+  };
+  if (_optionalChain([options, 'optionalAccess', _118 => _118.tokenStandard])) {
+    whereCondition.token_standard = { _eq: _optionalChain([options, 'optionalAccess', _119 => _119.tokenStandard]) };
+  }
+  const graphqlQuery = {
+    query: GetAccountOwnedTokensFromCollection,
+    variables: {
+      where_condition: whereCondition,
+      offset: _optionalChain([options, 'optionalAccess', _120 => _120.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _121 => _121.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _122 => _122.orderBy])
+    }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountOwnedTokensFromCollectionAddress"
+  });
+  return data.current_token_ownerships_v2;
+}
+async function getAccountCollectionsWithOwnedTokens(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const whereCondition = {
+    owner_address: { _eq: address }
+  };
+  if (_optionalChain([options, 'optionalAccess', _123 => _123.tokenStandard])) {
+    whereCondition.current_collection = {
+      token_standard: { _eq: _optionalChain([options, 'optionalAccess', _124 => _124.tokenStandard]) }
+    };
+  }
+  const graphqlQuery = {
+    query: GetAccountCollectionsWithOwnedTokens,
+    variables: {
+      where_condition: whereCondition,
+      offset: _optionalChain([options, 'optionalAccess', _125 => _125.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _126 => _126.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _127 => _127.orderBy])
+    }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountCollectionsWithOwnedTokens"
+  });
+  return data.current_collection_ownership_v2_view;
+}
+async function getAccountTransactionsCount(args) {
+  const { aptosConfig, accountAddress } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const graphqlQuery = {
+    query: GetAccountTransactionsCount,
+    variables: { address }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountTransactionsCount"
+  });
+  return data.account_transactions_aggregate.aggregate ? data.account_transactions_aggregate.aggregate.count : 0;
+}
+async function getAccountCoinsData(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const whereCondition = {
+    ..._optionalChain([options, 'optionalAccess', _128 => _128.where]),
+    owner_address: { _eq: address }
+  };
+  const graphqlQuery = {
+    query: GetAccountCoinsData,
+    variables: {
+      where_condition: whereCondition,
+      offset: _optionalChain([options, 'optionalAccess', _129 => _129.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _130 => _130.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _131 => _131.orderBy])
+    }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountCoinsData"
   });
+  return data.current_fungible_asset_balances;
 }
-async function signAndSubmitAsFeePayer(args) {
-  const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;
-  if (isKeylessSigner(feePayer)) {
-    await feePayer.checkKeylessAccountValidity(aptosConfig);
+async function getAccountCoinsCount(args) {
+  const { aptosConfig, accountAddress } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const graphqlQuery = {
+    query: GetAccountCoinsCount,
+    variables: { address }
+  };
+  const data = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountCoinsCount"
+  });
+  if (!data.current_fungible_asset_balances_aggregate.aggregate) {
+    throw Error("Failed to get the count of account coins");
   }
-  const feePayerAuthenticator = signAsFeePayer({ signer: feePayer, transaction });
-  return submitTransaction({
+  return data.current_fungible_asset_balances_aggregate.aggregate.count;
+}
+async function getAccountOwnedObjects(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toStringLong();
+  const whereCondition = {
+    owner_address: { _eq: address }
+  };
+  const graphqlQuery = {
+    query: GetObjectData,
+    variables: {
+      where_condition: whereCondition,
+      offset: _optionalChain([options, 'optionalAccess', _132 => _132.offset]),
+      limit: _optionalChain([options, 'optionalAccess', _133 => _133.limit]),
+      order_by: _optionalChain([options, 'optionalAccess', _134 => _134.orderBy])
+    }
+  };
+  const data = await queryIndexer({
     aptosConfig,
-    transaction,
-    senderAuthenticator,
-    feePayerAuthenticator
+    query: graphqlQuery,
+    originMethod: "getAccountOwnedObjects"
   });
+  return data.current_objects;
 }
-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({
+async function deriveAccountFromPrivateKey(args) {
+  const { aptosConfig, privateKey } = args;
+  const publicKey = new AnyPublicKey(privateKey.publicKey());
+  if (privateKey instanceof Secp256k1PrivateKey) {
+    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
+    const address = authKey.derivedAddress();
+    return Account.fromPrivateKey({ privateKey, address });
+  }
+  if (privateKey instanceof Ed25519PrivateKey) {
+    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKey({
+      publicKey
+    });
+    const isSingleSenderTransactionAuthenticator = await isAccountExist({
+      authKey: singleSenderTransactionAuthenticatorAuthKey,
+      aptosConfig
+    });
+    if (isSingleSenderTransactionAuthenticator) {
+      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();
+      return Account.fromPrivateKey({ privateKey, address, legacy: false });
+    }
+    const legacyAuthKey = AuthenticationKey.fromPublicKey({
+      publicKey: publicKey.publicKey
+    });
+    const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
+    if (isLegacyEd25519) {
+      const address = legacyAuthKey.derivedAddress();
+      return Account.fromPrivateKey({ privateKey, address, legacy: true });
+    }
+  }
+  throw new Error(`Can't derive account from private key ${privateKey}`);
+}
+async function isAccountExist(args) {
+  const { aptosConfig, authKey } = args;
+  const accountAddress = await lookupOriginalAccountAddress({
     aptosConfig,
-    sender: _chunkJMOQXLEDjs.AccountAddress.from(account),
-    data: {
-      function: "0x1::code::publish_package_txn",
-      functionArguments: [MoveVector.U8(metadataBytes), new MoveVector(totalByteCode)],
-      abi: packagePublishAbi
-    },
-    options
+    authenticationKey: authKey.derivedAddress()
   });
+  try {
+    await getInfo2({
+      aptosConfig,
+      accountAddress
+    });
+    return true;
+  } catch (error) {
+    if (error.status === 404) {
+      return false;
+    }
+    throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);
+  }
 }
 var rotateAuthKeyAbi = {
   typeParameters: [],
@@ -10770,17 +10468,71 @@ var rotateAuthKeyAbi = {
     TypeTagVector.u8()
   ]
 };
-var rotateAuthKeyUnverifiedAbi = {
-  typeParameters: [],
-  parameters: [TypeTagVector.u8()]
-};
 async function rotateAuthKey(args) {
-  const { aptosConfig, fromAccount, toNewPrivateKey } = args;
-  const accountInfo = await getInfo({
+  const { aptosConfig, fromAccount, dangerouslySkipVerification } = args;
+  if ("toNewPrivateKey" in args) {
+    return rotateAuthKeyWithChallenge({
+      aptosConfig,
+      fromAccount,
+      toNewPrivateKey: args.toNewPrivateKey
+    });
+  }
+  let authKey;
+  if ("toAccount" in args) {
+    if (args.toAccount instanceof Ed25519Account) {
+      return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toNewPrivateKey: args.toAccount.privateKey });
+    }
+    if (args.toAccount instanceof MultiEd25519Account) {
+      return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toAccount: args.toAccount });
+    }
+    authKey = args.toAccount.publicKey.authKey();
+  } else if ("toAuthKey" in args) {
+    authKey = args.toAuthKey;
+  } else {
+    throw new Error("Invalid arguments");
+  }
+  const pendingTxn = await rotateAuthKeyUnverified({
+    aptosConfig,
+    fromAccount,
+    toAuthKey: authKey
+  });
+  if (dangerouslySkipVerification === true) {
+    return pendingTxn;
+  }
+  const rotateAuthKeyTxnResponse = await waitForTransaction({
+    aptosConfig,
+    transactionHash: pendingTxn.hash
+  });
+  if (!rotateAuthKeyTxnResponse.success) {
+    throw new Error(`Failed to rotate authentication key - ${rotateAuthKeyTxnResponse}`);
+  }
+  const verificationTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::set_originating_address",
+      functionArguments: []
+    }
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: args.toAccount,
+    // Use the new account to sign
+    transaction: verificationTxn
+  });
+}
+async function rotateAuthKeyWithChallenge(args) {
+  const { aptosConfig, fromAccount } = args;
+  const accountInfo = await getInfo2({
     aptosConfig,
     accountAddress: fromAccount.accountAddress
   });
-  const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });
+  let newAccount;
+  if ("toNewPrivateKey" in args) {
+    newAccount = Account.fromPrivateKey({ privateKey: args.toNewPrivateKey, legacy: true });
+  } else {
+    newAccount = args.toAccount;
+  }
   const challenge = new RotationProofChallenge({
     sequenceNumber: BigInt(accountInfo.sequence_number),
     originator: fromAccount.accountAddress,
@@ -10788,8 +10540,8 @@ async function rotateAuthKey(args) {
     newPublicKey: newAccount.publicKey
   });
   const challengeHex = challenge.bcsToBytes();
-  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
-  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
+  const proofSignedByCurrentKey = fromAccount.sign(challengeHex);
+  const proofSignedByNewKey = newAccount.sign(challengeHex);
   const rawTxn = await generateTransaction({
     aptosConfig,
     sender: fromAccount.accountAddress,
@@ -10802,100 +10554,338 @@ async function rotateAuthKey(args) {
         new U8(newAccount.signingScheme),
         // to scheme
         MoveVector.U8(newAccount.publicKey.toUint8Array()),
-        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array())
+        MoveVector.U8(proofSignedByCurrentKey.toUint8Array()),
+        MoveVector.U8(proofSignedByNewKey.toUint8Array())
       ],
       abi: rotateAuthKeyAbi
     }
-  });
-  return signAndSubmitTransaction({
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn
+  });
+}
+var rotateAuthKeyUnverifiedAbi = {
+  typeParameters: [],
+  parameters: [TypeTagVector.u8()]
+};
+async function rotateAuthKeyUnverified(args) {
+  const { aptosConfig, fromAccount, toAuthKey } = args;
+  const authKey = toAuthKey;
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key_call",
+      functionArguments: [MoveVector.U8(authKey.toUint8Array())],
+      abi: rotateAuthKeyUnverifiedAbi
+    }
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn
+  });
+}
+async function getMultiKeysForAuthenticationKeys(args) {
+  const { aptosConfig, authKeys } = args;
+  if (authKeys.length === 0) {
+    throw new Error("No authentication keys provided");
+  }
+  const whereCondition = {
+    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) }
+  };
+  const graphqlQuery = {
+    query: GetMultiKeyForAuthKey,
+    variables: {
+      where_condition: whereCondition
+    }
+  };
+  const { auth_key_multikey_layout: data } = await queryIndexer({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getMultiKeysForAuthenticationKeys"
+  });
+  const authKeyToMultiKey = new Map(data.map((entry) => [entry.auth_key, entry]));
+  const result = [];
+  for (let i = 0; i < authKeys.length; i += 1) {
+    const entry = authKeyToMultiKey.get(authKeys[i].toString());
+    if (!entry) {
+      throw new Error(`Failed to find multikey for authentication key ${authKeys[i]}`);
+    }
+    const publicKey = extractMultiKeyFromData(entry);
+    result.push({ authKey: authKeys[i], publicKey });
+  }
+  return result;
+}
+function extractMultiKeyFromData(data) {
+  const signaturesRequired = data.signatures_required;
+  const multikeyLayout = data.multikey_layout_with_prefixes;
+  const multikeyType = data.multikey_type;
+  if (multikeyType === "multi_ed25519") {
+    const ed25519PublicKeys = [];
+    for (const key of multikeyLayout) {
+      ed25519PublicKeys.push(new Ed25519PublicKey(key));
+    }
+    return new MultiEd25519PublicKey({
+      publicKeys: ed25519PublicKeys,
+      threshold: signaturesRequired
+    });
+  }
+  if (multikeyType === "multi_key") {
+    const publicKeys = [];
+    for (const key of multikeyLayout) {
+      const deserializer = Deserializer.fromHex(key);
+      const variantIndex = deserializer.deserializeUleb128AsU32();
+      let publicKey;
+      switch (variantIndex) {
+        case 0 /* Ed25519 */:
+          publicKey = new Ed25519PublicKey(deserializer.deserializeFixedBytes(32));
+          break;
+        case 1 /* Secp256k1 */:
+          publicKey = new Secp256k1PublicKey(deserializer.deserializeFixedBytes(65));
+          break;
+        case 3 /* Keyless */:
+          publicKey = KeylessPublicKey.deserialize(deserializer);
+          break;
+        case 4 /* FederatedKeyless */:
+          publicKey = FederatedKeylessPublicKey.deserialize(deserializer);
+          break;
+        default:
+          throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
+      }
+      publicKeys.push(new AnyPublicKey(publicKey));
+    }
+    return new MultiKey({
+      publicKeys,
+      signaturesRequired
+    });
+  }
+  throw new Error("Unknown multikey type");
+}
+async function getAuthKeysForPublicKey(args) {
+  const { aptosConfig, publicKey, options } = args;
+  const verified = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _135 => _135.verified]), () => ( true));
+  let baseKey = publicKey;
+  if (publicKey instanceof AnyPublicKey) {
+    baseKey = publicKey.publicKey;
+  }
+  const whereCondition = {
+    public_key: { _eq: baseKey.toString() },
+    verified: { _eq: verified }
+  };
+  const graphqlQuery = {
+    query: GetAuthKeysForPublicKey,
+    variables: {
+      where_condition: whereCondition
+    }
+  };
+  const { public_key_auth_keys: data } = await queryIndexer({
     aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn
+    query: graphqlQuery,
+    originMethod: "getAuthKeysForPublicKey"
   });
+  const sortedData = data.sort((a, b) => Number(b.last_transaction_version) - Number(a.last_transaction_version));
+  const authKeys = sortedData.map((entry) => new AuthenticationKey({ data: entry.auth_key }));
+  return authKeys;
 }
-async function rotateAuthKeyToMultiEd25519(args) {
-  const { aptosConfig, fromAccount, multiEd25519Account } = args;
-  const accountInfo = await getInfo({
-    aptosConfig,
-    accountAddress: fromAccount.accountAddress
-  });
-  const newAccount = multiEd25519Account;
-  const challenge = new RotationProofChallenge({
-    sequenceNumber: BigInt(accountInfo.sequence_number),
-    originator: fromAccount.accountAddress,
-    currentAuthKey: _chunkJMOQXLEDjs.AccountAddress.from(accountInfo.authentication_key),
-    newPublicKey: newAccount.publicKey
-  });
-  const challengeHex = challenge.bcsToBytes();
-  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
-  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
-  const rawTxn = await generateTransaction({
-    aptosConfig,
-    sender: fromAccount.accountAddress,
-    data: {
-      function: "0x1::account::rotate_authentication_key",
-      functionArguments: [
-        new U8(fromAccount.signingScheme),
-        // from scheme
-        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
-        new U8(newAccount.signingScheme),
-        // to scheme
-        MoveVector.U8(newAccount.publicKey.toUint8Array()),
-        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array())
-      ],
-      abi: rotateAuthKeyAbi
+async function getLastestTransactionVersionForAddress(args) {
+  const { aptosConfig, accountAddress } = args;
+  const address = _chunkJMOQXLEDjs.AccountAddress.from(accountAddress).toString();
+  const whereCondition = {
+    signer: { _eq: accountAddress.toString() }
+  };
+  const graphqlQuery = {
+    query: GetSignatures,
+    variables: {
+      where_condition: whereCondition,
+      limit: 1,
+      order_by: { transaction_version: "desc" }
     }
-  });
-  return signAndSubmitTransaction({
+  };
+  const { signatures: data } = await queryIndexer({
     aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn
+    query: graphqlQuery,
+    originMethod: "getSignatures"
   });
+  if (data.length !== 1) {
+    throw new Error(`No signatures found for address ${address}`);
+  }
+  return Number(data[0].transaction_version);
 }
-async function rotateAuthKeyWithVerificationTransaction(args) {
-  const { aptosConfig, fromAccount, toAccount } = args;
-  const rawTxn = await generateTransaction({
-    aptosConfig,
-    sender: fromAccount.accountAddress,
-    data: {
-      function: "0x1::account::rotate_authentication_key_call",
-      functionArguments: [MoveVector.U8(toAccount.publicKey.authKey().toUint8Array())],
-      abi: rotateAuthKeyUnverifiedAbi
+async function getAccountAddressesForAuthKeys(args) {
+  const { aptosConfig, options, authKeys } = args;
+  const verified = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _136 => _136.verified]), () => ( true));
+  if (authKeys.length === 0) {
+    throw new Error("No authentication keys provided");
+  }
+  const whereCondition = {
+    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },
+    verified: { _eq: verified }
+  };
+  const graphqlQuery = {
+    query: GetAccountAddressesForAuthKey,
+    variables: {
+      where_condition: whereCondition
     }
-  });
-  const pendingTxn = await signAndSubmitTransaction({
+  };
+  const { auth_key_account_addresses: data } = await queryIndexer({
     aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn
+    query: graphqlQuery,
+    originMethod: "getAccountAddressesForAuthKeys"
   });
-  const txnResponse = await waitForTransaction({
-    aptosConfig,
-    transactionHash: pendingTxn.hash
+  return data.map((entry) => ({
+    authKey: new AuthenticationKey({ data: entry.auth_key }),
+    accountAddress: new (0, _chunkJMOQXLEDjs.AccountAddress)(_chunkJMOQXLEDjs.Hex.hexInputToUint8Array(entry.address)),
+    verified: entry.verified,
+    lastTransactionVersion: Number(entry.last_transaction_version)
+  }));
+}
+async function getAccountsForPublicKey(args) {
+  const { aptosConfig, publicKey } = args;
+  let baseKey = publicKey;
+  if (publicKey instanceof AnyPublicKey) {
+    baseKey = publicKey.publicKey;
+  }
+  const singleKeyPublicKeys = [];
+  if (baseKey instanceof Ed25519PublicKey) {
+    singleKeyPublicKeys.push(baseKey);
+  }
+  const anyPublicKey = new AnyPublicKey(baseKey);
+  singleKeyPublicKeys.push(anyPublicKey);
+  const singleKeyAuthKeyPublicKeyPairs = singleKeyPublicKeys.map((pubKey) => {
+    const authKey = pubKey.authKey();
+    return { authKey, publicKey: pubKey };
   });
-  if (!txnResponse.success) {
-    throw new Error(`Failed to rotate authentication key - ${txnResponse}`);
+  const multiKeyAuthKeys = await getAuthKeysForPublicKey({ aptosConfig, publicKey });
+  const [multiKeyPairs, authKeyAccountAddressPairs] = await Promise.all([
+    getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: multiKeyAuthKeys }),
+    getAccountAddressesForAuthKeys({
+      aptosConfig,
+      authKeys: multiKeyAuthKeys.concat(singleKeyAuthKeyPublicKeyPairs.map((pair) => pair.publicKey.authKey()))
+    })
+  ]);
+  const authKeyPublicKeyPairs = singleKeyAuthKeyPublicKeyPairs.concat(multiKeyPairs);
+  const result = [];
+  const authKeyToPublicKey = new Map(authKeyPublicKeyPairs.map((pair) => [pair.authKey.toString(), pair.publicKey]));
+  for (const authKeyAccountAddressPair of authKeyAccountAddressPairs) {
+    if (!authKeyToPublicKey.has(authKeyAccountAddressPair.authKey.toString())) {
+      throw new Error(`No publicKey found for authentication key ${authKeyAccountAddressPair.authKey}.`);
+    }
+    result.push({
+      accountAddress: authKeyAccountAddressPair.accountAddress,
+      publicKey: authKeyToPublicKey.get(authKeyAccountAddressPair.authKey.toString()),
+      verified: authKeyAccountAddressPair.verified,
+      lastTransactionVersion: authKeyAccountAddressPair.lastTransactionVersion
+    });
   }
-  const coinTxn = await transferCoinTransaction({
+  return result;
+}
+async function getPublicKeyFromAccountAddress(args) {
+  const { aptosConfig, accountAddress } = args;
+  const accountData = await getInfo2({ aptosConfig, accountAddress });
+  const lastTransactionVersion = await getLastestTransactionVersionForAddress({
     aptosConfig,
-    sender: toAccount.accountAddress,
-    recipient: toAccount.accountAddress,
-    amount: 1
+    accountAddress
+  });
+  console.log("lastTransactionVersion", lastTransactionVersion);
+  const transaction = await getTransactionByVersion({ aptosConfig, ledgerVersion: lastTransactionVersion });
+  if (!_chunkJMOQXLEDjs.isUserTransactionResponse.call(void 0, transaction)) {
+    throw new Error("Transaction is not a user transaction");
+  }
+  const { signature } = transaction;
+  if (!signature) {
+    throw new Error("Transaction has no signature");
+  }
+  let publicKey;
+  if (_chunkJMOQXLEDjs.isEd25519Signature.call(void 0, signature)) {
+    publicKey = new Ed25519PublicKey(signature.public_key);
+  } else if (_chunkJMOQXLEDjs.isMultiEd25519Signature.call(void 0, signature)) {
+    publicKey = new MultiEd25519PublicKey({
+      publicKeys: signature.public_keys.map((pk) => new Ed25519PublicKey(pk)),
+      threshold: signature.threshold
+    });
+  } else if (_chunkJMOQXLEDjs.isSingleSenderSingleKeySignature.call(void 0, signature)) {
+    publicKey = parsePublicKey(signature.public_key);
+  } else if (_chunkJMOQXLEDjs.isSingleSenderMultiKeySignature.call(void 0, signature)) {
+    const publicKeys = [];
+    for (const pk of signature.public_keys) {
+      publicKeys.push(parsePublicKey(pk));
+    }
+    publicKey = new MultiKey({
+      publicKeys,
+      signaturesRequired: signature.signatures_required
+    });
+  } else {
+    throw new Error("Unknown signature type");
+  }
+  if (publicKey.authKey().toString() !== accountData.authentication_key) {
+    throw new Error(
+      "Derived public key does not match authentication key. The most recent signature was likely a key rotation."
+    );
+  }
+  return publicKey;
+}
+function parsePublicKey(data) {
+  if (data.type === "keyless") {
+    const deserializer = Deserializer.fromHex(data.value);
+    return new AnyPublicKey(KeylessPublicKey.deserialize(deserializer));
+  }
+  if (data.type === "ed25519") {
+    return new AnyPublicKey(new Ed25519PublicKey(data.value));
+  }
+  if (data.type === "secp256k1_ecdsa") {
+    return new AnyPublicKey(new Secp256k1PublicKey(data.value));
+  }
+  throw new Error("Unknown public key type");
+}
+
+// src/api/utils.ts
+async function waitForIndexerOnVersion(args) {
+  if (args.minimumLedgerVersion !== void 0) {
+    await waitForIndexer({
+      aptosConfig: args.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: args.processorType
+    });
+  }
+}
+
+// src/internal/view.ts
+async function view(args) {
+  const { aptosConfig, payload, options } = args;
+  const viewFunctionPayload = await generateViewFunctionPayload({
+    ...payload,
+    aptosConfig
   });
-  const pendingCoinTxn = await signAndSubmitTransaction({
+  const serializer = new (0, _chunkJMOQXLEDjs.Serializer)();
+  viewFunctionPayload.serialize(serializer);
+  const bytes = serializer.toUint8Array();
+  const { data } = await postAptosFullNode({
     aptosConfig,
-    signer: fromAccount,
-    transaction: coinTxn
+    path: "view",
+    originMethod: "view",
+    contentType: "application/x.aptos.view_function+bcs" /* BCS_VIEW_FUNCTION */,
+    params: { ledger_version: _optionalChain([options, 'optionalAccess', _137 => _137.ledgerVersion]) },
+    body: bytes
   });
-  const coinTxnResponse = await waitForTransaction({
+  return data;
+}
+async function viewJson(args) {
+  const { aptosConfig, payload, options } = args;
+  const { data } = await postAptosFullNode({
     aptosConfig,
-    transactionHash: pendingCoinTxn.hash
+    originMethod: "viewJson",
+    path: "view",
+    params: { ledger_version: _optionalChain([options, 'optionalAccess', _138 => _138.ledgerVersion]) },
+    body: {
+      function: payload.function,
+      type_arguments: _nullishCoalesce(payload.typeArguments, () => ( [])),
+      arguments: _nullishCoalesce(payload.functionArguments, () => ( []))
+    }
   });
-  if (!coinTxnResponse.success) {
-    throw new Error(`Failed to verify authentication key - ${coinTxnResponse}`);
-  }
-  return coinTxnResponse;
+  return data;
 }
 
 // src/internal/abstraction.ts
@@ -11148,7 +11138,7 @@ var AccountAbstraction = class {
 };
 
 // src/api/account.ts
-var Account2 = class {
+var Account3 = class {
   /**
    * Creates an instance of the Aptos client with the provided configuration.
    *
@@ -11197,7 +11187,7 @@ var Account2 = class {
    * @group Account
    */
   async getAccountInfo(args) {
-    return getInfo({ aptosConfig: this.config, ...args });
+    return getInfo2({ aptosConfig: this.config, ...args });
   }
   /**
    * Queries for all modules in an account given an account address.
@@ -11234,7 +11224,7 @@ var Account2 = class {
    * @group Account
    */
   async getAccountModules(args) {
-    return getModules({ aptosConfig: this.config, ...args });
+    return getModules2({ aptosConfig: this.config, ...args });
   }
   /**
    * Queries for a specific account module given an account address and module name.
@@ -11266,7 +11256,7 @@ var Account2 = class {
    * @group Account
    */
   async getAccountModule(args) {
-    return getModule({ aptosConfig: this.config, ...args });
+    return getModule2({ aptosConfig: this.config, ...args });
   }
   /**
    * Queries account transactions given an account address.
@@ -12082,6 +12072,27 @@ var AptosConfig = class {
   }
 };
 
+// src/internal/coin.ts
+var coinTransferAbi = {
+  typeParameters: [{ constraints: [] }],
+  parameters: [new TypeTagAddress(), new TypeTagU64()]
+};
+async function transferCoinTransaction(args) {
+  const { aptosConfig, sender, recipient, amount, coinType, options } = args;
+  const coinStructType = _nullishCoalesce(coinType, () => ( APTOS_COIN));
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::aptos_account::transfer_coins",
+      typeArguments: [coinStructType],
+      functionArguments: [recipient, amount],
+      abi: coinTransferAbi
+    },
+    options
+  });
+}
+
 // src/api/coin.ts
 var Coin = class {
   /**
@@ -14666,11 +14677,11 @@ var General = class {
    * async function runExample() {
    *   // Querying the Aptos Indexer for ledger information
    *   const topUserTransactions = await aptos.queryIndexer({
-   *     query: `query MyQuery {
+   *     query: { query: `query MyQuery {
    *       ledger_infos {
    *         chain_id
    *       }
-   *     }`
+   *     }`}
    *   });
    *
    *   console.log(topUserTransactions);
@@ -16174,7 +16185,7 @@ var AccountSequenceNumber = class {
    * @category Transactions
    */
   async initialize() {
-    const { sequence_number: sequenceNumber } = await getInfo({
+    const { sequence_number: sequenceNumber } = await getInfo2({
       aptosConfig: this.aptosConfig,
       accountAddress: this.account.accountAddress
     });
@@ -16189,7 +16200,7 @@ var AccountSequenceNumber = class {
    * @category Transactions
    */
   async update() {
-    const { sequence_number: sequenceNumber } = await getInfo({
+    const { sequence_number: sequenceNumber } = await getInfo2({
       aptosConfig: this.aptosConfig,
       accountAddress: this.account.accountAddress
     });
@@ -17098,13 +17109,26 @@ var Transaction = class {
     return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
   /**
-   * Rotate an account's authentication key. After rotation, only the new private key can be used to sign transactions for the account.
-   * Note: Only legacy Ed25519 scheme is supported for now.
-   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+   * Rotates the authentication key for a given account.  Once an account is rotated, only the new private key
+   * or keyless signing scheme can be used to sign transactions for the account.
+   *
+   * @param args - The arguments for rotating the authentication key.
+   * @param args.fromAccount - The account from which the authentication key will be rotated.
+   * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey or toAuthKey.
+   * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount or toAuthKey.
+   * @param args.toAuthKey - (Optional) The new authentication key to rotate to. Can only be used with dangerouslySkipVerification=true.
+   * @param args.dangerouslySkipVerification - (Optional) If true, skips verification steps after rotation. Required when using toAuthKey.
    *
-   * @param args The arguments for rotating the auth key.
-   * @param args.fromAccount The account to rotate the auth key for.
-   * @param args.toNewPrivateKey The new private key to rotate to.
+   * @remarks
+   * This function supports three modes of rotation:
+   * 1. Using a target Account object (toAccount)
+   * 2. Using a new private key (toNewPrivateKey)
+   * 3. Using a raw authentication key (toAuthKey) - requires dangerouslySkipVerification=true
+   *
+   * When not using dangerouslySkipVerification, the function performs additional safety checks and account setup.
+   *
+   * If the new key is a multi key, skipping verification is dangerous because verification will publish the public key onchain and
+   * prevent users from being locked out of the account from loss of knowledge of one of the public keys.
    *
    * @returns PendingTransactionResponse
    *
@@ -17133,12 +17157,6 @@ var Transaction = class {
   async rotateAuthKey(args) {
     return rotateAuthKey({ aptosConfig: this.config, ...args });
   }
-  async rotateAuthKeyToMultiEd25519(args) {
-    return rotateAuthKeyToMultiEd25519({ aptosConfig: this.config, ...args });
-  }
-  async rotateAuthKeyWithVerificationTransaction(args) {
-    return rotateAuthKeyWithVerificationTransaction({ aptosConfig: this.config, ...args });
-  }
   /**
    * Sign a transaction that can later be submitted to the chain.
    * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.
@@ -18015,7 +18033,7 @@ var Aptos = class {
    */
   constructor(settings) {
     this.config = new AptosConfig(settings);
-    this.account = new Account2(this.config);
+    this.account = new Account3(this.config);
     this.abstraction = new AccountAbstraction(this.config);
     this.ans = new ANS(this.config);
     this.coin = new Coin(this.config);
@@ -18042,7 +18060,7 @@ function applyMixin(targetClass, baseClass, baseClassProp) {
     Object.defineProperty(targetClass.prototype, propertyName, propertyDescriptor);
   });
 }
-applyMixin(Aptos, Account2, "account");
+applyMixin(Aptos, Account3, "account");
 applyMixin(Aptos, AccountAbstraction, "abstraction");
 applyMixin(Aptos, ANS, "ans");
 applyMixin(Aptos, Coin, "coin");