@moveindustries/ts-sdk 5.1.4

package/src/account/KeylessAccount.ts

@@ -0,0 +1,179 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountAddress } from "../core/accountAddress";
+import { getIssAudAndUidVal, Groth16VerificationKey, KeylessPublicKey, ZeroKnowledgeSig } from "../core/crypto";
+import { HexInput } from "../types";
+
+import { Deserializer, Serializer } from "../bcs";
+import { Hex } from "../core/hex";
+import { AbstractKeylessAccount, ProofFetchCallback } from "./AbstractKeylessAccount";
+import { EphemeralKeyPair } from "./EphemeralKeyPair";
+
+/**
+ * Account implementation for the Keyless authentication scheme.
+ *
+ * Used to represent a Keyless based account and sign transactions with it.
+ *
+ * Use `KeylessAccount.create()` to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
+ *
+ * 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;
+
+  // Use the static constructor 'create' instead.
+
+  /**
+   * Use the static generator `create(...)` instead.
+   * Creates an instance of the KeylessAccount with an optional proof.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @param args.iss - A JWT issuer.
+   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
+   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
+   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
+   * OIDC registration with the identity provider.
+   * @param args.pepper - A hexadecimal input used for additional security.
+   * @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)
+   */
+  constructor(args: {
+    address?: AccountAddress;
+    ephemeralKeyPair: EphemeralKeyPair;
+    iss: string;
+    uidKey: string;
+    uidVal: string;
+    aud: string;
+    pepper: HexInput;
+    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+    proofFetchCallback?: ProofFetchCallback;
+    jwt: string;
+    verificationKeyHash?: HexInput;
+  }) {
+    const publicKey = KeylessPublicKey.create(args);
+    super({ publicKey, ...args });
+    this.publicKey = publicKey;
+  }
+
+  /**
+   * Serializes the transaction data into a format suitable for transmission or storage.
+   * 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);
+  }
+
+  /**
+   * Deserializes the provided deserializer to create a KeylessAccount instance.
+   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
+   *
+   * @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 } =
+      AbstractKeylessAccount.partialDeserialize(deserializer);
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      verificationKeyHash,
+    });
+  }
+
+  /**
+   * Deserialize bytes using this account's information.
+   *
+   * @param bytes The bytes being interpreted.
+   * @returns
+   */
+  static fromBytes(bytes: HexInput): KeylessAccount {
+    return KeylessAccount.deserialize(new Deserializer(Hex.hexInputToUint8Array(bytes)));
+  }
+
+  /**
+   * Creates a KeylessAccount instance using the provided parameters.
+   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
+   * This is used instead of the KeylessAccount constructor.
+   *
+   * @param args - The parameters for creating a KeylessAccount.
+   * @param args.address - Optional account address associated with the KeylessAccount.
+   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
+   * @param args.jwt - A JSON Web Token used for authentication.
+   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
+   * @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;
+    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
+    jwt: string;
+    ephemeralKeyPair: EphemeralKeyPair;
+    pepper: HexInput;
+    uidKey?: string;
+    proofFetchCallback?: ProofFetchCallback;
+    verificationKey?: Groth16VerificationKey;
+    verificationKeyHash?: Uint8Array;
+  }): KeylessAccount {
+    const {
+      address,
+      proof,
+      jwt,
+      ephemeralKeyPair,
+      pepper,
+      uidKey = "sub",
+      proofFetchCallback,
+      verificationKey,
+      verificationKeyHash,
+    } = args;
+
+    if (verificationKeyHash && verificationKey) {
+      throw new Error("Cannot provide both verificationKey and verificationKeyHash");
+    }
+
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return new KeylessAccount({
+      address,
+      proof,
+      ephemeralKeyPair,
+      iss,
+      uidKey,
+      uidVal,
+      aud,
+      pepper,
+      jwt,
+      proofFetchCallback,
+      verificationKeyHash: verificationKeyHash ?? (verificationKey ? verificationKey.hash() : undefined),
+    });
+  }
+}

package/src/account/MultiEd25519Account.ts

@@ -0,0 +1,181 @@
+import type { MovementConfig } from "../api";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { Ed25519PrivateKey, Signature } from "../core/crypto";
+import { MultiEd25519PublicKey, MultiEd25519Signature } from "../core/crypto/multiEd25519";
+import { AccountAuthenticatorMultiEd25519 } from "../transactions/authenticator/account";
+import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
+import { AnyRawTransaction } from "../transactions/types";
+import { HexInput, SigningScheme } from "../types";
+import type { Account } from "./Account";
+
+export interface MultiEd25519SignerConstructorArgs {
+  publicKey: MultiEd25519PublicKey;
+  signers: Ed25519PrivateKey[];
+  address?: AccountAddressInput;
+}
+
+export interface VerifyMultiEd25519SignatureArgs {
+  message: HexInput;
+  signature: MultiEd25519Signature;
+}
+
+/**
+ * Signer implementation for the Multi-Ed25519 authentication scheme.
+ *
+ * Note: This authentication scheme is a legacy authentication scheme.  Prefer using MultiKeyAccounts as a
+ * MultiKeyAccount can support any type of signer, not just Ed25519.  Generating a signer instance does not
+ * create the account on-chain.
+ */
+export class MultiEd25519Account implements Account {
+  readonly publicKey: MultiEd25519PublicKey;
+
+  readonly accountAddress: AccountAddress;
+
+  readonly signingScheme = SigningScheme.MultiEd25519;
+
+  /**
+   * The signers used to sign messages.  These signers should correspond to public keys in the
+   * MultiEd25519Account.  The number of signers should be equal to this.publicKey.threshold.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  readonly signers: Ed25519PrivateKey[];
+
+  /**
+   * 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)
+   */
+  readonly signerIndices: number[];
+
+  readonly signaturesBitmap: Uint8Array;
+
+  // region Constructors
+
+  constructor(args: MultiEd25519SignerConstructorArgs) {
+    const { signers, publicKey, address } = args;
+    this.publicKey = publicKey;
+    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
+
+    if (publicKey.threshold > signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `Not enough signers provided to satisfy the required signatures. Need ${publicKey.threshold} signers, but only ${signers.length} provided`,
+      );
+    } else if (publicKey.threshold < signers.length) {
+      throw new Error(
+        // eslint-disable-next-line max-len
+        `More signers provided than required. Need ${publicKey.threshold} signers, but ${signers.length} provided`,
+      );
+    }
+
+    // For each signer, find its corresponding position in the public keys array
+    const bitPositions: number[] = [];
+    for (const signer of signers) {
+      bitPositions.push(this.publicKey.getIndex(signer.publicKey()));
+    }
+
+    // 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: [Ed25519PrivateKey, 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.signerIndices = signersAndBitPosition.map((value) => value[1]);
+
+    // Create a bitmap representing which public keys from the MultiEd25519PublicKey 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 });
+  }
+
+  // endregion
+
+  // region Account
+
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * @param args.message raw message data in HexInput format
+   * @param args.signature signed message Signature
+   * @returns
+   */
+  verifySignature(args: VerifyMultiEd25519SignatureArgs): boolean {
+    return this.publicKey.verifySignature(args);
+  }
+
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * MultiEd25519 signatures do not depend on chain state, so this function is
+   * equivalent to the synchronous verifySignature method.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.movementConfig - The configuration object for connecting to the Movement network
+   * @param args.message - Raw message data in HexInput format.
+   * @param args.signature - Signed message signature.
+   * @returns A boolean indicating whether the signature is valid.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  async verifySignatureAsync(args: {
+    movementConfig: MovementConfig;
+    message: HexInput;
+    signature: Signature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return this.publicKey.verifySignatureAsync({
+      ...args,
+      signature: args.signature,
+    });
+  }
+
+  /**
+   * Sign a message using the account's Ed25519 private key.
+   * @param message the signing message, as binary input
+   * @return the AccountAuthenticator containing the signature, together with the account's public key
+   */
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorMultiEd25519 {
+    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.sign(message));
+  }
+
+  /**
+   * Sign a transaction using the account's Ed25519 private keys.
+   * @param transaction the raw transaction
+   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+   */
+  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorMultiEd25519 {
+    return new AccountAuthenticatorMultiEd25519(this.publicKey, this.signTransaction(transaction));
+  }
+
+  /**
+   * Sign the given message using the account's Ed25519 private keys.
+   * @param message in HexInput format
+   * @returns MultiEd25519Signature
+   */
+  sign(message: HexInput): MultiEd25519Signature {
+    const signatures = [];
+    for (const signer of this.signers) {
+      signatures.push(signer.sign(message));
+    }
+    return new MultiEd25519Signature({ signatures, bitmap: this.signaturesBitmap });
+  }
+
+  /**
+   * Sign the given transaction using the available signing capabilities.
+   * @param transaction the transaction to be signed
+   * @returns Signature
+   */
+  signTransaction(transaction: AnyRawTransaction): MultiEd25519Signature {
+    return this.sign(generateSigningMessageForTransaction(transaction));
+  }
+
+  // endregion
+}

