@aptos-labs/ts-sdk 1.13.3 → 1.14.0-zeta.1

package/src/account/EphemeralKeyPair.ts

@@ -0,0 +1,161 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { randomBytes } from "@noble/hashes/utils";
+
+import {
+  EPK_HORIZON_SECS,
+  Ed25519PrivateKey,
+  EphemeralPublicKey,
+  EphemeralSignature,
+  PrivateKey,
+} from "../core/crypto";
+import { Hex } from "../core/hex";
+import { bytesToBigIntLE, padAndPackBytesWithLen, poseidonHash } from "../core/crypto/poseidon";
+import { EphemeralPublicKeyVariant, HexInput } from "../types";
+import { Deserializer, Serializable, Serializer } from "../bcs";
+
+export class EphemeralKeyPair extends Serializable {
+  static readonly BLINDER_LENGTH: number = 31;
+
+  /**
+   * A byte array of length BLINDER_LENGTH used to obfuscate the public key from the IdP.
+   * Used in calculating the nonce passed to the IdP and as a secret witness in proof generation.
+   */
+  readonly blinder: Uint8Array;
+
+  /**
+   * A timestamp in seconds indicating when the ephemeral key pair is expired.  After expiry, a new
+   * EphemeralKeyPair must be generated and a new JWT needs to be created.
+   */
+  readonly expiryDateSecs: bigint | number;
+
+  /**
+   * The value passed to the IdP when the user authenticates.  It comprises of a hash of the
+   * ephermeral public key, expiry date, and blinder.
+   */
+  readonly nonce: string;
+
+  /**
+   * A private key used to sign transactions.  This private key is not tied to any account on the chain as it
+   * is ephemeral in nature.
+   */
+  private privateKey: PrivateKey;
+
+  /**
+   * A public key used to verify transactions.  This public key is not tied to any account on the chain as it
+   * is ephemeral in nature.
+   */
+  private publicKey: EphemeralPublicKey;
+
+  constructor(args: { privateKey: PrivateKey; expiryDateSecs?: bigint | number; blinder?: HexInput }) {
+    super();
+    const { privateKey, expiryDateSecs, blinder } = args;
+    this.privateKey = privateKey;
+    this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
+    // We set the expiry date to be the nearest floored hour
+    this.expiryDateSecs = expiryDateSecs || BigInt(floorToWholeHour(currentTimeInSeconds() + EPK_HORIZON_SECS));
+    // Generate the blinder if not provided
+    this.blinder = blinder !== undefined ? Hex.fromHexInput(blinder).toUint8Array() : generateBlinder();
+    // Calculate the nonce
+    this.nonce = this.generateNonce();
+  }
+
+  /**
+   * Returns the public key of the key pair.
+   * @return EphemeralPublicKey
+   */
+  getPublicKey(): EphemeralPublicKey {
+    return this.publicKey;
+  }
+
+  /**
+   * Returns the public key of the key pair.
+   * @return boolean
+   */
+  isExpired(): boolean {
+    const currentTimeSecs: number = Math.floor(Date.now() / 1000);
+    return currentTimeSecs > this.expiryDateSecs;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(this.publicKey.variant);
+    serializer.serializeBytes(this.privateKey.toUint8Array());
+    serializer.serializeU64(this.expiryDateSecs);
+    serializer.serializeFixedBytes(this.blinder);
+  }
+
+  static deserialize(deserializer: Deserializer): EphemeralKeyPair {
+    const variantIndex = deserializer.deserializeUleb128AsU32();
+    let privateKey: PrivateKey;
+    switch (variantIndex) {
+      case EphemeralPublicKeyVariant.Ed25519:
+        privateKey = Ed25519PrivateKey.deserialize(deserializer);
+        break;
+      default:
+        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);
+    }
+    const expiryDateSecs = deserializer.deserializeU64();
+    const blinder = deserializer.deserializeFixedBytes(31);
+    return new EphemeralKeyPair({ privateKey, expiryDateSecs, blinder });
+  }
+
+  static fromBytes(bytes: Uint8Array): EphemeralKeyPair {
+    return EphemeralKeyPair.deserialize(new Deserializer(bytes));
+  }
+
+  /**
+   * Returns the public key of the key pair.
+   * @param scheme the type of keypair to use for the EphemeralKeyPair.  Only Ed25519 supported for now.
+   * @return boolean
+   */
+  static generate(args?: { scheme: EphemeralPublicKeyVariant }): EphemeralKeyPair {
+    let privateKey: PrivateKey;
+
+    switch (args?.scheme) {
+      case EphemeralPublicKeyVariant.Ed25519:
+      default:
+        privateKey = Ed25519PrivateKey.generate();
+    }
+
+    return new EphemeralKeyPair({ privateKey });
+  }
+
+  private generateNonce(): string {
+    const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);
+    fields.push(BigInt(this.expiryDateSecs));
+    fields.push(bytesToBigIntLE(this.blinder));
+    const nonceHash = poseidonHash(fields);
+    return nonceHash.toString();
+  }
+
+  /**
+   * Sign the given message with the private key.
+   *
+   * @param data in HexInput format
+   * @returns EphemeralSignature
+   */
+  sign(data: HexInput): EphemeralSignature {
+    if (this.isExpired()) {
+      throw new Error("EphemeralKeyPair has expired");
+    }
+    return new EphemeralSignature(this.privateKey.sign(data));
+  }
+}
+
+function generateBlinder(): Uint8Array {
+  return randomBytes(EphemeralKeyPair.BLINDER_LENGTH);
+}
+
+function currentTimeInSeconds(): number {
+  return Math.floor(new Date().getTime() / 1000);
+}
+
+function floorToWholeHour(timestampInSeconds: number): number {
+  const date = new Date(timestampInSeconds * 1000);
+  // Reset minutes and seconds to zero
+  date.setMinutes(0);
+  date.setSeconds(0);
+  date.setMilliseconds(0);
+  return Math.floor(date.getTime() / 1000);
+}

