@aptos-labs/ts-sdk 1.36.0 → 1.37.0

package/src/account/Ed25519Account.ts

@@ -1,10 +1,11 @@
 import { AccountAuthenticatorEd25519 } from "../transactions/authenticator/account";
 import { HexInput, SigningScheme } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from "../core/crypto";
+import { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature, Signature } from "../core/crypto";
 import type { Account } from "./Account";
 import { AnyRawTransaction } from "../transactions/types";
 import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
+import { AptosConfig } from "../api";
 
 /**
  * Arguments required to create an instance of an Ed25519 signer.
@@ -131,6 +132,30 @@ export class Ed25519Account implements Account {
     return this.publicKey.verifySignature(args);
   }
 
+  /**
+   * Verify the given message and signature with the public key.
+   *
+   * Ed25519 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.aptosConfig - The configuration object for connecting to the Aptos 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: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Signature;
+  }): Promise<boolean> {
+    return this.publicKey.verifySignatureAsync({
+      ...args,
+      signature: args.signature,
+    });
+  }
+
   /**
    * Sign a message using the account's Ed25519 private key.
    * This function returns an AccountAuthenticator containing the signature along with the account's public key.

package/src/account/MultiEd25519Account.ts

@@ -1,5 +1,6 @@
+import { AptosConfig } from "../api";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Ed25519PrivateKey } from "../core/crypto";
+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";
@@ -110,6 +111,32 @@ export class MultiEd25519Account implements Account {
     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.aptosConfig - The configuration object for connecting to the Aptos 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: {
+    aptosConfig: AptosConfig;
+    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

package/src/account/MultiKeyAccount.ts

@@ -259,6 +259,7 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * 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.
@@ -267,21 +268,29 @@ export class MultiKeyAccount implements Account, KeylessSigner {
    * @group Implementation
    * @category Account (On-Chain Model)
    */
-  verifySignature(args: VerifyMultiKeySignatureArgs): boolean {
-    const { message, signature } = args;
-    const isSignerIndicesSorted = this.signerIndicies.every(
-      (value, i) => i === 0 || value >= this.signerIndicies[i - 1],
-    );
-    if (!isSignerIndicesSorted) {
-      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;
+  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: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: MultiKeySignature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return await this.publicKey.verifySignatureAsync(args);
   }
 }

package/src/account/SingleKeyAccount.ts

@@ -1,11 +1,20 @@
 import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
 import { type HexInput, SigningScheme, SigningSchemeInput } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { AnyPublicKey, AnySignature, Ed25519PrivateKey, PrivateKeyInput, Secp256k1PrivateKey } from "../core/crypto";
+import {
+  AnyPublicKey,
+  AnySignature,
+  Ed25519PrivateKey,
+  KeylessSignature,
+  PrivateKeyInput,
+  Secp256k1PrivateKey,
+  Signature,
+} from "../core/crypto";
 import type { Account } from "./Account";
 import { generateSigningMessageForTransaction } from "../transactions/transactionBuilder/signingMessage";
 import { AnyRawTransaction } from "../transactions/types";
 import { Ed25519Account } from "./Ed25519Account";
