@aptos-labs/ts-sdk 1.33.1 → 1.33.2

package/src/account/FederatedKeylessAccount.ts

@@ -9,7 +9,6 @@ import { EphemeralKeyPair } from "./EphemeralKeyPair";
 import { Deserializer, Serializer } from "../bcs";
 import { FederatedKeylessPublicKey } from "../core/crypto/federatedKeyless";
 import { AbstractKeylessAccount, ProofFetchCallback } from "./AbstractKeylessAccount";
-import { Hex } from "../core";
 
 /**
  * Account implementation for the FederatedKeyless authentication scheme.
@@ -21,13 +20,19 @@ import { Hex } from "../core";
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
  * EphemeralKeyPair, and corresponding proof.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export class FederatedKeylessAccount extends AbstractKeylessAccount {
   /**
    * The FederatedKeylessPublicKey associated with the account
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   readonly publicKey: FederatedKeylessPublicKey;
 
+  readonly audless: boolean;
+
   /**
    * Use the static generator `FederatedKeylessAccount.create(...)` instead.
    * Creates a KeylessAccount instance using the provided parameters.
@@ -42,7 +47,7 @@ export class FederatedKeylessAccount extends AbstractKeylessAccount {
    * @param args.uidKey - Optional key for user identification, defaults to "sub".
    * @param args.proofFetchCallback - Optional callback function for fetching proof.
    */
