@aptos-labs/ts-sdk 1.36.0 → 1.37.1

package/src/account/AbstractKeylessAccount.ts

@@ -13,9 +13,10 @@ import {
   EphemeralCertificate,
   ZeroKnowledgeSig,
   ZkProof,
-  getKeylessJWKs,
   MoveJWK,
   getKeylessConfig,
+  fetchJWK,
+  KeylessConfiguration,
 } from "../core/crypto";
 
 import { EphemeralKeyPair } from "./EphemeralKeyPair";
@@ -428,28 +429,47 @@ export abstract class AbstractKeylessAccount extends Serializable implements Key
     return this.sign(signMess);
   }
 
+  getSigningMessage(transaction: AnyRawTransaction): Uint8Array {
+    if (this.proof === undefined) {
+      throw KeylessError.fromErrorType({
+        type: KeylessErrorType.PROOF_NOT_FOUND,
+        details: "Proof not found - make sure to call `await account.checkKeylessAccountValidity()` before signing.",
+      });
+    }
+    const raw = deriveTransactionType(transaction);
+    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);
+    return txnAndProof.hash();
+  }
+
   /**
    * Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
    *
    * Verifies a signature given the message.
    *
-   * TODO: Groth16 proof verification
-   *
    * @param args.message the message that was signed.
    * @param args.signature the KeylessSignature to verify
    * @returns boolean
    * @group Implementation
    * @category Account (On-Chain Model)
    */
-  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {
-    const { message, signature } = args;
-    if (this.isExpired()) {
-      return false;
-    }
-    if (!this.ephemeralKeyPair.getPublicKey().verifySignature({ message, signature: signature.ephemeralSignature })) {
-      return false;
-    }
-    return true;
+  verifySignature(args: {
+    message: HexInput;
+    signature: KeylessSignature;
+    jwk: MoveJWK;
+    keylessConfig: KeylessConfiguration;
+  }): boolean {
+    return this.publicKey.verifySignature(args);
+  }
+
+  async verifySignatureAsync(args: {
+    aptosConfig: AptosConfig;
+    message: HexInput;
+    signature: KeylessSignature;
+    options?: { throwErrorWithReason?: boolean };
+  }): Promise<boolean> {
+    return this.publicKey.verifySignatureAsync({
+      ...args,
+    });
   }
 
   /**
@@ -465,43 +485,7 @@ export abstract class AbstractKeylessAccount extends Serializable implements Key
     publicKey: KeylessPublicKey | FederatedKeylessPublicKey;
     kid: string;
   }): Promise<MoveJWK> {
-    const { aptosConfig, publicKey, kid } = args;
-    const keylessPubKey = publicKey instanceof KeylessPublicKey ? publicKey : publicKey.keylessPublicKey;
-    const { iss } = keylessPubKey;
-
-    let allJWKs: Map<string, MoveJWK[]>;
-    const jwkAddr = publicKey instanceof FederatedKeylessPublicKey ? publicKey.jwkAddress : undefined;
-    try {
-      allJWKs = await getKeylessJWKs({ aptosConfig, jwkAddr });
-    } catch (error) {
-      throw KeylessError.fromErrorType({
-        type: KeylessErrorType.FULL_NODE_JWKS_LOOKUP_ERROR,
-        error,
-        details: `Failed to fetch ${jwkAddr ? "Federated" : "Patched"}JWKs ${jwkAddr ? `for address ${jwkAddr}` : "0x1"}`,
-      });
-    }
-
-    // Find the corresponding JWK set by `iss`
-    const jwksForIssuer = allJWKs.get(iss);
-
-    if (jwksForIssuer === undefined) {
-      throw KeylessError.fromErrorType({
-        type: KeylessErrorType.INVALID_JWT_ISS_NOT_RECOGNIZED,
-        details: `JWKs for issuer ${iss} not found.`,
-      });
-    }
-
-    // Find the corresponding JWK by `kid`
-    const jwk = jwksForIssuer.find((key) => key.kid === kid);
-
-    if (jwk === undefined) {
-      throw KeylessError.fromErrorType({
-        type: KeylessErrorType.INVALID_JWT_JWK_NOT_FOUND,
-        details: `JWK with kid '${kid}' for issuer '${iss}' not found.`,
-      });
-    }
-
-    return jwk;
+    return fetchJWK(args);
   }
 }
 

package/src/account/Account.ts

@@ -6,6 +6,7 @@ import { AccountPublicKey, Ed25519PrivateKey, PrivateKeyInput, Signature, Verify
 import { Ed25519Account } from "./Ed25519Account";
 import { SingleKeyAccount } from "./SingleKeyAccount";
 import { AnyRawTransaction } from "../transactions/types";
+import { AptosConfig } from "../api";
 
 /**
  * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
@@ -331,4 +332,23 @@ export abstract class Account {
   verifySignature(args: VerifySignatureArgs): boolean {
     return this.publicKey.verifySignature(args);
   }
+
+  /**
+   * Verify the given message and signature with the public key. It fetches any on chain state if needed for verification.
+   *
+   * @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);
+  }
 }

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.");