package/src/account/KeylessAccount.ts

@@ -0,0 +1,342 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { JwtPayload, jwtDecode } from "jwt-decode";
+import { JwksClient } from "jwks-rsa";
+import { decode } from "base-64";
+import EventEmitter from "eventemitter3";
+import { EphemeralCertificateVariant, HexInput, SigningScheme } from "../types";
+import { AccountAddress } from "../core/accountAddress";
+import {
+  AnyPublicKey,
+  AnySignature,
+  KeylessPublicKey,
+  KeylessSignature,
+  EphemeralCertificate,
+  Signature,
+  ZeroKnowledgeSig,
+  ZkProof,
+} from "../core/crypto";
+
+import { Account } from "./Account";
+import { EphemeralKeyPair } from "./EphemeralKeyPair";
+import { Hex } from "../core/hex";
+import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
+import { Deserializer, Serializable, Serializer } from "../bcs";
+import {
+  deriveTransactionType,
+  generateSigningMessageForSerializable,
+} from "../transactions/transactionBuilder/signingMessage";
+import { AnyRawTransaction, AnyRawTransactionInstance } from "../transactions/types";
+
+export const IssuerToJwkEndpoint: Record<string, string> = {
+  "https://accounts.google.com": "https://www.googleapis.com/oauth2/v3/certs",
+};
+
+export class KeylessAccount extends Serializable implements Account {
+  static readonly PEPPER_LENGTH: number = 31;
+
+  readonly publicKey: KeylessPublicKey;
+
+  readonly ephemeralKeyPair: EphemeralKeyPair;
+
+  readonly uidKey: string;
+
+  readonly uidVal: string;
+
+  readonly aud: string;
+
+  readonly pepper: Uint8Array;
+
+  readonly accountAddress: AccountAddress;
+
+  proof: ZeroKnowledgeSig | undefined;
+
+  readonly proofOrPromise: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+
+  readonly signingScheme: SigningScheme;
+
+  private jwt: string;
+
+  private isJwtValid: boolean;
+
+  readonly emitter: EventEmitter<ProofFetchEvents>;
+
+  constructor(args: {
+    address?: AccountAddress;
+    ephemeralKeyPair: EphemeralKeyPair;
+    iss: string;
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: HexInput;
+    proofOrFetcher: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+    proofFetchCallback?: ProofFetchCallback;
+    jwt: string;
+  }) {
+    super();
+    const { address, ephemeralKeyPair, uidKey, uidVal, aud, pepper, proofOrFetcher, proofFetchCallback, jwt } = args;
+    this.ephemeralKeyPair = ephemeralKeyPair;
+    this.publicKey = KeylessPublicKey.create(args);
+    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
+    this.uidKey = uidKey;
+    this.uidVal = uidVal;
+    this.aud = aud;
+    this.jwt = jwt;
+    this.emitter = new EventEmitter<ProofFetchEvents>();
+    this.proofOrPromise = proofOrFetcher;
+    if (proofOrFetcher instanceof ZeroKnowledgeSig) {
+      this.proof = proofOrFetcher;
+    } else {
+      if (proofFetchCallback === undefined) {
+        throw new Error("Must provide callback for async proof fetch");
+      }
+      this.emitter.on("proofFetchFinish", async (status) => {
+        await proofFetchCallback(status);
+        this.emitter.removeAllListeners();
+      });
+      this.init(proofOrFetcher);
+    }
+    this.signingScheme = SigningScheme.SingleKey;
+    const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();
+    if (pepperBytes.length !== KeylessAccount.PEPPER_LENGTH) {
+      throw new Error(`Pepper length in bytes should be ${KeylessAccount.PEPPER_LENGTH}`);
+    }
+    this.pepper = pepperBytes;
+    this.isJwtValid = true;
+  }
+
+  /**
+   * This initializes the asyncronous proof fetch
+   * @return
+   */
+  async init(promise: Promise<ZeroKnowledgeSig>) {
+    try {
+      this.proof = await promise;
+      this.emitter.emit("proofFetchFinish", { status: "Success" });
+    } catch (error) {
+      if (error instanceof Error) {
+        this.emitter.emit("proofFetchFinish", { status: "Failed", error: error.toString() });
+      } else {
+        this.emitter.emit("proofFetchFinish", { status: "Failed", error: "Unknown" });
+      }
+    }
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeStr(this.jwt);
+    serializer.serializeStr(this.uidKey);
+    serializer.serializeFixedBytes(this.pepper);
+    this.ephemeralKeyPair.serialize(serializer);
+    if (this.proof === undefined) {
+      throw new Error("Connot serialize - proof undefined");
+    }
+    this.proof.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): KeylessAccount {
+    const jwt = deserializer.deserializeStr();
+    const uidKey = deserializer.deserializeStr();
+    const pepper = deserializer.deserializeFixedBytes(31);
+    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
+    const proof = ZeroKnowledgeSig.deserialize(deserializer);
+    return KeylessAccount.fromJWTAndProof({
+      proof,
+      pepper,
+      uidKey,
+      jwt,
+      ephemeralKeyPair,
+    });
+  }
+
+  /**
+   * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair
+   * and JWT token.
+   * @return boolean
+   */
+  isExpired(): boolean {
+    return this.ephemeralKeyPair.isExpired();
+  }
+
+  /**
+   * Checks if the the JWK used to verify the token still exists on the issuer's JWK uri.
+   * Caches the result.
+   * @return boolean
+   */
+  async checkJwkValidity(): Promise<boolean> {
+    if (!this.isJwtValid) {
+      return false;
+    }
+    const jwtHeader = jwtDecode(this.jwt, { header: true });
+    const client = new JwksClient({
+      jwksUri: IssuerToJwkEndpoint[this.publicKey.iss],
+    });
+    try {
+      await client.getSigningKey(jwtHeader.kid);
+      return true;
+    } catch (error) {
+      this.isJwtValid = false;
+      return false;
+    }
+  }
+
+  /**
+   * Sign a message using Keyless.
+   * @param message the message to sign, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey {
+    const signature = new AnySignature(this.sign(message));
+    const publicKey = new AnyPublicKey(this.publicKey);
+    return new AccountAuthenticatorSingleKey(publicKey, signature);
+  }
+
+  /**
+   * Sign a transaction using Keyless.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
+    const signature = new AnySignature(this.signTransaction(transaction));
+    const publicKey = new AnyPublicKey(this.publicKey);
+    return new AccountAuthenticatorSingleKey(publicKey, signature);
+  }
+
+  /**
+   * Waits for asyncronous proof fetching to finish.
+   * @return
+   */
+  async waitForProofFetch() {
+    if (this.proofOrPromise instanceof Promise) {
+      await this.proofOrPromise;
+    }
+  }
+
+  /**
+   * Sign the given message using Keyless.
+   * @param message in HexInput format
+   * @returns Signature
+   */
+  sign(data: HexInput): KeylessSignature {
+    const { expiryDateSecs } = this.ephemeralKeyPair;
+    if (this.isExpired()) {
+      throw new Error("Ephemeral key pair is expired.");
+    }
+    if (this.proof === undefined) {
+      throw new Error("Proof not found");
+    }
+    if (!this.isJwtValid) {
+      throw new Error("The proof has expired. Please refetch proof");
+    }
+    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
+    const ephemeralSignature = this.ephemeralKeyPair.sign(data);
+
+    return new KeylessSignature({
+      jwtHeader: base64UrlDecode(this.jwt.split(".")[0]),
+      ephemeralCertificate: new EphemeralCertificate(this.proof, EphemeralCertificateVariant.ZkProof),
+      expiryDateSecs,
+      ephemeralPublicKey,
+      ephemeralSignature,
+    });
+  }
+
+  /**
+   * Sign the given transaction with Keyless.
+   * Signs the transaction and proof to guard against proof malleability.
+   * @param transaction the transaction to be signed
+   * @returns KeylessSignature
+   */
+  signTransaction(transaction: AnyRawTransaction): KeylessSignature {
+    if (this.proof === undefined) {
+      throw new Error("Proof not found");
+    }
+    const raw = deriveTransactionType(transaction);
+    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);
+    const signMess = generateSigningMessageForSerializable(txnAndProof);
+    return this.sign(signMess);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
+  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
+    throw new Error("Not implemented");
+  }
+
+  static fromBytes(bytes: Uint8Array): KeylessAccount {
+    return KeylessAccount.deserialize(new Deserializer(bytes));
+  }
+
+  static fromJWTAndProof(args: {
+    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+    jwt: string;
+    ephemeralKeyPair: EphemeralKeyPair;
+    pepper: HexInput;
+    uidKey?: string;
+    proofFetchCallback?: ProofFetchCallback;
+  }): KeylessAccount {
+    const { proof, jwt, ephemeralKeyPair, pepper, proofFetchCallback } = args;
+    const uidKey = args.uidKey ?? "sub";
+
+    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
+    const iss = jwtPayload.iss!;
+    if (typeof jwtPayload.aud !== "string") {
+      throw new Error("aud was not found or an array of values");
+    }
+    const aud = jwtPayload.aud!;
+    const uidVal = jwtPayload[uidKey];
+    return new KeylessAccount({
+      proofOrFetcher: proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      proofFetchCallback,
+    });
+  }
+}
+
+class TransactionAndProof extends Serializable {
+  transaction: AnyRawTransactionInstance;
+
+  proof?: ZkProof;
+
+  constructor(transaction: AnyRawTransactionInstance, proof?: ZkProof) {
+    super();
+    this.transaction = transaction;
+    this.proof = proof;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeFixedBytes(this.transaction.bcsToBytes());
+    serializer.serializeOption(this.proof);
+  }
+}
+
+function base64UrlDecode(base64Url: string): string {
+  // Replace base64url-specific characters
+  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+  // Pad the string with '=' characters if needed
+  const paddedBase64 = base64 + "==".substring(0, (3 - (base64.length % 3)) % 3);
+  // Decode the base64 string using the base-64 library
+  const decodedString = decode(paddedBase64);
+  return decodedString;
+}
+
+export type ProofFetchSuccess = {
+  status: "Success";
+};
+
+export type ProofFetchFailure = {
+  status: "Failed";
+  error: string;
+};
+
+export type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure;
+
+export type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;
+
+export interface ProofFetchEvents {
+  proofFetchFinish: (status: ProofFetchStatus) => void;
+}