package/src/account/MultiKeyAccount.ts

@@ -0,0 +1,296 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import type { MovementConfig } from "../api/movementConfig";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { MultiKey, MultiKeySignature, PublicKey } from "../core/crypto";
+import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/account";
+import { AnyRawTransaction } from "../transactions/types";
+import { HexInput, SigningScheme } from "../types";
+import { AbstractKeylessAccount, KeylessSigner } from "./AbstractKeylessAccount";
+import type { Account } from "./Account";
+import { Ed25519Account } from "./Ed25519Account";
+import { SingleKeyAccount, SingleKeySigner, SingleKeySignerOrLegacyEd25519Account } from "./SingleKeyAccount";
+
+/**
+ * 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;
+  signature: MultiKeySignature;
+}
+
+/**
+ * Signer implementation for the MultiKey authentication scheme.
+ *
+ * This account utilizes an M of N signing scheme, where M and N are specified in the {@link MultiKey}.
+ * 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 = 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 to 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[];
+
+  readonly signaturesBitmap: Uint8Array;
+
+  /**
+   * Constructs a MultiKeyAccount instance, which requires multiple signatures for transactions.
+   *
+   * @param args - The arguments for creating a MultiKeyAccount.
+   * @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: 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.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
+
+    // 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.getAnyPublicKey()));
+    }
+
+    // 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 });
+  }
+
+  /**
+   * Static constructor to create a MultiKeyAccount using the provided public keys and signers.
+   *
+   * @param args - The arguments for creating a MultiKeyAccount.
+   * @param args.publicKeys - The N public keys of the MultiKeyAccount.
+   * @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: {
+    address?: AccountAddressInput;
+    publicKeys: PublicKey[];
+    signaturesRequired: number;
+    signers: SingleKeySignerOrLegacyEd25519Account[];
+  }): MultiKeyAccount {
+    const { address, publicKeys, signaturesRequired, signers } = args;
+    const multiKey = new MultiKey({ publicKeys, signaturesRequired });
+    return new MultiKeyAccount({ multiKey, signers, address });
+  }
+
+  /**
+   * Determines if the provided account is a multi-key account.
+   *
+   * @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;
+  }
+
+  /**
+   * Sign a message using the account's signers and return an AccountAuthenticator containing the signature along with the
+   * 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));
+  }
+
+  /**
+   * Sign a transaction using the account's signers, returning an AccountAuthenticator that contains the signature and the
+   * 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));
+  }
+
+  /**
+   * 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(
+      (signer) => signer instanceof AbstractKeylessAccount,
+    ) as AbstractKeylessAccount[];
+    const promises = keylessSigners.map(async (signer) => signer.waitForProofFetch());
+    await Promise.all(promises);
+  }
+
+  /**
+   * Validates that the Keyless Account can be used to sign transactions.
+   * @return
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  async checkKeylessAccountValidity(movementConfig: MovementConfig): Promise<void> {
+    const keylessSigners = this.signers.filter(
+      (signer) => signer instanceof AbstractKeylessAccount,
+    ) as AbstractKeylessAccount[];
+    const promises = keylessSigners.map((signer) => signer.checkKeylessAccountValidity(movementConfig));
+    await Promise.all(promises);
+  }
+
+  /**
+   * Sign the given message using the MultiKeyAccount's signers
+   * @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 = [];
+    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.
+   * This function aggregates signatures from all signers associated with the MultiKeyAccount.
+   *
+   * @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 = [];
+    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 keys.
+   *
+   * This function checks if the provided signatures are valid for the given message using the corresponding public keys.
+   * Note: If you are using KeylessAccounts, you must use `verifySignatureAsync` instead.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @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: { message: HexInput; signature: MultiKeySignature }): boolean {
+    return this.publicKey.verifySignature(args);
+  }
+
+  /**
+   * Verify the given message and signature with the public keys.
+   *
+   * This function checks if the provided signatures are valid for the given message using the corresponding public keys.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The raw message data in HexInput format.
+   * @param args.signature - The signed message MultiKeySignature containing multiple signatures.
+   * @param args.options.throwErrorWithReason - Whether to throw an error with the reason for the verification failure.
+   * @returns A boolean indicating whether the signatures are valid for the message.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  async verifySignatureAsync(args: {
+    movementConfig: MovementConfig;
+    message: HexInput;
+    signature: MultiKeySignature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return await this.publicKey.verifySignatureAsync(args);
+  }
+}