@aptos-labs/ts-sdk 0.0.3 → 0.0.5

package/src/core/crypto/ed25519.ts

@@ -7,6 +7,7 @@ import { Deserializer } from "../../bcs/deserializer";
 import { Serializer } from "../../bcs/serializer";
 import { Hex } from "../hex";
 import { HexInput } from "../../types";
+import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
 
 /**
  * Represents the public key of an Ed25519 key pair.
@@ -70,7 +71,7 @@ export class Ed25519PublicKey extends PublicKey {
   verifySignature(args: { message: HexInput; signature: Ed25519Signature }): boolean {
     const { message, signature } = args;
     const rawMessage = Hex.fromHexInput(message).toUint8Array();
-    const rawSignature = Hex.fromHexInput(signature.toUint8Array()).toUint8Array();
+    const rawSignature = signature.toUint8Array();
     return nacl.sign.detached.verify(rawMessage, rawSignature, this.key.toUint8Array());
   }
 
@@ -98,6 +99,12 @@ export class Ed25519PrivateKey extends PrivateKey {
    */
   static readonly LENGTH: number = 32;
 
+  /**
+   * The Ed25519 key seed to use for BIP-32 compatibility
+   * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}
+   */
+  static readonly SLIP_0010_SEED = "ed25519 seed";
+
   /**
    * The Ed25519 signing key
    * @private
@@ -179,6 +186,46 @@ export class Ed25519PrivateKey extends PrivateKey {
     const bytes = this.signingKeyPair.publicKey;
     return new Ed25519PublicKey(bytes);
   }
+
+  /**
+   * Derives a private key from a mnemonic seed phrase.
+   *
+   * To derive multiple keys from the same phrase, change the path
+   *
+   * IMPORTANT: Ed25519 supports hardened derivation only (since it lacks a key homomorphism,
+   * so non-hardened derivation cannot work)
+   *
+   * @param path the BIP44 path
+   * @param mnemonics the mnemonic seed phrase
+   */
+  static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey {
+    if (!isValidHardenedPath(path)) {
+      throw new Error(`Invalid derivation path ${path}`);
+    }
+    return Ed25519PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
+  }
+
+  /**
+   * A private inner function so we can separate from the main fromDerivationPath() method
+   * to add tests to verify we create the keys correctly.
+   *
+   * @param path the BIP44 path
+   * @param seed the seed phrase created by the mnemonics
+   * @param offset the offset used for key derivation, defaults to 0x80000000
+   * @returns
+   */
+  private static fromDerivationPathInner(path: string, seed: Uint8Array, offset = HARDENED_OFFSET): Ed25519PrivateKey {
+    const { key, chainCode } = deriveKey(Ed25519PrivateKey.SLIP_0010_SEED, seed);
+
+    const segments = splitPath(path).map((el) => parseInt(el, 10));
+
+    // Derive the child key based on the path
+    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
+      key,
+      chainCode,
+    });
+    return new Ed25519PrivateKey(privateKey);
+  }
 }
 
 /**

package/src/core/crypto/hdKey.ts

@@ -0,0 +1,105 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+import * as bip39 from "@scure/bip39";
+
+export type DerivedKeys = {
+  key: Uint8Array;
+  chainCode: Uint8Array;
+};
+
+/**
+ * Aptos derive path is 637
+ */
+export const APTOS_HARDENED_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+'\/[0-9]+'?$/;
+export const APTOS_BIP44_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+\/[0-9]+$/;
+
+/**
+ * A list of supported key types and associated seeds
+ */
+export enum KeyType {
+  ED25519 = "ed25519 seed",
+}
+
+export const HARDENED_OFFSET = 0x80000000;
+
+/**
+ * Aptos derive path is 637
+ *
+ * Parse and validate a path that is compliant to BIP-44 in form m/44'/637'/{account_index}'/{change_index}/{address_index}
+ * for Secp256k1
+ *
+ * Note that for secp256k1, last two components must be non-hardened.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0/0`).
+ */
+export function isValidBIP44Path(path: string): boolean {
+  return APTOS_BIP44_REGEX.test(path);
+}
+
+/**
+ * Aptos derive path is 637
+ *
+ * Parse and validate a path that is compliant to SLIP-0010 and BIP-44
+ * in form m/44'/637'/{account_index}'/{change_index}'/{address_index}'.
+ * See SLIP-0010 {@link https://github.com/satoshilabs/slips/blob/master/slip-0044.md}
+ * See BIP-44 {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+ *
+ * Note that for Ed25519, all components must be hardened.
+ * This is because non-hardened [PK] derivation would not work due to Ed25519's lack of a key homomorphism.
+ * Specifically, you cannot derive the PK associated with derivation path a/b/c given the PK of a/b.
+ * This is because the PK in Ed25519 is, more or less, computed as 𝑔𝐻(𝑠𝑘),
+ * with the hash function breaking the homomorphism.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0'/0'`).
+ */
+export function isValidHardenedPath(path: string): boolean {
+  return APTOS_HARDENED_REGEX.test(path);
+}
+
+export const deriveKey = (hashSeed: Uint8Array | string, data: Uint8Array | string): DerivedKeys => {
+  const digest = hmac.create(sha512, hashSeed).update(data).digest();
+  return {
+    key: digest.slice(0, 32),
+    chainCode: digest.slice(32),
+  };
+};
+
+/**
+ * Derive a child key from the private key
+ * @param key
+ * @param chainCode
+ * @param index
+ * @constructor
+ */
+export const CKDPriv = ({ key, chainCode }: DerivedKeys, index: number): DerivedKeys => {
+  const buffer = new ArrayBuffer(4);
+  new DataView(buffer).setUint32(0, index);
+  const indexBytes = new Uint8Array(buffer);
+  const zero = new Uint8Array([0]);
+  const data = new Uint8Array([...zero, ...key, ...indexBytes]);
+  return deriveKey(chainCode, data);
+};
+
+const removeApostrophes = (val: string): string => val.replace("'", "");
+
+/**
+ * Splits derive path into segments
+ * @param path
+ */
+export const splitPath = (path: string): Array<string> => path.split("/").slice(1).map(removeApostrophes);
+
+/**
+ * Normalizes the mnemonic by removing extra whitespace and making it lowercase
+ * @param mnemonic the mnemonic seed phrase
+ */
+export const mnemonicToSeed = (mnemonic: string): Uint8Array => {
+  const normalizedMnemonic = mnemonic
+    .trim()
+    .split(/\s+/)
+    .map((part) => part.toLowerCase())
+    .join(" ");
+  return bip39.mnemonicToSeedSync(normalizedMnemonic);
+};

