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

package/dist/esm/chunk-KEZG4OGH.mjs

@@ -0,0 +1,725 @@
+import {
+  getTableItem
+} from "./chunk-EMKV5DFX.mjs";
+import {
+  getTransactionByVersion
+} from "./chunk-SDIZSFCQ.mjs";
+import {
+  queryIndexer
+} from "./chunk-HLTYSM7H.mjs";
+import {
+  GetAccountAddressesForAuthKey,
+  GetAccountCoinsCount,
+  GetAccountCoinsData,
+  GetAccountCollectionsWithOwnedTokens,
+  GetAccountOwnedTokens,
+  GetAccountOwnedTokensFromCollection,
+  GetAccountTokensCount,
+  GetAccountTransactionsCount,
+  GetAuthKeysForPublicKey,
+  GetMultiKeyForAuthKey,
+  GetObjectData,
+  GetSignatures
+} from "./chunk-EPTUAWRA.mjs";
+import {
+  Account
+} from "./chunk-KEKNIJHE.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 {
+  memoizeAsync
+} from "./chunk-BEYIOC2H.mjs";
+import {
+  getAptosFullNode,
+  paginateWithCursor,
+  paginateWithObfuscatedCursor
+} from "./chunk-XQFUKBY7.mjs";
+import {
+  AptosApiError
+} from "./chunk-32UQAST6.mjs";
+import {
+  AccountAddress
+} from "./chunk-CXLXUSCG.mjs";
+import {
+  isEd25519Signature,
+  isMultiEd25519Signature,
+  isSingleSenderSignature,
+  isUserTransactionResponse
+} from "./chunk-QW7RQDZ5.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 getInfo(args) {
+  const { aptosConfig, accountAddress } = args;
+  const { data } = await getAptosFullNode({
+    aptosConfig,
+    originMethod: "getInfo",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}`
+  });
+  return data;
+}
+async function getModules(args) {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor({
+    aptosConfig,
+    originMethod: "getModules",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      offset: options?.offset,
+      limit: options?.limit ?? 1e3
+    }
+  });
+}
+async function getModule(args) {
+  if (args.options?.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/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
+    params: { ledger_version: options?.ledgerVersion }
+  });
+  return data;
+}
+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 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 = 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
+    }
+  };
+  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 = 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 getInfo({ aptosConfig, accountAddress });
+  const lastTransactionVersion = await getLastestTransactionVersionForAddress({
+    aptosConfig,
+    accountAddress
+  });
+  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 (isSingleSenderSignature(signature)) {
+    if (signature.public_key.type === "keyless") {
+      const deserializer = Deserializer.fromHex(signature.public_key.value);
+      publicKey = new AnyPublicKey(KeylessPublicKey.deserialize(deserializer));
+    } else if (signature.public_key.type === "ed25519") {
+      publicKey = new AnyPublicKey(new Ed25519PublicKey(signature.public_key.value));
+    } else if (signature.public_key.type === "secp256k1_ecdsa") {
+      publicKey = new AnyPublicKey(new Secp256k1PublicKey(signature.public_key.value));
+    } else {
+      throw new Error("Unknown public key type");
+    }
+  } 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;
+}
+
+export {
+  getInfo,
+  getModules,
+  getModule,
+  getTransactions,
+  getResources,
+  getResource,
+  lookupOriginalAccountAddress,
+  getAccountTokensCount,
+  getAccountOwnedTokens,
+  getAccountOwnedTokensFromCollectionAddress,
+  getAccountCollectionsWithOwnedTokens,
+  getAccountTransactionsCount,
+  getAccountCoinAmount,
+  getAccountCoinsData,
+  getAccountCoinsCount,
+  getAccountOwnedObjects,
+  deriveAccountFromPrivateKey,
+  isAccountExist,
+  getAccountsForPublicKey,
+  getPublicKeyFromAccountAddress,
+  getMultiKeyFromAuthenticationKey
+};
+//# sourceMappingURL=chunk-KEZG4OGH.mjs.map