-  private constructor(args: {
+  constructor(args: {
     address?: AccountAddress;
     ephemeralKeyPair: EphemeralKeyPair;
     iss: string;
@@ -55,10 +60,12 @@ export class FederatedKeylessAccount extends AbstractKeylessAccount {
     proofFetchCallback?: ProofFetchCallback;
     jwt: string;
     verificationKeyHash?: HexInput;
+    audless?: boolean;
   }) {
     const publicKey = FederatedKeylessPublicKey.create(args);
     super({ publicKey, ...args });
     this.publicKey = publicKey;
+    this.audless = args.audless ?? false;
   }
 
   /**
@@ -106,7 +113,7 @@ export class FederatedKeylessAccount extends AbstractKeylessAccount {
    * @returns
    */
   static fromBytes(bytes: HexInput): FederatedKeylessAccount {
-    return FederatedKeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
+    return FederatedKeylessAccount.deserialize(Deserializer.fromHex(bytes));
   }
 
   /**

package/src/account/KeylessAccount.ts

@@ -19,10 +19,14 @@ import { Hex } from "../core/hex";
  *
  * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
  * EphemeralKeyPair, and corresponding proof.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export class KeylessAccount extends AbstractKeylessAccount {
   /**
    * The KeylessPublicKey associated with the account
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   readonly publicKey: KeylessPublicKey;
 
@@ -44,8 +48,10 @@ export class KeylessAccount extends AbstractKeylessAccount {
    * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
    * @param args.proofFetchCallback - Optional callback function for fetching proof.
    * @param args.jwt - A JSON Web Token used for authentication.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
-  private constructor(args: {
+  constructor(args: {
     address?: AccountAddress;
     ephemeralKeyPair: EphemeralKeyPair;
     iss: string;
@@ -68,6 +74,8 @@ export class KeylessAccount extends AbstractKeylessAccount {
    * This function ensures that both the transaction bytes and the proof are properly serialized.
    *
    * @param serializer - The serializer instance used to convert the transaction data into bytes.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   serialize(serializer: Serializer): void {
     super.serialize(serializer);
@@ -79,6 +87,8 @@ export class KeylessAccount extends AbstractKeylessAccount {
    *
    * @param deserializer - The deserializer instance used to retrieve the serialized data.
    * @returns A KeylessAccount instance created from the deserialized data.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static deserialize(deserializer: Deserializer): KeylessAccount {
     const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } =
@@ -121,6 +131,8 @@ export class KeylessAccount extends AbstractKeylessAccount {
    * @param args.pepper - A hexadecimal input used for additional security.
    * @param args.uidKey - Optional key for user identification, defaults to "sub".
    * @param args.proofFetchCallback - Optional callback function for fetching proof.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static create(args: {
     address?: AccountAddress;

package/src/account/MultiKeyAccount.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account } from "./Account";
+import type { Account } from "./Account";
 import { MultiKey, MultiKeySignature, PublicKey } from "../core/crypto";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { HexInput, SigningScheme } from "../types";
@@ -9,12 +9,16 @@ import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/acco
 import { AnyRawTransaction } from "../transactions/types";
 import { AbstractKeylessAccount, KeylessSigner } from "./AbstractKeylessAccount";
 import { AptosConfig } from "../api/aptosConfig";
+import { SingleKeyAccount, SingleKeySigner, SingleKeySignerOrLegacyEd25519Account } from "./SingleKeyAccount";
+import { Ed25519Account } from "./Ed25519Account";
 
 /**
  * Arguments required to verify a multi-key signature against a given message.
  *
  * @param message - The original message that was signed.
  * @param signature - The multi-key signature to be verified.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export interface VerifyMultiKeySignatureArgs {
   message: HexInput;
@@ -28,33 +32,45 @@ export interface VerifyMultiKeySignatureArgs {
  * It signs messages using an array of M accounts, each corresponding to a public key in the {@link MultiKey}.
  *
  * Note: Generating a signer instance does not create the account on-chain.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export class MultiKeyAccount implements Account, KeylessSigner {
   /**
    * Public key associated with the account
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   readonly publicKey: MultiKey;
 
   /**
    * Account address associated with the account
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   readonly accountAddress: AccountAddress;
 
   /**
    * Signing scheme used to sign transactions
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
-  readonly signingScheme: SigningScheme;
+  readonly signingScheme: SigningScheme = SigningScheme.MultiKey;
 
   /**
    * The signers used to sign messages.  These signers should correspond to public keys in the
    * MultiKeyAccount's public key.  The number of signers should be equal or greater
    * than this.publicKey.signaturesRequired
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   readonly signers: Account[];
 
   /**
    * An array of indices where for signer[i], signerIndicies[i] is the index of the corresponding public key in
    * publicKey.publicKeys.  Used to derive the right public key to use for verification.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   // TODO: Rename Indicies to Indices
   readonly signerIndicies: number[];
@@ -68,27 +84,56 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * @param args.multiKey - The multikey of the account consisting of N public keys and a number M representing the required signatures.
    * @param args.signers - An array of M signers that will be used to sign the transaction.
    * @param args.address - An optional account address input. If not provided, the derived address from the public key will be used.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
-  constructor(args: { multiKey: MultiKey; signers: Account[]; address?: AccountAddressInput }) {
-    const { multiKey, signers, address } = args;
+  constructor(args: {
+    multiKey: MultiKey;
+    signers: SingleKeySignerOrLegacyEd25519Account[];
+    address?: AccountAddressInput;
+  }) {
+    const { multiKey, address } = args;
+
+    const signers: SingleKeySigner[] = args.signers.map((signer) =>
+      signer instanceof Ed25519Account ? SingleKeyAccount.fromEd25519Account(signer) : signer,
+    );
+
+    if (multiKey.signaturesRequired > signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `Not enough signers provided to satisfy the required signatures. Need ${multiKey.signaturesRequired} signers, but only ${signers.length} provided`,
+      );
+    } else if (multiKey.signaturesRequired < signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `More signers provided than required. Need ${multiKey.signaturesRequired} signers, but ${signers.length} provided`,
+      );
+    }
 
     this.publicKey = multiKey;
-    this.signingScheme = SigningScheme.MultiKey;
 
     this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
 
-    // Get the index of each respective signer in the bitmap
+    // For each signer, find its corresponding position in the MultiKey's public keys array
     const bitPositions: number[] = [];
     for (const signer of signers) {
-      bitPositions.push(this.publicKey.getIndex(signer.publicKey));
+      bitPositions.push(this.publicKey.getIndex(signer.getAnyPublicKey()));
     }
-    // Zip signers and bit positions and sort signers by bit positions in order
-    // to ensure the signature is signed in ascending order according to the bitmap.
-    // Authentication on chain will fail otherwise.
+
+    // Create pairs of [signer, position] and sort them by position
+    // This sorting is critical because:
+    // 1. The on-chain verification expects signatures to be in ascending order by bit position
+    // 2. The bitmap must match the order of signatures when verifying
     const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);
     signersAndBitPosition.sort((a, b) => a[1] - b[1]);
+
+    // Extract the sorted signers and their positions into separate arrays
     this.signers = signersAndBitPosition.map((value) => value[0]);
     this.signerIndicies = signersAndBitPosition.map((value) => value[1]);
+
+    // Create a bitmap representing which public keys from the MultiKey are being used
+    // This bitmap is used during signature verification to identify which public keys
+    // should be used to verify each signature
     this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
   }
 
@@ -100,11 +145,13 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * @param args.signaturesRequired - The number of signatures required to authorize a transaction.
    * @param args.signers - An array of M signers that will be used to sign the transaction.
    * @returns MultiKeyAccount - The newly created MultiKeyAccount.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static fromPublicKeysAndSigners(args: {
     publicKeys: PublicKey[];
     signaturesRequired: number;
-    signers: Account[];
+    signers: SingleKeySignerOrLegacyEd25519Account[];
   }): MultiKeyAccount {
     const { publicKeys, signaturesRequired, signers } = args;
     const multiKey = new MultiKey({ publicKeys, signaturesRequired });
@@ -116,6 +163,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    *
    * @param account - The account to check.
    * @returns A boolean indicating whether the account is a multi-key account.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static isMultiKeySigner(account: Account): account is MultiKeyAccount {
     return account instanceof MultiKeyAccount;
@@ -126,6 +175,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * account's public key.
    * @param message - The signing message, represented as binary input in hexadecimal format.
    * @returns An instance of AccountAuthenticatorMultiKey that includes the signature and the public key.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {
     return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));
@@ -136,6 +187,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * account's public key.
    * @param transaction - The raw transaction to be signed.
    * @returns An AccountAuthenticatorMultiKey containing the signature of the transaction along with the account's public key.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {
     return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
@@ -145,6 +198,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * Waits for any proofs on KeylessAccount signers to be fetched. This ensures that signing with the KeylessAccount does not
    * fail due to missing proofs.
    * @return {Promise<void>} A promise that resolves when all proofs have been fetched.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   async waitForProofFetch(): Promise<void> {
     const keylessSigners = this.signers.filter(
@@ -157,6 +212,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
   /**
    * Validates that the Keyless Account can be used to sign transactions.
    * @return
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   async checkKeylessAccountValidity(aptosConfig: AptosConfig): Promise<void> {
     const keylessSigners = this.signers.filter(
@@ -168,8 +225,10 @@ export class MultiKeyAccount implements Account, KeylessSigner {
 
   /**
    * Sign the given message using the MultiKeyAccount's signers
-   * @param message in HexInput format
+   * @param data - The data to be signed in HexInput format.
    * @returns MultiKeySignature
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   sign(data: HexInput): MultiKeySignature {
     const signatures = [];
@@ -185,6 +244,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    *
    * @param transaction - The transaction to be signed.
    * @returns MultiKeySignature - An object containing the aggregated signatures and a bitmap of the signatures.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signTransaction(transaction: AnyRawTransaction): MultiKeySignature {
     const signatures = [];
@@ -203,6 +264,8 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * @param args.message - The raw message data in HexInput format.
    * @param args.signature - The signed message MultiKeySignature containing multiple signatures.
    * @returns A boolean indicating whether the signatures are valid for the message.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   verifySignature(args: VerifyMultiKeySignatureArgs): boolean {
     const { message, signature } = args;

package/src/account/SingleKeyAccount.ts

@@ -1,19 +1,42 @@
 import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
 import { type HexInput, SigningScheme, SigningSchemeInput } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKey, Secp256k1PrivateKey } from "../core/crypto";
+import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKeyInput, Secp256k1PrivateKey } from "../core/crypto";
 import type { Account } from "./Account";
 import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
 import { AnyRawTransaction } from "../transactions/types";
+import { Ed25519Account } from "./Ed25519Account";
+
+/**
+ * An interface which defines if an Account utilizes SingleKey signing.
+ *
+ * Such an account will use the AnyPublicKey enum to represent its public key when deriving the auth key.
+ */
+export interface SingleKeySigner extends Account {
+  getAnyPublicKey(): AnyPublicKey;
+}
+
+export function isSingleKeySigner(obj: unknown): obj is SingleKeySigner {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "getAnyPublicKey" in obj &&
+    typeof (obj as any).getAnyPublicKey === "function"
+  );
+}
+
+export type SingleKeySignerOrLegacyEd25519Account = SingleKeySigner | Ed25519Account;
 
 /**
  * Arguments required to create a single key signer.
  *
  * @param privateKey - The private key used for signing.
  * @param address - Optional account address associated with the signer.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export interface SingleKeySignerConstructorArgs {
-  privateKey: PrivateKey;
+  privateKey: PrivateKeyInput;
   address?: AccountAddressInput;
 }
 
@@ -21,6 +44,8 @@ export interface SingleKeySignerConstructorArgs {
  * Arguments for generating a single key signer.
  *
  * @param scheme - The signing scheme to be used.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export interface SingleKeySignerGenerateArgs {
   scheme?: SigningSchemeInput;
@@ -28,6 +53,8 @@ export interface SingleKeySignerGenerateArgs {
 
 /**
  * The arguments for generating a single key signer from a specified derivation path.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs & {
   path: string;
@@ -39,6 +66,8 @@ export type SingleKeySignerFromDerivationPathArgs = SingleKeySignerGenerateArgs
  *
  * @param message - The message to be verified, represented in hexadecimal format.
  * @param signature - The signature that corresponds to the message.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
 export interface VerifySingleKeySignatureArgs {
   message: HexInput;
@@ -51,12 +80,16 @@ export interface VerifySingleKeySignatureArgs {
  * Currently, the only supported signature schemes are Ed25519 and Secp256k1.
  *
  * Note: Generating a signer instance does not create the account on-chain.
+ * @group Implementation
+ * @category Account (On-Chain Model)
  */
-export class SingleKeyAccount implements Account {
+export class SingleKeyAccount implements Account, SingleKeySigner {
   /**
    * Private key associated with the account
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
-  readonly privateKey: PrivateKey;
+  readonly privateKey: PrivateKeyInput;
 
   readonly publicKey: AnyPublicKey;
 
@@ -71,6 +104,8 @@ export class SingleKeyAccount implements Account {
    * @param args - The constructor arguments for initializing the SingleKeySigner.
    * @param args.privateKey - The private key used for signing.
    * @param args.address - The optional account address; if not provided, it will derive the address from the public key.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   constructor(args: SingleKeySignerConstructorArgs) {
     const { privateKey, address } = args;
@@ -79,6 +114,10 @@ export class SingleKeyAccount implements Account {
     this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
   }
 
+  getAnyPublicKey(): AnyPublicKey {
+    return this.publicKey;
+  }
+
   /**
    * Derives an account from a randomly generated private key based on the specified signing scheme.
    * The default generation scheme is Ed25519, but it can also support Secp256k1Ecdsa.
@@ -87,10 +126,12 @@ export class SingleKeyAccount implements Account {
    * @param args.scheme - The signing scheme to use for generating the private key. Defaults to SigningSchemeInput.Ed25519.
    * @returns An account with the generated private key based on the specified signing scheme.
    * @throws Error if an unsupported signature scheme is provided.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static generate(args: SingleKeySignerGenerateArgs = {}) {
     const { scheme = SigningSchemeInput.Ed25519 } = args;
-    let privateKey: PrivateKey;
+    let privateKey: PrivateKeyInput;
     switch (scheme) {
       case SigningSchemeInput.Ed25519:
         privateKey = Ed25519PrivateKey.generate();
@@ -114,10 +155,12 @@ export class SingleKeyAccount implements Account {
    * (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.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   static fromDerivationPath(args: SingleKeySignerFromDerivationPathArgs) {
     const { scheme = SigningSchemeInput.Ed25519, path, mnemonic } = args;
-    let privateKey: PrivateKey;
+    let privateKey: PrivateKeyInput;
     switch (scheme) {
       case SigningSchemeInput.Ed25519:
         privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
@@ -138,6 +181,8 @@ export class SingleKeyAccount implements Account {
    * @param args.message - The raw message data in HexInput format.
    * @param args.signature - The signed message signature.
    * @returns A boolean indicating whether the signature is valid.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   verifySignature(args: VerifySingleKeySignatureArgs): boolean {
     return this.publicKey.verifySignature(args);
@@ -148,6 +193,8 @@ export class SingleKeyAccount implements Account {
    * account's public key.
    * @param message - The signing message, represented as binary input in hexadecimal format.
    * @returns An instance of AccountAuthenticatorSingleKey containing the signature and the public key.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey {
     return new AccountAuthenticatorSingleKey(this.publicKey, this.sign(message));
@@ -158,6 +205,8 @@ export class SingleKeyAccount implements Account {
    * This function returns an AccountAuthenticator that contains the signature of the transaction along with the account's public key.
    * @param transaction - The raw transaction to be signed.
    * @returns An AccountAuthenticatorSingleKey containing the signature of the transaction and the account's public key.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
     return new AccountAuthenticatorSingleKey(this.publicKey, this.signTransaction(transaction));
@@ -167,6 +216,8 @@ export class SingleKeyAccount implements Account {
    * Sign the given message using the account's private key.
    * @param message - The message to be signed in HexInput format.
    * @returns A new AnySignature containing the signature of the message.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   sign(message: HexInput): AnySignature {
     return new AnySignature(this.privateKey.sign(message));
@@ -178,10 +229,16 @@ export class SingleKeyAccount implements Account {
    *
    * @param transaction - The transaction to be signed.
    * @returns Signature - The resulting signature for the signed transaction.
+   * @group Implementation
+   * @category Account (On-Chain Model)
    */
   signTransaction(transaction: AnyRawTransaction): AnySignature {
     return this.sign(generateSigningMessageForTransaction(transaction));
   }
 
   // endregion
+
+  static fromEd25519Account(account: Ed25519Account): SingleKeyAccount {
+    return new SingleKeyAccount({ privateKey: account.privateKey, address: account.accountAddress });
+  }
 }

package/src/account/index.ts

@@ -6,3 +6,4 @@ export * from "./KeylessAccount";
 export * from "./AbstractKeylessAccount";
 export * from "./FederatedKeylessAccount";
 export * from "./MultiKeyAccount";
+export * from "./AccountUtils";

package/src/account/utils.ts

@@ -0,0 +1,16 @@
+import { SigningScheme } from "../types";
+import { AccountAddress } from "../core";
+import { Deserializer } from "../bcs/deserializer";
+
+export function deserializeSchemeAndAddress(deserializer: Deserializer): {
+  address: AccountAddress;
+  signingScheme: SigningScheme;
+} {
+  const signingScheme = deserializer.deserializeUleb128AsU32();
+  // Validate that signingScheme is a valid SigningScheme value
+  if (!Object.values(SigningScheme).includes(signingScheme)) {
+    throw new Error(`Deserialization of Account failed: SigningScheme variant ${signingScheme} is invalid`);
+  }
+  const address = AccountAddress.deserialize(deserializer);
+  return { address, signingScheme };
+}