package/src/core/crypto/index.ts

@@ -6,3 +6,4 @@ export * from "./ed25519";
 export * from "./multiEd25519";
 export * from "./secp256k1";
 export * from "./multiKey";
+export * from "./hdKey";

package/src/core/crypto/secp256k1.ts

@@ -3,10 +3,12 @@
 
 import { sha3_256 } from "@noble/hashes/sha3";
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { HDKey } from "@scure/bip32";
 import { PrivateKey, PublicKey, Signature } from "./asymmetricCrypto";
 import { Deserializer, Serializer } from "../../bcs";
 import { Hex } from "../hex";
 import { HexInput } from "../../types";
+import { isValidBIP44Path, mnemonicToSeed } from "./hdKey";
 
 /**
  * Represents the Secp256k1 ecdsa public key
@@ -173,6 +175,40 @@ export class Secp256k1PrivateKey extends PrivateKey {
     const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
     return new Secp256k1PublicKey(bytes);
   }
+
+  /**
+   * Derives a private key from a mnemonic seed phrase.
+   *
+   * @param path the BIP44 path
+   * @param mnemonics the mnemonic seed phrase
+   *
+   * @returns The generated key
+   */
+  static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey {
+    if (!isValidBIP44Path(path)) {
+      throw new Error(`Invalid derivation path ${path}`);
+    }
+    return Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
+  }
+
+  /**
+   * A private inner function so we can separate from the main fromDerivationPath() method
+   * to add tests to verify we create the keys correctly.
+   *
+   * @param path the BIP44 path
+   * @param seed the seed phrase created by the mnemonics
+   *
+   * @returns The generated key
+   */
+  private static fromDerivationPathInner(path: string, seed: Uint8Array): Secp256k1PrivateKey {
+    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);
+    // library returns privateKey as Uint8Array | null
+    if (privateKey === null) {
+      throw new Error("Invalid key");
+    }
+
+    return new Secp256k1PrivateKey(privateKey);
+  }
 }
 
 /**

package/src/index.ts

@@ -8,4 +8,3 @@ export * from "./core";
 export * from "./transactions";
 export * from "./types";
 export * from "./utils/apiEndpoints";
-export * from "./utils/hdKey";

package/src/internal/account.ts

@@ -10,10 +10,9 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
-import { AccountAddress } from "../core/accountAddress";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account } from "../core/account";
 import { PrivateKey } from "../core/crypto/asymmetricCrypto";
-import { Hex } from "../core/hex";
 import { getTableItem, queryIndexer } from "./general";
 import {
   AccountData,
@@ -22,7 +21,6 @@ import {
   GetAccountOwnedObjectsResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
-  HexInput,
   LedgerVersion,
   MoveModuleBytecode,
   MoveResource,
@@ -57,26 +55,29 @@ import { memoizeAsync } from "../utils/memoize";
 import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
 import { AnyPublicKey } from "../core/crypto/anyPublicKey";
 
-export async function getInfo(args: { aptosConfig: AptosConfig; accountAddress: HexInput }): Promise<AccountData> {
+export async function getInfo(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<AccountData> {
   const { aptosConfig, accountAddress } = args;
   const { data } = await getAptosFullNode<{}, AccountData>({
     aptosConfig,
     originMethod: "getInfo",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,
   });
   return data;
 }
 
 export async function getModules(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs & LedgerVersion;
 }): Promise<MoveModuleBytecode[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveModuleBytecode[]>({
     aptosConfig,
     originMethod: "getModules",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/modules`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
     params: {
       ledger_version: options?.ledgerVersion,
       start: options?.offset,
@@ -95,7 +96,7 @@ export async function getModules(args: {
  */
 export async function getModule(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   moduleName: string;
   options?: LedgerVersion;
 }): Promise<MoveModuleBytecode> {
@@ -114,7 +115,7 @@ export async function getModule(args: {
 
 async function getModuleInner(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   moduleName: string;
   options?: LedgerVersion;
 }): Promise<MoveModuleBytecode> {
@@ -123,7 +124,7 @@ async function getModuleInner(args: {
   const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({
     aptosConfig,
     originMethod: "getModule",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/module/${moduleName}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
     params: { ledger_version: options?.ledgerVersion },
   });
   return data;
@@ -131,28 +132,28 @@ async function getModuleInner(args: {
 
 export async function getTransactions(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs;
 }): Promise<TransactionResponse[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, TransactionResponse[]>({
     aptosConfig,
     originMethod: "getTransactions",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/transactions`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/transactions`,
     params: { start: options?.offset, limit: options?.limit },
   });
 }
 
 export async function getResources(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs & LedgerVersion;
 }): Promise<MoveResource[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveResource[]>({
     aptosConfig,
     originMethod: "getResources",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/resources`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,
     params: {
       ledger_version: options?.ledgerVersion,
       start: options?.offset,
@@ -163,7 +164,7 @@ export async function getResources(args: {
 
 export async function getResource<T extends {}>(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   resourceType: MoveStructType;
   options?: LedgerVersion;
 }): Promise<T> {
@@ -171,7 +172,7 @@ export async function getResource<T extends {}>(args: {
   const { data } = await getAptosFullNode<{}, MoveResource>({
     aptosConfig,
     originMethod: "getResource",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/resource/${resourceType}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,
     params: { ledger_version: options?.ledgerVersion },
   });
   return data.data as T;
@@ -179,7 +180,7 @@ export async function getResource<T extends {}>(args: {
 
 export async function lookupOriginalAccountAddress(args: {
   aptosConfig: AptosConfig;
-  authenticationKey: HexInput;
+  authenticationKey: AccountAddressInput;
   options?: LedgerVersion;
 }): Promise<AccountAddress> {
   const { aptosConfig, authenticationKey, options } = args;
@@ -197,24 +198,26 @@ export async function lookupOriginalAccountAddress(args: {
     address_map: { handle },
   } = resource;
 
+  const authKeyAddress = AccountAddress.from(authenticationKey);
+
   // If the address is not found in the address map, which means its not rotated
   // then return the address as is
   try {
-    const originalAddress = await getTableItem({
+    const originalAddress = await getTableItem<string>({
       aptosConfig,
       handle,
       data: {
-        key: Hex.fromHexInput(authenticationKey).toString(),
+        key: authKeyAddress.toString(),
         key_type: "address",
         value_type: "address",
       },
       options,
     });
 
-    return AccountAddress.fromHexInput(originalAddress);
+    return AccountAddress.from(originalAddress);
   } catch (err) {
     if (err instanceof AptosApiError && err.data.error_code === "table_item_not_found") {
-      return AccountAddress.fromHexInput(authenticationKey);
+      return authKeyAddress;
     }
 
     throw err;
@@ -223,15 +226,15 @@ export async function lookupOriginalAccountAddress(args: {
 
 export async function getAccountTokensCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
 
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number } } = {
     owner_address: { _eq: address },
-    amount: { _gt: "0" },
+    amount: { _gt: 0 },
   };
 
   const graphqlQuery = {
@@ -252,7 +255,7 @@ export async function getAccountTokensCount(args: {
 
 export async function getAccountOwnedTokens(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -260,12 +263,13 @@ export async function getAccountOwnedTokens(args: {
   };
 }): Promise<GetAccountOwnedTokensQueryResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
-    owner_address: { _eq: address },
-    amount: { _gt: 0 },
-  };
+  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number }; token_standard?: { _eq: string } } =
+    {
+      owner_address: { _eq: address },
+      amount: { _gt: 0 },
+    };
 
   if (options?.tokenStandard) {
     whereCondition.token_standard = { _eq: options?.tokenStandard };
@@ -292,8 +296,8 @@ export async function getAccountOwnedTokens(args: {
 
 export async function getAccountOwnedTokensFromCollectionAddress(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
-  collectionAddress: HexInput;
+  accountAddress: AccountAddressInput;
+  collectionAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -301,10 +305,15 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
   };
 }): Promise<GetAccountOwnedTokensFromCollectionResponse> {
   const { aptosConfig, accountAddress, collectionAddress, options } = args;
-  const ownerAddress = AccountAddress.fromHexInput(accountAddress).toString();
-  const collAddress = Hex.fromHexInput(collectionAddress).toString();
-
-  const whereCondition: any = {
+  const ownerAddress = AccountAddress.from(accountAddress).toStringLong();
+  const collAddress = AccountAddress.from(collectionAddress).toStringLong();
+
+  const whereCondition: {
+    owner_address: { _eq: string };
+    current_token_data: { collection_id: { _eq: string } };
+    amount: { _gt: number };
+    token_standard?: { _eq: string };
+  } = {
     owner_address: { _eq: ownerAddress },
     current_token_data: { collection_id: { _eq: collAddress } },
     amount: { _gt: 0 },
@@ -335,7 +344,7 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
 
 export async function getAccountCollectionsWithOwnedTokens(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -343,9 +352,13 @@ export async function getAccountCollectionsWithOwnedTokens(args: {
   };
 }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: {
+    owner_address: { _eq: string };
+    amount: { _gt: number };
+    current_collection?: { token_standard: { _eq: string } };
+  } = {
     owner_address: { _eq: address },
     amount: { _gt: 0 },
   };
@@ -377,11 +390,11 @@ export async function getAccountCollectionsWithOwnedTokens(args: {
 
 export async function getAccountTransactionsCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
 
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
   const graphqlQuery = {
     query: GetAccountTransactionsCount,
@@ -403,16 +416,16 @@ export async function getAccountTransactionsCount(args: {
 
 export async function getAccountCoinsData(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;
   };
 }): Promise<GetAccountCoinsDataResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string } } = {
     owner_address: { _eq: address },
   };
 
@@ -437,10 +450,10 @@ export async function getAccountCoinsData(args: {
 
 export async function getAccountCoinsCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
   const graphqlQuery = {
     query: GetAccountCoinsCount,
@@ -462,16 +475,16 @@ export async function getAccountCoinsCount(args: {
 
 export async function getAccountOwnedObjects(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
   };
 }): Promise<GetAccountOwnedObjectsResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string } } = {
     owner_address: { _eq: address },
   };
   const graphqlQuery = {
@@ -492,6 +505,15 @@ export async function getAccountOwnedObjects(args: {
   return data.current_objects;
 }
 
+/**
+ * NOTE: There is a potential issue once unified single signer scheme will be adopted
+ * by the community.
+ *
+ * Becuase on could create 2 accounts with the same private key with this new authenticator type,
+ * we’ll need to determine the order in which we lookup the accounts. First unified
+ * scheme and then legacy scheme vs first legacy scheme and then unified scheme.
+ *
+ */
 export async function deriveAccountFromPrivateKey(args: {
   aptosConfig: AptosConfig;
   privateKey: PrivateKey;
@@ -502,29 +524,29 @@ export async function deriveAccountFromPrivateKey(args: {
   if (privateKey instanceof Secp256k1PrivateKey) {
     // private key is secp256k1, therefore we know it for sure uses a single signer key
     const authKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.SingleKey });
-    const address = new AccountAddress({ data: authKey.toUint8Array() });
+    const address = authKey.derivedAddress();
     return Account.fromPrivateKeyAndAddress({ privateKey, address });
   }
 
   if (privateKey instanceof Ed25519PrivateKey) {
     // lookup single sender ed25519
-    const SingleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
       publicKey,
       scheme: SigningScheme.SingleKey,
     });
     const isSingleSenderTransactionAuthenticator = await isAccountExist({
-      authKey: SingleSenderTransactionAuthenticatorAuthKey,
+      authKey: singleSenderTransactionAuthenticatorAuthKey,
       aptosConfig,
     });
     if (isSingleSenderTransactionAuthenticator) {
-      const address = new AccountAddress({ data: SingleSenderTransactionAuthenticatorAuthKey.toUint8Array() });
-      return Account.fromPrivateKeyAndAddress({ privateKey, address });
+      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();
+      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: false });
     }
     // lookup legacy ed25519
     const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.Ed25519 });
     const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
     if (isLegacyEd25519) {
-      const address = new AccountAddress({ data: legacyAuthKey.toUint8Array() });
+      const address = legacyAuthKey.derivedAddress();
       return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: true });
     }
   }
@@ -537,13 +559,13 @@ export async function isAccountExist(args: { aptosConfig: AptosConfig; authKey:
   const { aptosConfig, authKey } = args;
   const accountAddress = await lookupOriginalAccountAddress({
     aptosConfig,
-    authenticationKey: authKey.toString(),
+    authenticationKey: authKey.derivedAddress(),
   });
 
   try {
     await getInfo({
       aptosConfig,
-      accountAddress: accountAddress.toString(),
+      accountAddress,
     });
     return true;
   } catch (error: any) {