package/src/account/MultiKeyAccount.ts

@@ -0,0 +1,186 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Account } from "./Account";
+import { MultiKey, MultiKeySignature, PublicKey } from "../core/crypto";
+import { AccountAddress } from "../core/accountAddress";
+import { HexInput, SigningScheme } from "../types";
+import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/account";
+import { AnyRawTransaction } from "../transactions/types";
+import { KeylessAccount } from "./KeylessAccount";
+
+export interface VerifyMultiKeySignatureArgs {
+  message: HexInput;
+  signature: MultiKeySignature;
+}
+
+/**
+ * Signer implementation for the MultiKey authentication scheme.
+ *
+ * This accounts to use a M of N signing scheme. M and N are specified in the {@link MultiKey}
+ * It signs messages via the array of M number of Accounts that individually correspond to a public key in the {@link MultiKey}.
+ *
+ * Note: Generating a signer instance does not create the account on-chain.
+ */
+export class MultiKeyAccount implements Account {
+  /**
+   * Public key associated with the account
+   */
+  readonly publicKey: MultiKey;
+
+  /**
+   * Account address associated with the account
+   */
+  readonly accountAddress: AccountAddress;
+
+  /**
+   * Signing scheme used to sign transactions
+   */
+  readonly signingScheme: SigningScheme;
+
+  /**
+   * 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
+   */
+  readonly signers: Account[];
+
+  /**
+   * An array of indicies 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.
+   */
+  readonly signerIndicies: number[];
+
+  readonly signaturesBitmap: Uint8Array;
+
+  /**
+   * constructor for MultiKeyAccount
+   *
+   * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is
+   * the number of required signatures.
+   * @param args.signers an array of M signers that will be used to sign the transaction
+   * @returns MultiKeyAccount
+   */
+  constructor(args: { multiKey: MultiKey; signers: Account[] }) {
+    const { multiKey, signers } = args;
+
+    this.publicKey = multiKey;
+    this.signingScheme = SigningScheme.MultiKey;
+
+    this.accountAddress = this.publicKey.authKey().derivedAddress();
+
+    // Get the index of each respective signer in the bitmap
+    const bitPositions: number[] = [];
+    for (const signer of signers) {
+      bitPositions.push(this.publicKey.getIndex(signer.publicKey));
+    }
+    // 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.
+    const signersAndBitPosition: [Account, number][] = signers.map((signer, index) => [signer, bitPositions[index]]);
+    signersAndBitPosition.sort((a, b) => a[1] - b[1]);
+    this.signers = signersAndBitPosition.map((value) => value[0]);
+    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);
+    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
+  }
+
+  /**
+   * Static constructor for MultiKeyAccount
+   *
+   * @param args.publicKeys the N public keys of the MultiKeyAccount
+   * @param args.signaturesRequired the number of signatures required
+   * @param args.signers an array of M signers that will be used to sign the transaction
+   * @returns MultiKeyAccount
+   */
+  static fromPublicKeysAndSigners(args: {
+    publicKeys: PublicKey[];
+    signaturesRequired: number;
+    signers: Account[];
+  }): MultiKeyAccount {
+    const { publicKeys, signaturesRequired, signers } = args;
+    const multiKey = new MultiKey({ publicKeys, signaturesRequired });
+    return new MultiKeyAccount({ multiKey, signers });
+  }
+
+  static isMultiKeySigner(account: Account): account is MultiKeyAccount {
+    return account instanceof MultiKeyAccount;
+  }
+
+  /**
+   * Sign a message using the account's signers.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiKey {
+    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));
+  }
+
+  /**
+   * Sign a transaction using the account's signers.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiKey {
+    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
+  }
+
+  /**
+   * Waits for any proofs to be fetched
+   * @return
+   */
+  async waitForProofFetch() {
+    const keylessSigners = this.signers.filter((signer) => signer instanceof KeylessAccount) as KeylessAccount[];
+    await Promise.all(keylessSigners.filter((signer) => signer.proof instanceof Promise).map((signer) => signer.proof));
+  }
+
+  /**
+   * Sign the given message using the MultiKeyAccount's signers
+   * @param message in HexInput format
+   * @returns MultiKeySignature
+   */
+  sign(data: HexInput): MultiKeySignature {
+    const signatures = [];
+    for (const signer of this.signers) {
+      signatures.push(signer.sign(data));
+    }
+    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
+  }
+
+  /**
+   * Sign the given transaction using the MultiKeyAccount's signers
+   * @param transaction the transaction to be signed
+   * @returns MultiKeySignature
+   */
+  signTransaction(transaction: AnyRawTransaction): MultiKeySignature {
+    const signatures = [];
+    for (const signer of this.signers) {
+      signatures.push(signer.signTransaction(transaction));
+    }
+    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
+  }
+
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * @param args.message raw message data in HexInput format
+   * @param args.signatures signed message MultiKeySignature
+   * @returns boolean
+   */
+  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {
+    const { message, signature } = args;
+    const isSignerIndiciesSorted = this.signerIndicies.every(
+      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],
+    );
+    if (!isSignerIndiciesSorted) {
+      return false;
+    }
+    for (let i = 0; i < signature.signatures.length; i += 1) {
+      const singleSignature = signature.signatures[i];
+      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];
+      if (!publicKey.verifySignature({ message, signature: singleSignature })) {
+        return false;
+      }
+    }
+    return true;
+  }
+}