+import { AptosConfig } from "../api";
 
 /**
  * An interface which defines if an Account utilizes SingleKey signing.
@@ -188,6 +197,31 @@ export class SingleKeyAccount implements Account, SingleKeySigner {
     return this.publicKey.verifySignature(args);
   }
 
+  /**
+   * Verify the given message and signature with the account's public key.
+   *
+   * This function checks if the provided signature is valid for the given message using the account's public key.
+   *
+   * @param args - The arguments for verifying the signature.
+   * @param args.message - The raw message data in HexInput format.
+   * @param args.signature - The signed message signature.
+   * @param args.options.throwErrorWithReason - Whether to throw an error with the reason for the verification failure.
+   * @returns A boolean indicating whether the signature is valid for the message.
+   * @group Implementation
+   * @category Account (On-Chain Model)
+   */
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: Signature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return this.publicKey.verifySignatureAsync({
+      ...args,
+      signature: args.signature,
+    });
+  }
+
   /**
    * Sign a message using the account's private key and return an AccountAuthenticator containing the signature along with the
    * account's public key.

package/src/api/account.ts

@@ -6,6 +6,7 @@ import { AccountAddress, PrivateKey, AccountAddressInput, createObjectAddress }
 import {
   AccountData,
   AnyNumber,
+  CursorPaginationArgs,
   GetAccountCoinsDataResponse,
   GetAccountCollectionsWithOwnedTokenResponse,
   GetAccountOwnedTokensFromCollectionResponse,
@@ -35,8 +36,10 @@ import {
   getInfo,
   getModule,
   getModules,
+  getModulesPage,
   getResource,
   getResources,
+  getResourcesPage,
   getTransactions,
   lookupOriginalAccountAddress,
 } from "../internal/account";
@@ -112,7 +115,6 @@ export class Account {
    * This function may call the API multiple times to auto paginate through results.
    *
    * @param args.accountAddress - The Aptos account address to query modules for.
-   * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
    * @param args.options.limit - The maximum number of results to return.
    * @param args.options.ledgerVersion - The ledger version to query; if not provided, it retrieves the latest version.
    *
@@ -130,7 +132,6 @@ export class Account {
    *   const accountModules = await aptos.getAccountModules({
    *     accountAddress: "0x1", // replace with a real account address
    *     options: {
-   *       offset: 0, // starting from the first module
    *       limit: 10, // limiting to 10 modules
    *     },
    *   });
@@ -143,11 +144,52 @@ export class Account {
    */
   async getAccountModules(args: {
     accountAddress: AccountAddressInput;
-    options?: PaginationArgs & LedgerVersionArg;
+    options?: { limit?: number } & LedgerVersionArg;
   }): Promise<MoveModuleBytecode[]> {
     return getModules({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Queries for a page of modules in an account given an account address.
+   *
+   * @param args.accountAddress - The Aptos account address to query modules for.
+   * @param args.options.cursor - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
+   * @param args.options.limit - The maximum number of results to return.
+   * @param args.options.ledgerVersion - The ledger version to query; if not provided, it retrieves the latest version.
+   *
+   * @returns - The account modules associated with the specified address. Along with a cursor for future pagination. If the cursor is undefined, it means there are no more modules to fetch.
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+   *
+   * const config = new AptosConfig({ network: Network.TESTNET });
+   * const aptos = new Aptos(config);
+   *
+   * async function runExample() {
+   *   // Fetching account modules for a specific account
+   *   const {modules, cursor} = await aptos.getAccountModulesPage({
+   *     accountAddress: "0x1", // replace with a real account address
+   *     options: {
+   *       cursor: undefined, // starting from the first module
+   *       limit: 10, // limiting to 10 modules
+   *     },
+   *   });
+   *
+   *   console.log(modules);
+   *   console.log(`More to fetch: ${cursor !== undefined}`);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Account
+   */
+  async getAccountModulesPage(args: {
+    accountAddress: AccountAddressInput;
+    options?: CursorPaginationArgs & LedgerVersionArg;
+  }): Promise<{ modules: MoveModuleBytecode[]; cursor: string | undefined }> {
+    return getModulesPage({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Queries for a specific account module given an account address and module name.
    *
@@ -234,7 +276,6 @@ export class Account {
    * This function may call the API multiple times to auto paginate through results.
    *
    * @param args.accountAddress - The Aptos account address to query resources for.
-   * @param args.options.offset - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
    * @param args.options.limit - The maximum number of results to return.
    * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
    * @returns Account resources.
@@ -262,6 +303,45 @@ export class Account {
     return getResources({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Queries a page of account resources given an account address.
+   *
+   * @param args.accountAddress - The Aptos account address to query resources for.
+   * @param args.options.cursor - The cursor to start returning results from.  Note, this is obfuscated and is not an index.
+   * @param args.options.limit - The maximum number of results to return.
+   * @param args.options.ledgerVersion - The ledger version to query; if not provided, it will get the latest version.
+   * @returns Account resources.
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+   *
+   * const config = new AptosConfig({ network: Network.TESTNET });
+   * const aptos = new Aptos(config);
+   *
+   * async function runExample() {
+   *   // Fetching account resources for a specific account address
+   *   const resources = await aptos.getAccountResourcesPage({
+   *     accountAddress: "0x1", // replace with a real account address
+   *     options: {
+   *       cursor: undefined, // starting from the first resource
+   *       limit: 10, // limiting to 10 resources
+   *     },
+   *   });
+   *   console.log(resources);
+   *   console.log(`More to fetch: ${resources.cursor !== undefined}`);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Account
+   */
+  async getAccountResourcesPage(args: {
+    accountAddress: AccountAddressInput;
+    options?: CursorPaginationArgs & LedgerVersionArg;
+  }): Promise<{ resources: MoveResource[]; cursor: string | undefined }> {
+    return getResourcesPage({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Queries a specific account resource given an account address and resource type.
    *

package/src/cli/localNode.ts

@@ -89,23 +89,14 @@ export class LocalNode {
     const cliArgs = ["aptos", "node", "run-localnet", "--force-restart", "--assume-yes", "--with-indexer-api"];
 
     const currentPlatform = platform();
-    let childProcess;
-    // Check if current OS is windows
-    if (currentPlatform === "win32") {
-      childProcess = spawn(cliCommand, cliArgs, { shell: true });
-    } else {
-      childProcess = spawn(cliCommand, cliArgs);
-    }
-
-    this.process = childProcess;
+    const spawnConfig = {
+      env: { ...process.env, ENABLE_KEYLESS_DEFAULT: "1" },
+      ...(currentPlatform === "win32" && { shell: true }),
+    };
 
-    childProcess.stderr?.on("data", (data: any) => {
-      const str = data.toString();
-      // Print local node output error log
-      console.log(str);
-    });
+    this.process = spawn(cliCommand, cliArgs, spawnConfig);
 
-    childProcess.stdout?.on("data", (data: any) => {
+    this.process.stdout?.on("data", (data: any) => {
       const str = data.toString();
       // Print local node output log
       if (this.showStdout) {

package/src/client/get.ts

@@ -234,7 +234,7 @@ export async function getAptosPepperService<Req extends {}, Res extends {}>(
 export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
-  const out: any[] = [];
+  const out: Res = new Array(0) as Res;
   let cursor: string | undefined;
   const requestParams = options.params as { start?: string; limit?: number };
   do {
@@ -261,38 +261,31 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
     out.push(...response.data);
     requestParams.start = cursor;
   } while (cursor !== null && cursor !== undefined);
-  return out as Res;
+  return out;
 }
 
 /// This function is a helper for paginating using a function wrapping an API using offset instead of start
 export async function paginateWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
-  const out: any[] = [];
+  const out: Res = new Array(0) as Res;
   let cursor: string | undefined;
-  const requestParams = options.params as { offset?: string; limit?: number };
+  const requestParams = options.params as { start?: string; limit?: number };
   const totalLimit = requestParams.limit;
   do {
     // eslint-disable-next-line no-await-in-loop
-    const response = await get<Req, Res>({
-      type: AptosApiType.FULLNODE,
-      aptosConfig: options.aptosConfig,
-      originMethod: options.originMethod,
-      path: options.path,
-      params: requestParams,
-      overrides: options.overrides,
-    });
+    const { response, cursor: newCursor } = await getPageWithObfuscatedCursor<Req, Res>({ ...options });
+
     /**
      * the cursor is a "state key" from the API perspective. Client
      * should not need to "care" what it represents but just use it
      * to query the next chunk of data.
      */
-    cursor = response.headers["x-aptos-cursor"];
-    // Now that we have the cursor (if any), we remove the headers before
-    // adding these to the output of this function.
-    delete response.headers;
+    cursor = newCursor;
     out.push(...response.data);
-    requestParams.offset = cursor;
+    if (options?.params) {
+      options.params.start = cursor;
+    }
 
     // Re-evaluate length
     if (totalLimit !== undefined) {
@@ -303,5 +296,39 @@ export async function paginateWithObfuscatedCursor<Req extends Record<string, an
       requestParams.limit = newLimit;
     }
   } while (cursor !== null && cursor !== undefined);
-  return out as Res;
+  return out;
+}
+
+export async function getPageWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(
+  options: GetAptosRequestOptions,
+): Promise<{ response: AptosResponse<Req, Res>; cursor: string | undefined }> {
+  let cursor: string | undefined;
+  let requestParams: { start?: string; limit?: number } = {};
+
+  // Drop any other values
+  // TODO: Throw error if cursor is not a string
+  if (typeof options.params?.cursor === "string") {
+    requestParams.start = options.params.cursor;
+  }
+  if (typeof options.params?.limit === "number") {
+    requestParams.limit = options.params.limit;
+  }
+
+  // eslint-disable-next-line no-await-in-loop
+  const response = await get<Req, Res>({
+    type: AptosApiType.FULLNODE,
+    aptosConfig: options.aptosConfig,
+    originMethod: options.originMethod,
+    path: options.path,
+    params: requestParams,
+    overrides: options.overrides,
+  });
+
+  /**
+   * the cursor is a "state key" from the API perspective. Client
+   * should not need to "care" what it represents but just use it
+   * to query the next chunk of data.
+   */
+  cursor = response.headers["x-aptos-cursor"];
+  return { response, cursor };
 }

package/src/core/accountAddress.ts

@@ -183,6 +183,31 @@ export class AccountAddress extends Serializable implements TransactionArgument
     return bytesToHex(this.data);
   }
 
+  /**
+   * Convert the account address to a string in SHORT format, which is 0x followed by the shortest
+   * possible representation (no leading zeros).
+   *
+   * @returns AccountAddress as a string in SHORT form.
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringShort(): `0x${string}` {
+    return `0x${this.toStringShortWithoutPrefix()}`;
+  }
+
+  /**
+   * Returns a lossless short string representation of the address by trimming leading zeros.
+   * If the address consists of all zeros, returns "0".
+   *
+   * @returns A string representation of the address without leading zeros
+   * @group Implementation
+   * @category Serialization
+   */
+  toStringShortWithoutPrefix(): string {
+    const hex = bytesToHex(this.data).replace(/^0+/, "");
+    return hex === "" ? "0" : hex;
+  }
+
   /**
    * Get the inner data as a Uint8Array.
    * The inner data is already a Uint8Array, so no conversion takes place.

package/src/core/crypto/abstraction.ts

@@ -3,7 +3,7 @@ import { HexInput } from "../../types";
 import { AccountAddress } from "../accountAddress";
 import { AuthenticationKey } from "../authenticationKey";
 import { Hex } from "../hex";
-import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { AccountPublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey";
 import { Signature } from "./signature";
 
 export class AbstractSignature extends Signature {
@@ -40,6 +40,11 @@ export class AbstractPublicKey extends AccountPublicKey {
     throw new Error("This function is not implemented for AbstractPublicKey.");
   }
 
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  async verifySignatureAsync(args: VerifySignatureAsyncArgs): Promise<boolean> {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+
   // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
   serialize(serializer: Serializer): void {
     throw new Error("This function is not implemented for AbstractPublicKey.");

package/src/core/crypto/ed25519.ts

@@ -9,7 +9,7 @@ import { Hex } from "../hex";
 import { HexInput, SigningScheme as AuthenticationKeyScheme, PrivateKeyVariants } from "../../types";
 import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
 import { PrivateKey } from "./privateKey";
-import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
+import { AccountPublicKey, PublicKey, VerifySignatureArgs, VerifySignatureAsyncArgs } from "./publicKey";
 import { Signature } from "./signature";
 import { convertSigningMessage } from "./utils";
 
@@ -120,6 +120,24 @@ export class Ed25519PublicKey extends AccountPublicKey {
     return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);
   }
 
+  /**
+   * Note: Ed25519Signatures can be verified syncronously.
+   *
+   * Verifies the provided signature against the given message.
+   * This function helps ensure the integrity and authenticity of the message by confirming that the signature is valid.
+   *
+   * @param args - The arguments for signature verification.
+   * @param args.aptosConfig - The configuration object for connecting to the Aptos network
+   * @param args.message - The message that was signed.
+   * @param args.signature - The signature to verify, which must be an instance of Secp256k1Signature.
+   * @returns A boolean indicating whether the signature is valid for the given message.
+   * @group Implementation
+   * @category Serialization
+   */
+  async verifySignatureAsync(args: VerifySignatureAsyncArgs): Promise<boolean> {
+    return this.verifySignature(args);
+  }
+
   /**
    * Generates an authentication key from the public key using the Ed25519 scheme.
    * This function is essential for creating a secure authentication key that can be used for further cryptographic operations.

package/src/core/crypto/ephemeral.ts

@@ -4,6 +4,7 @@ import { PublicKey } from "./publicKey";
 import { Signature } from "./signature";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
 import { Hex } from "../hex";
+import { AptosConfig } from "../../api";
 
 /**
  * Represents ephemeral public keys for Aptos Keyless accounts.
@@ -64,6 +65,14 @@ export class EphemeralPublicKey extends PublicKey {
     return this.publicKey.verifySignature({ message, signature: signature.signature });
   }
 
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: EphemeralSignature;
+  }): Promise<boolean> {
+    return this.verifySignature(args);
+  }
+
   /**
    * Serializes the current instance, specifically handling the Ed25519 signature type.
    * This function ensures that the signature is properly serialized using the provided serializer.

package/src/core/crypto/federatedKeyless.ts

@@ -6,7 +6,16 @@ import { Deserializer, Serializer } from "../../bcs";
 import { HexInput, AnyPublicKeyVariant, SigningScheme } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { AccountAddress, AccountAddressInput } from "../accountAddress";
-import { KeylessPublicKey, KeylessSignature } from "./keyless";
+import {
+  KeylessConfiguration,
+  KeylessPublicKey,
+  KeylessSignature,
+  MoveJWK,
+  verifyKeylessSignature,
+  verifyKeylessSignatureWithJwkAndConfig,
+} from "./keyless";
+import { AptosConfig } from "../../api";
+import { Signature } from "..";
 
 /**
  * Represents the FederatedKeylessPublicKey public key
@@ -60,13 +69,24 @@ export class FederatedKeylessPublicKey extends AccountPublicKey {
    *
    * @param args.message message
    * @param args.signature The signature
+   * @param args.jwk - The JWK to use for verification.
+   * @param args.keylessConfig - The keyless configuration to use for verification.
    * @returns true if the signature is valid
    * @group Implementation
    * @category Serialization
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {
-    throw new Error("Not yet implemented");
+  verifySignature(args: {
+    message: HexInput;
+    signature: Signature;
+    jwk: MoveJWK;
+    keylessConfig: KeylessConfiguration;
+  }): boolean {
+    try {
+      verifyKeylessSignatureWithJwkAndConfig({ ...args, publicKey: this });
+      return true;
+    } catch (error) {
+      return false;
+    }
   }
 
   serialize(serializer: Serializer): void {
@@ -84,6 +104,28 @@ export class FederatedKeylessPublicKey extends AccountPublicKey {
     return publicKey instanceof FederatedKeylessPublicKey;
   }
 
+  /**
+   * Verifies a keyless signature for a given message.  It will fetch the keyless configuration and the JWK to
+   * use for verification from the appropriate network as defined by the aptosConfig.
+   *
+   * @param args.aptosConfig The aptos config to use for fetching the keyless configuration.
+   * @param args.message The message to verify the signature against.
+   * @param args.signature The signature to verify.
+   * @param args.options.throwErrorWithReason Whether to throw an error with the reason for the failure instead of returning false.
+   * @returns true if the signature is valid
+   */
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: KeylessSignature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return verifyKeylessSignature({
+      ...args,
+      publicKey: this,
+    });
+  }
+
   /**
    * Creates a FederatedKeylessPublicKey from the JWT components plus pepper
    *

package/src/core/crypto/index.ts

@@ -1,13 +1,14 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+export * from "./abstraction";
 export * from "./ed25519";
-export * from "./hdKey";
-export * from "./multiEd25519";
-export * from "./multiKey";
 export * from "./ephemeral";
 export * from "./federatedKeyless";
+export * from "./hdKey";
 export * from "./keyless";
+export * from "./multiEd25519";
+export * from "./multiKey";
 export * from "./poseidon";
 export * from "./privateKey";
 export * from "./publicKey";