@aptos-labs/ts-sdk 0.0.3 → 0.0.5

package/src/api/transactionSubmission.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AptosConfig } from "./aptosConfig";
-import { Account } from "../core";
+import { Account, AccountAddressInput, PrivateKey } from "../core";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
 import {
   AnyRawTransaction,
@@ -15,11 +15,13 @@ import {
   InputSingleSignerTransaction,
   InputSimulateTransactionData,
   InputGenerateTransactionOptions,
+  InputSubmitTransactionData,
 } from "../transactions/types";
-import { UserTransactionResponse, PendingTransactionResponse, HexInput } from "../types";
+import { UserTransactionResponse, PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
 import {
   generateTransaction,
   publicPackageTransaction,
+  rotateAuthKey,
   signAndSubmitTransaction,
   signTransaction,
   simulateTransaction,
@@ -47,7 +49,7 @@ export class TransactionSubmission {
   /**
    * Generates any transaction by passing in the required arguments
    *
-   * @param args.sender The transaction sender's account address as a HexInput
+   * @param args.sender The transaction sender's account address as a AccountAddressInput
    * @param args.data EntryFunctionData | ScriptData | MultiSigData
    * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction
    * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions
@@ -75,10 +77,10 @@ export class TransactionSubmission {
    * }
    * ```
    *
-   * @return A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+   * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
    * ```
    * {
-   *  rawTransaction: Uint8Array,
+   *  rawTransaction: RawTransaction,
    *  secondarySignerAddresses? : Array<AccountAddress>,
    *  feePayerAddress?: AccountAddress
    * }
@@ -92,10 +94,11 @@ export class TransactionSubmission {
    * Sign a transaction that can later be submitted to chain
    *
    * @param args.signer The signer account to sign the transaction
-   * @param args.transaction A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
+   * @param args.asFeePayer optional. If the signer is also the fee payer
    * ```
    * {
-   *  rawTransaction: Uint8Array,
+   *  rawTransaction: RawTransaction,
    *  secondarySignerAddresses? : Array<AccountAddress>,
    *  feePayerAddress?: AccountAddress
    * }
@@ -104,8 +107,19 @@ export class TransactionSubmission {
    * @return The signer AccountAuthenticator
    */
   /* eslint-disable class-methods-use-this */
-  signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
-    return signTransaction({ ...args });
+  signTransaction(args: {
+    signer: Account;
+    transaction: AnyRawTransaction;
+    asFeePayer?: boolean;
+  }): AccountAuthenticator {
+    const { signer, transaction, asFeePayer } = args;
+    if (asFeePayer) {
+      transaction.feePayerAddress = signer.accountAddress;
+    }
+    return signTransaction({
+      signer,
+      transaction,
+    });
   }
 
   /**
@@ -130,14 +144,7 @@ export class TransactionSubmission {
    *
    * @return PendingTransactionResponse
    */
-  async submitTransaction(args: {
-    transaction: AnyRawTransaction;
-    senderAuthenticator: AccountAuthenticator;
-    secondarySignerAuthenticators?: {
-      feePayerAuthenticator?: AccountAuthenticator;
-      additionalSignersAuthenticators?: Array<AccountAuthenticator>;
-    };
-  }): Promise<PendingTransactionResponse> {
+  async submitTransaction(args: InputSubmitTransactionData): Promise<PendingTransactionResponse> {
     return submitTransaction({ aptosConfig: this.config, ...args });
   }
 
@@ -145,10 +152,10 @@ export class TransactionSubmission {
    * Sign and submit a single signer transaction to chain
    *
    * @param args.signer The signer account to sign the transaction
-   * @param args.transaction A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
    * ```
    * {
-   *  rawTransaction: Uint8Array,
+   *  rawTransaction: RawTransaction,
    *  secondarySignerAddresses? : Array<AccountAddress>,
    *  feePayerAddress?: AccountAddress
    * }
@@ -182,11 +189,25 @@ export class TransactionSubmission {
    * @returns A SingleSignerTransaction that can be simulated or submitted to chain
    */
   async publishPackageTransaction(args: {
-    account: HexInput;
+    account: AccountAddressInput;
     metadataBytes: HexInput;
     moduleBytecode: Array<HexInput>;
     options?: InputGenerateTransactionOptions;
   }): Promise<InputSingleSignerTransaction> {
     return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
+
+  /**
+   * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for
+   * the account.
+   * Note: Only legacy Ed25519 scheme is supported for now.
+   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+   * @param args.fromAccount The account to rotate the auth key for
+   * @param args.toNewPrivateKey The new private key to rotate to
+   *
+   * @returns PendingTransactionResponse
+   */
+  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKey }): Promise<TransactionResponse> {
+    return rotateAuthKey({ aptosConfig: this.config, ...args });
+  }
 }

package/src/bcs/deserializer.ts

@@ -222,10 +222,10 @@ export class Deserializer {
    * @example
    * // serialize a vector of addresses
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromHexInputRelaxed("0x1"),
-   *   AccountAddress.fromHexInputRelaxed("0x2"),
-   *   AccountAddress.fromHexInputRelaxed("0xa"),
-   *   AccountAddress.fromHexInputRelaxed("0xb"),
+   *   AccountAddress.fromRelaxed("0x1"),
+   *   AccountAddress.fromRelaxed("0x2"),
+   *   AccountAddress.fromRelaxed("0xa"),
+   *   AccountAddress.fromRelaxed("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);

package/src/bcs/serializable/moveStructs.ts

@@ -42,11 +42,6 @@ import { EntryFunctionArgument, TransactionArgument } from "../../transactions/i
  * const vecOfStrings = new MoveVector([new MoveString("hello"), new MoveString("world")]);
  * const vecOfStrings2 = MoveVector.MoveString(["hello", "world"]);
  *
- * // where MySerializableStruct is a class you've made that implements Serializable
- * const vecOfSerializableValues = new MoveVector<MySerializableStruct>([
- *   new MySerializableStruct("hello", "world"),
- *   new MySerializableStruct("foo", "bar"),
- * ]);
  * @params
  * values: an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
@@ -73,9 +68,11 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    */
   serializeForScriptFunction(serializer: Serializer): void {
     // runtime check to ensure that you can't serialize anything other than vector<u8>
-    // TODO: consider adding support for MoveString later?
     const isU8 = this.values[0] instanceof U8;
-    if (!isU8) {
+    // if the inner array is length 0, we can't check the type because it has no instance, so we assume it's a u8
+    // it may not be, but we don't care because regardless of a vector's type,
+    // a zero-length vector is serialized to a single byte value: 0
+    if (!isU8 && this.values[0] !== undefined) {
       throw new Error("Script function arguments only accept u8 vectors");
     }
     serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.U8Vector);
@@ -172,7 +169,7 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    * const v = MoveVector.Bool([true, false, true, false]);
-   * @params values: an array of `numbers` to convert to Bools
+   * @params values: an array of `bools` to convert to Bools
    * @returns a `MoveVector<Bool>`
    */
   static Bool(values: Array<boolean>): MoveVector<Bool> {
@@ -184,7 +181,7 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    * const v = MoveVector.MoveString(["hello", "world"]);
-   * @params values: an array of `numbers` to convert to MoveStrings
+   * @params values: an array of `strings` to convert to MoveStrings
    * @returns a `MoveVector<MoveString>`
    */
   static MoveString(values: Array<string>): MoveVector<MoveString> {
@@ -202,8 +199,9 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * NOTE: This will not work with types that aren't of the Serializable class.
    *
-   * If you want to use types that merely implement Deserializable,
-   * please use the deserializeVector function in the Deserializer class.
+   * If you're looking for a more flexible deserialization function, you can use the deserializeVector function
+   * in the Deserializer class.
+   *
    * @example
    * const vec = MoveVector.deserialize(deserializer, U64);
    * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.
@@ -242,8 +240,10 @@ export class MoveString extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    // serialize the string, load it into a vector<u8> and serialize it as a script vector<u8> argument
-    const vectorU8 = MoveVector.U8(this.bcsToBytes());
+    // Serialize the string as a fixed byte string, i.e., without the length prefix
+    const fixedStringBytes = this.bcsToBytes().slice(1);
+    // Put those bytes into a vector<u8> and serialize it as a script function argument
+    const vectorU8 = MoveVector.U8(fixedStringBytes);
     vectorU8.serializeForScriptFunction(serializer);
   }
 

package/src/bcs/serializer.ts

@@ -298,10 +298,10 @@ export class Serializer {
    * @param values The array of BCS Serializable values
    * @example
    * const addresses = new Array<AccountAddress>(
-   *   AccountAddress.fromHexInputRelaxed("0x1"),
-   *   AccountAddress.fromHexInputRelaxed("0x2"),
-   *   AccountAddress.fromHexInputRelaxed("0xa"),
-   *   AccountAddress.fromHexInputRelaxed("0xb"),
+   *   AccountAddress.fromRelaxed("0x1"),
+   *   AccountAddress.fromRelaxed("0x2"),
+   *   AccountAddress.fromRelaxed("0xa"),
+   *   AccountAddress.fromRelaxed("0xb"),
    * );
    * const serializer = new Serializer();
    * serializer.serializeVector(addresses);

package/src/client/core.ts

@@ -32,8 +32,11 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
     "content-type": contentType ?? MimeType.JSON,
   };
 
-  if (overrides?.TOKEN) {
-    headers.Authorization = `Bearer ${overrides?.TOKEN}`;
+  // TODO - auth token is being used only for faucet, it breaks full node requests.
+  // Find a more sophisticated way than that but without the need to add the
+  // auth_token on every `aptos.fundAccount()` call
+  if (overrides?.AUTH_TOKEN && url.includes("faucet")) {
+    headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
   }
 
   /*
@@ -94,11 +97,18 @@ export async function aptosRequest<Req, Res>(
     return result;
   }
 
-  const errorMessage = errors[result.status];
+  let errorMessage: string;
 
-  throw new AptosApiError(
-    options,
-    result,
-    errorMessage ?? `Unhandled Error ${response.status} : ${response.statusText}`,
-  );
+  // If it is the shape of an AptosApiError, convert it properly
+  if ("message" in response.data && "error_code" in response.data) {
+    errorMessage = JSON.stringify(response.data);
+  } else if (result.status in errors) {
+    // If it's not an API type, it must come form infra, these are prehandled
+    errorMessage = errors[result.status];
+  } else {
+    // Everything else is unhandled
+    errorMessage = `Unhandled Error ${response.status} : ${response.statusText}`;
+  }
+
+  throw new AptosApiError(options, result, errorMessage);
 }

package/src/core/account.ts

@@ -9,7 +9,6 @@ import { MultiEd25519PublicKey } from "./crypto/multiEd25519";
 import { Secp256k1PrivateKey, Secp256k1PublicKey } from "./crypto/secp256k1";
 import { Hex } from "./hex";
 import { GenerateAccount, HexInput, SigningScheme, SigningSchemeInput } from "../types";
-import { derivePrivateKeyFromMnemonic, KeyType } from "../utils/hdKey";
 import { AnyPublicKey } from "./crypto/anyPublicKey";
 
 /**
@@ -26,11 +25,14 @@ import { AnyPublicKey } from "./crypto/anyPublicKey";
  * `SingleSender` supports `ED25519` and `Secp256k1`, and `MultiSender` supports
  * `MultiED25519`.
  *
- * In TypeScript SDK, we support all of these options
- * @generate default to generate Unified keys, with an optional `legacy` boolean argument
- * that lets you generate new keys conforming to the Legacy authentication.
+ * In TypeScript SDK, we support all of these options:
+ *
+ * @generate default to generate Legacy Ed25519 keys, with an optional `legacy` boolean argument
+ * that lets you generate new keys conforming to the Unified authentication.
+ *
  * @fromPrivateKey derives an account by a provided private key and address, with an optional
- * `legacy` boolean argument that lets you generate new keys conforming to the Legacy authentication.
+ * `legacy` boolean argument that lets you generate new keys conforming to the Unified authentication.
+ *
  * @fromDerivationPath derives an account with bip44 path and mnemonics,
  *
  */
@@ -70,13 +72,14 @@ export class Account {
    */
   private constructor(args: { privateKey: PrivateKey; address: AccountAddress; legacy?: boolean }) {
     const { privateKey, address, legacy } = args;
+    const useLegacy = legacy ?? true;
 
     // Derive the public key from the private key
     this.publicKey = privateKey.publicKey();
 
     // Derive the signing scheme from the public key
     if (this.publicKey instanceof Ed25519PublicKey) {
-      if (legacy) {
+      if (useLegacy) {
         this.signingScheme = SigningScheme.Ed25519;
       } else {
         this.publicKey = new AnyPublicKey(this.publicKey);
@@ -97,7 +100,8 @@ export class Account {
 
   /**
    * Derives an account with random private key and address.
-   * Default generation is using the Unified flow with ED25519 key
+   *
+   * Default generation is using the Legacy ED25519 key
    *
    * @param args optional. Unify GenerateAccount type for Legacy and Unified keys
    *
@@ -123,37 +127,75 @@ export class Account {
    * @returns Account with the given signing scheme
    */
   static generate(args?: GenerateAccount): Account {
+    const useLegacy = args?.legacy ?? true;
+
     let privateKey: PrivateKey;
+    let publicKey: PublicKey;
 
     switch (args?.scheme) {
       case SigningSchemeInput.Secp256k1Ecdsa:
         privateKey = Secp256k1PrivateKey.generate();
+        publicKey = new AnyPublicKey(privateKey.publicKey());
         break;
       default:
         privateKey = Ed25519PrivateKey.generate();
+        if (useLegacy === false) {
+          publicKey = new AnyPublicKey(privateKey.publicKey());
+        } else {
+          publicKey = privateKey.publicKey();
+        }
     }
+    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
+
+    const address = authKey.derivedAddress();
+    return new Account({ privateKey, address, legacy: args?.legacy });
+  }
 
-    let publicKey = privateKey.publicKey();
-    if (!args?.legacy) {
+  /**
+   * Instantiates an account given a private key.
+   *
+   * This is used as a local calculation and therefore is used to instantiate an `Account`
+   * that has not had its authentication key rotated.
+   *
+   * @param privateKey PrivateKey - private key of the account
+   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+   * to generating a Legacy Ed25519 keypair
+   *
+   * @returns Account
+   */
+  static fromPrivateKey(args: { privateKey: PrivateKey; legacy?: boolean }): Account {
+    const { privateKey, legacy } = args;
+    const useLegacy = legacy ?? true;
+
+    let publicKey;
+    if (privateKey instanceof Secp256k1PrivateKey) {
+      // Secp256k1 single sender
       publicKey = new AnyPublicKey(privateKey.publicKey());
+    } else if (privateKey instanceof Ed25519PrivateKey) {
+      // legacy Ed25519
+      if (useLegacy) {
+        publicKey = privateKey.publicKey();
+      } else {
+        // Ed25519 single sender
+        publicKey = new AnyPublicKey(privateKey.publicKey());
+      }
+    } else {
+      throw new Error(`Unsupported private key ${privateKey}`);
     }
 
-    const address = new AccountAddress({
-      data: Account.authKey({
-        publicKey,
-      }).toUint8Array(),
-    });
-    return new Account({ privateKey, address, legacy: args?.legacy });
+    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
+    const address = authKey.derivedAddress();
+    return new Account({ privateKey, address, legacy: useLegacy });
   }
 
   /**
    * Instantiates an account given a private key and a specified account address.
    * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
    *
-   * @param privateKey PrivateKey - private key of the account
-   * @param address The account address
-   * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
-   * Defaults to deriving an authentication key with a Unified scheme
+   * @param args.privateKey PrivateKey - the underlying private key for the account
+   * @param args.address AccountAddress - The account address the `Account` will sign for
+   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+   * to generating a Legacy Ed25519 keypair
    *
    * @returns Account
    */
@@ -169,19 +211,35 @@ export class Account {
   /**
    * Derives an account with bip44 path and mnemonics,
    *
-   * @param args.path the BIP44 derive path (e.g. m/44'/637'/0'/0'/0')
+   * @param args.scheme The signing scheme to derive with
+   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
+   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
    * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
    * @param args.mnemonic the mnemonic seed phrase of the account
-   * @returns AptosAccount
+   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
+   * to generating a Legacy Ed25519 keypair
+   *
+   * @returns Account
    */
-  static fromDerivationPath(args: { path: string; mnemonic: string }): Account {
-    const { path, mnemonic } = args;
-    const { key } = derivePrivateKeyFromMnemonic(KeyType.ED25519, path, mnemonic);
-    const privateKey = new Ed25519PrivateKey(key);
-    const publicKey = privateKey.publicKey();
-    const authKey = Account.authKey({ publicKey });
-    const address = new AccountAddress({ data: authKey.toUint8Array() });
-    return new Account({ privateKey, address, legacy: true });
+  static fromDerivationPath(args: {
+    scheme: SigningSchemeInput;
+    path: string;
+    mnemonic: string;
+    legacy?: boolean;
+  }): Account {
+    const { path, mnemonic, scheme, legacy } = args;
+    let privateKey: PrivateKey;
+    switch (scheme) {
+      case SigningSchemeInput.Secp256k1Ecdsa:
+        privateKey = Secp256k1PrivateKey.fromDerivationPath(path, mnemonic);
+        break;
+      case SigningSchemeInput.Ed25519:
+        privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
+        break;
+      default:
+        throw new Error(`Unsupported scheme ${scheme}`);
+    }
+    return Account.fromPrivateKey({ privateKey, legacy });
   }
 
   /**
@@ -190,12 +248,11 @@ export class Account {
    * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
    *
    * @param args.publicKey PublicKey - public key of the account
-   * @returns Authentication key for the associated account
+   * @returns The authentication key for the associated account
    */
-  static authKey(args: { publicKey: PublicKey }): Hex {
+  static authKey(args: { publicKey: PublicKey }): AuthenticationKey {
     const { publicKey } = args;
-    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
-    return authKey.data;
+    return AuthenticationKey.fromPublicKey({ publicKey });
   }
 
   /**

package/src/core/accountAddress.ts

@@ -21,6 +21,8 @@ export enum AddressInvalidReason {
   INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES",
 }
 
+export type AccountAddressInput = HexInput | AccountAddress;
+
 /**
  * NOTE: Only use this class for account addresses. For other hex data, e.g. transaction
  * hashes, use the Hex class.
@@ -53,30 +55,30 @@ export class AccountAddress extends Serializable implements TransactionArgument
    */
   static readonly LONG_STRING_LENGTH: number = 64;
 
-  static ZERO: AccountAddress = AccountAddress.fromString("0x0");
+  static ZERO: AccountAddress = AccountAddress.from("0x0");
 
-  static ONE: AccountAddress = AccountAddress.fromString("0x1");
+  static ONE: AccountAddress = AccountAddress.from("0x1");
 
-  static TWO: AccountAddress = AccountAddress.fromString("0x2");
+  static TWO: AccountAddress = AccountAddress.from("0x2");
 
-  static THREE: AccountAddress = AccountAddress.fromString("0x3");
+  static THREE: AccountAddress = AccountAddress.from("0x3");
 
-  static FOUR: AccountAddress = AccountAddress.fromString("0x4");
+  static FOUR: AccountAddress = AccountAddress.from("0x4");
 
   /**
    * Creates an instance of AccountAddress from a Uint8Array.
    *
    * @param args.data A Uint8Array representing an account address.
    */
-  constructor(args: { data: Uint8Array }) {
+  constructor(input: Uint8Array) {
     super();
-    if (args.data.length !== AccountAddress.LENGTH) {
+    if (input.length !== AccountAddress.LENGTH) {
       throw new ParsingError(
         "AccountAddress data should be exactly 32 bytes long",
         AddressInvalidReason.INCORRECT_NUMBER_OF_BYTES,
       );
     }
-    this.data = args.data;
+    this.data = input;
   }
 
   /**
@@ -207,7 +209,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
    */
   static deserialize(deserializer: Deserializer): AccountAddress {
     const bytes = deserializer.deserializeFixedBytes(AccountAddress.LENGTH);
-    return new AccountAddress({ data: bytes });
+    return new AccountAddress(bytes);
   }
 
   // ===
@@ -331,37 +333,39 @@ export class AccountAddress extends Serializable implements TransactionArgument
       throw new ParsingError(`Hex characters are invalid: ${error.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
     }
 
-    return new AccountAddress({ data: addressBytes });
+    return new AccountAddress(addressBytes);
   }
 
   /**
-   * Convenience method for creating an AccountAddress from HexInput. For
-   * more information on how this works, see the constructor and fromString.
-   *
-   * @param input A hex string or Uint8Array representing an account address.
+   * Convenience method for creating an AccountAddress from all known inputs.
    *
-   * @returns An instance of AccountAddress.
+   * This handles, Uint8array, string, and AccountAddress itself
+   * @param input
    */
-  static fromHexInput(input: HexInput): AccountAddress {
+  static fromRelaxed(input: AccountAddressInput): AccountAddress {
+    if (input instanceof AccountAddress) {
+      return input;
+    }
     if (input instanceof Uint8Array) {
-      return new AccountAddress({ data: input });
+      return new AccountAddress(input);
     }
-    return AccountAddress.fromString(input);
+    return AccountAddress.fromStringRelaxed(input);
   }
 
   /**
-   * Convenience method for creating an AccountAddress from HexInput. For
-   * more information on how this works, see the constructor and fromStringRelaxed.
+   * Convenience method for creating an AccountAddress from all known inputs.
    *
-   * @param hexInput A hex string or Uint8Array representing an account address.
-   *
-   * @returns An instance of AccountAddress.
+   * This handles, Uint8array, string, and AccountAddress itself
+   * @param input
    */
-  static fromHexInputRelaxed(hexInput: HexInput): AccountAddress {
-    if (hexInput instanceof Uint8Array) {
-      return new AccountAddress({ data: hexInput });
+  static from(input: AccountAddressInput): AccountAddress {
+    if (input instanceof AccountAddress) {
+      return input;
     }
-    return AccountAddress.fromStringRelaxed(hexInput);
+    if (input instanceof Uint8Array) {
+      return new AccountAddress(input);
+    }
+    return AccountAddress.fromString(input);
   }
 
   // ===
@@ -377,12 +381,12 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * @returns valid = true if the string is valid, valid = false if not. If the string
    * is not valid, invalidReason will be set explaining why it is invalid.
    */
-  static isValid(args: { input: string; relaxed?: boolean }): ParsingResult<AddressInvalidReason> {
+  static isValid(args: { input: AccountAddressInput; relaxed?: boolean }): ParsingResult<AddressInvalidReason> {
     try {
       if (args.relaxed) {
-        AccountAddress.fromStringRelaxed(args.input);
+        AccountAddress.fromRelaxed(args.input);
       } else {
-        AccountAddress.fromString(args.input);
+        AccountAddress.from(args.input);
       }
       return { valid: true };
     } catch (e) {

package/src/core/authenticationKey.ts

@@ -18,13 +18,13 @@ import { Deserializer } from "../bcs/deserializer";
  * their private key(s) associated with the account without changing the address that hosts their account.
  * @see {@link https://aptos.dev/concepts/accounts | Account Basics}
  *
- * Note: AuthenticationKey only supports Ed25519 and MultiEd25519 public keys for now.
- *
  * Account addresses can be derived from AuthenticationKey
  */
 export class AuthenticationKey extends Serializable {
   /**
    * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
+   *
+   * The data to hash depends on the underlying public key type and the derivation scheme.
    */
   static readonly LENGTH: number = 32;
 
@@ -66,10 +66,11 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Creates an AuthenticationKey from seed bytes and a scheme
+   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
+   *
+   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
    *
-   * This allows for the creation of AuthenticationKeys that are not derived from Public Keys directly
-   * @param args
+   * @param args - the public key and scheme to use for the derivation
    */
   public static fromPublicKeyAndScheme(args: { publicKey: PublicKey; scheme: AuthenticationKeyScheme }) {
     const { publicKey, scheme } = args;
@@ -102,7 +103,8 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Converts a PublicKey(s) to AuthenticationKey
+   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the
+   * instance of the PublicKey type passed in.
    *
    * @param args.publicKey
    * @returns AuthenticationKey
@@ -129,12 +131,12 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Derives an account address from AuthenticationKey. Since current AccountAddress is 32 bytes,
-   * AuthenticationKey bytes are directly translated to AccountAddress.
+   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,
+   * the AuthenticationKey bytes are directly translated to an AccountAddress.
    *
    * @returns AccountAddress
    */
   derivedAddress(): AccountAddress {
-    return new AccountAddress({ data: this.data.toUint8Array() });
+    return new AccountAddress(this.data.toUint8Array());
   }
 }