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

package/dist/esm/chunk-SPVJXZL5.mjs

@@ -1,865 +0,0 @@
-import {
-  getTableItem
-} from "./chunk-YT7V6AVJ.mjs";
-import {
-  generateTransaction,
-  signAndSubmitTransaction
-} from "./chunk-HKQY5GXT.mjs";
-import {
-  getInfo,
-  getModule,
-  getModules
-} from "./chunk-FRLS4GRM.mjs";
-import {
-  getTransactionByVersion,
-  waitForTransaction
-} from "./chunk-BU43ZFDJ.mjs";
-import {
-  queryIndexer
-} from "./chunk-YK66QBML.mjs";
-import {
-  GetAccountAddressesForAuthKey,
-  GetAccountCoinsCount,
-  GetAccountCoinsData,
-  GetAccountCollectionsWithOwnedTokens,
-  GetAccountOwnedTokens,
-  GetAccountOwnedTokensFromCollection,
-  GetAccountTokensCount,
-  GetAccountTransactionsCount,
-  GetAuthKeysForPublicKey,
-  GetMultiKeyForAuthKey,
-  GetObjectData,
-  GetSignatures
-} from "./chunk-EPTUAWRA.mjs";
-import {
-  MultiEd25519Account
-} from "./chunk-5ORUQZAR.mjs";
-import {
-  Account
-} from "./chunk-WHSS6I7T.mjs";
-import {
-  Ed25519Account
-} from "./chunk-62LC4PPC.mjs";
-import {
-  RotationProofChallenge
-} from "./chunk-QJ6CGH7N.mjs";
-import {
-  TypeTagU8,
-  TypeTagVector
-} from "./chunk-DDZGHA66.mjs";
-import {
-  createObjectAddress
-} from "./chunk-6I37A76G.mjs";
-import {
-  MultiEd25519PublicKey
-} from "./chunk-3TUV6YMI.mjs";
-import {
-  MultiKey
-} from "./chunk-DMFRIING.mjs";
-import {
-  AnyPublicKey
-} from "./chunk-IPUAVRGL.mjs";
-import {
-  Secp256k1PrivateKey,
-  Secp256k1PublicKey
-} from "./chunk-ECTX2FGD.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  KeylessPublicKey
-} from "./chunk-T573PCIR.mjs";
-import {
-  Ed25519PrivateKey,
-  Ed25519PublicKey
-} from "./chunk-TFW6N66T.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  getAptosFullNode,
-  paginateWithCursor,
-  paginateWithObfuscatedCursor
-} from "./chunk-XQFUKBY7.mjs";
-import {
-  AptosApiError
-} from "./chunk-32UQAST6.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveVector
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  U8
-} from "./chunk-QSYWLSSN.mjs";
-import {
-  isEd25519Signature,
-  isMultiEd25519Signature,
-  isSingleSenderMultiKeySignature,
-  isSingleSenderSingleKeySignature,
-  isUserTransactionResponse
-} from "./chunk-SQNS4SFV.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-import {
-  APTOS_COIN
-} from "./chunk-5QHMFYVL.mjs";
-
-// 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 getTransactions(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithCursor({
-    aptosConfig,
-    originMethod: "getTransactions",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}/transactions`,
-    params: { start: options?.offset, limit: options?.limit }
-  });
-}
-async function getResources(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithObfuscatedCursor({
-    aptosConfig,
-    originMethod: "getResources",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,
-    params: {
-      ledger_version: options?.ledgerVersion,
-      offset: options?.offset,
-      limit: options?.limit ?? 999
-    }
-  });
-}
-async function getResource(args) {
-  const { aptosConfig, accountAddress, resourceType, options } = args;
-  const { data } = await getAptosFullNode({
-    aptosConfig,
-    originMethod: "getResource",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,
-    params: { ledger_version: options?.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 = AccountAddress.from(authenticationKey);
-  try {
-    const originalAddress = await getTableItem({
-      aptosConfig,
-      handle,
-      data: {
-        key: authKeyAddress.toString(),
-        key_type: "address",
-        value_type: "address"
-      },
-      options
-    });
-    return 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 = 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 = AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address },
-    amount: { _gt: 0 }
-  };
-  if (options?.tokenStandard) {
-    whereCondition.token_standard = { _eq: options?.tokenStandard };
-  }
-  const graphqlQuery = {
-    query: GetAccountOwnedTokens,
-    variables: {
-      where_condition: whereCondition,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.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 = AccountAddress.from(accountAddress).toStringLong();
-  const collAddress = AccountAddress.from(collectionAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: ownerAddress },
-    current_token_data: { collection_id: { _eq: collAddress } },
-    amount: { _gt: 0 }
-  };
-  if (options?.tokenStandard) {
-    whereCondition.token_standard = { _eq: options?.tokenStandard };
-  }
-  const graphqlQuery = {
-    query: GetAccountOwnedTokensFromCollection,
-    variables: {
-      where_condition: whereCondition,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.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 = AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address }
-  };
-  if (options?.tokenStandard) {
-    whereCondition.current_collection = {
-      token_standard: { _eq: options?.tokenStandard }
-    };
-  }
-  const graphqlQuery = {
-    query: GetAccountCollectionsWithOwnedTokens,
-    variables: {
-      where_condition: whereCondition,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.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 = 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 getAccountCoinAmount(args) {
-  const { aptosConfig, accountAddress, coinType, faMetadataAddress } = args;
-  let coinAssetType = coinType;
-  let faAddress;
-  if (coinType !== void 0 && faMetadataAddress !== void 0) {
-    faAddress = AccountAddress.from(faMetadataAddress).toStringLong();
-  } else if (coinType !== void 0 && faMetadataAddress === void 0) {
-    if (coinType === APTOS_COIN) {
-      faAddress = AccountAddress.A.toStringLong();
-    } else {
-      faAddress = createObjectAddress(AccountAddress.A, coinType).toStringLong();
-    }
-  } else if (coinType === void 0 && faMetadataAddress !== void 0) {
-    const addr = AccountAddress.from(faMetadataAddress);
-    faAddress = addr.toStringLong();
-    if (addr === AccountAddress.A) {
-      coinAssetType = APTOS_COIN;
-    }
-  } else {
-    throw new Error("Either coinType, fungibleAssetAddress, or both must be provided");
-  }
-  const address = AccountAddress.from(accountAddress).toStringLong();
-  let where = { asset_type: { _eq: faAddress } };
-  if (coinAssetType !== void 0) {
-    where = { asset_type: { _in: [coinAssetType, faAddress] } };
-  }
-  const data = await getAccountCoinsData({
-    aptosConfig,
-    accountAddress: address,
-    options: {
-      where
-    }
-  });
-  return data[0] ? data[0].amount : 0;
-}
-async function getAccountCoinsData(args) {
-  const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    ...options?.where,
-    owner_address: { _eq: address }
-  };
-  const graphqlQuery = {
-    query: GetAccountCoinsData,
-    variables: {
-      where_condition: whereCondition,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.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 = 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 = AccountAddress.from(accountAddress).toStringLong();
-  const whereCondition = {
-    owner_address: { _eq: address }
-  };
-  const graphqlQuery = {
-    query: GetObjectData,
-    variables: {
-      where_condition: whereCondition,
-      offset: options?.offset,
-      limit: options?.limit,
-      order_by: options?.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 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: [],
-  parameters: [
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8()
-  ]
-};
-async function rotateAuthKey(args) {
-  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
-  });
-  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,
-    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
-    newPublicKey: newAccount.publicKey
-  });
-  const challengeHex = challenge.bcsToBytes();
-  const proofSignedByCurrentKey = fromAccount.sign(challengeHex);
-  const proofSignedByNewKey = 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(proofSignedByCurrentKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewKey.toUint8Array())
-      ],
-      abi: rotateAuthKeyAbi
-    }
-  });
-  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 = options?.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 = 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(`No signatures found for address ${address}`);
-  }
-  return Number(data[0].transaction_version);
-}
-async function getAccountAddressesForAuthKeys(args) {
-  const { aptosConfig, options, authKeys } = args;
-  const verified = options?.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 AccountAddress(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 getInfo2({ aptosConfig, accountAddress });
-  const lastTransactionVersion = await getLastestTransactionVersionForAddress({
-    aptosConfig,
-    accountAddress
-  });
-  console.log("lastTransactionVersion", lastTransactionVersion);
-  const transaction = await getTransactionByVersion({ aptosConfig, ledgerVersion: lastTransactionVersion });
-  if (!isUserTransactionResponse(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 (isEd25519Signature(signature)) {
-    publicKey = new Ed25519PublicKey(signature.public_key);
-  } else if (isMultiEd25519Signature(signature)) {
-    publicKey = new MultiEd25519PublicKey({
-      publicKeys: signature.public_keys.map((pk) => new Ed25519PublicKey(pk)),
-      threshold: signature.threshold
-    });
-  } else if (isSingleSenderSingleKeySignature(signature)) {
-    publicKey = parsePublicKey(signature.public_key);
-  } else if (isSingleSenderMultiKeySignature(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;
-}
-async function getMultiKeyFromAuthenticationKey(args) {
-  const { aptosConfig, authKey } = args;
-  const result = await getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: [authKey] });
-  if (result.length === 0) {
-    throw new Error(`No multikey found for the given authentication key ${authKey}`);
-  }
-  if (result.length > 1) {
-    throw new Error(`More than one multikey found for the given authentication key ${authKey}`);
-  }
-  return result[0].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");
-}
-
-export {
-  getInfo2 as getInfo,
-  getModules2 as getModules,
-  getModule2 as getModule,
-  getTransactions,
-  getResources,
-  getResource,
-  lookupOriginalAccountAddress,
-  getAccountTokensCount,
-  getAccountOwnedTokens,
-  getAccountOwnedTokensFromCollectionAddress,
-  getAccountCollectionsWithOwnedTokens,
-  getAccountTransactionsCount,
-  getAccountCoinAmount,
-  getAccountCoinsData,
-  getAccountCoinsCount,
-  getAccountOwnedObjects,
-  deriveAccountFromPrivateKey,
-  isAccountExist,
-  rotateAuthKey,
-  getAccountsForPublicKey,
-  getPublicKeyFromAccountAddress,
-  getMultiKeyFromAuthenticationKey
-};
-//# sourceMappingURL=chunk-SPVJXZL5.mjs.map