@aptos-labs/ts-sdk 6.0.0 → 6.2.0

package/src/bcs/serializable/movePrimitives.ts

@@ -1,6 +1,5 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
-
 import {
   MAX_U128_BIG_INT,
   MAX_U16_NUMBER,
@@ -77,14 +76,14 @@ export class Bool extends Serializable implements TransactionArgument {
   /**
    * Serializes the current instance for use in an entry function by converting it to a byte sequence.
    * This allows the instance to be properly formatted for serialization in transactions.
+   * Uses the optimized serializeAsBytes method to reduce allocations.
    *
    * @param serializer - The serializer instance used to serialize the byte sequence.
    * @group Implementation
    * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   /**
@@ -107,7 +106,7 @@ export class Bool extends Serializable implements TransactionArgument {
    * @group Implementation
    * @category BCS
    */
-  // eslint-disable-next-line class-methods-use-this
+
   deserialize(deserializer: Deserializer) {
     return new U256(deserializer.deserializeU256());
   }
@@ -139,8 +138,7 @@ export class U8 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -176,8 +174,7 @@ export class U16 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -212,8 +209,7 @@ export class U32 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -251,8 +247,7 @@ export class U64 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -288,8 +283,7 @@ export class U128 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -325,8 +319,7 @@ export class U256 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -361,8 +354,7 @@ export class I8 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -398,8 +390,7 @@ export class I16 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -434,8 +425,7 @@ export class I32 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -473,8 +463,7 @@ export class I64 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -510,8 +499,7 @@ export class I128 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -547,8 +535,7 @@ export class I256 extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {

package/src/bcs/serializable/moveStructs.ts

@@ -69,14 +69,14 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
   /**
    * Serializes the current instance into a byte sequence suitable for entry functions.
    * This allows the data to be properly formatted for transmission or storage.
+   * Uses the optimized serializeAsBytes method to reduce allocations.
    *
    * @param serializer - The serializer instance used to serialize the byte sequence.
    * @group Implementation
    * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   /**
@@ -493,8 +493,7 @@ export class MoveString extends Serializable implements TransactionArgument {
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
@@ -531,8 +530,7 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
   }
 
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   /**

package/src/bcs/serializer.ts

@@ -1,7 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-/* eslint-disable no-bitwise */
 import {
   MAX_U128_BIG_INT,
   MAX_U16_NUMBER,
@@ -24,6 +23,7 @@ import {
 } from "./consts";
 import { Hex } from "../core/hex";
 import { AnyNumber, Uint16, Uint32, Uint8 } from "../types";
+import { TEXT_ENCODER } from "../utils/const";
 
 /**
  * This class serves as a base class for all serializable types. It facilitates
@@ -77,6 +77,41 @@ export abstract class Serializable {
   }
 }
 
+/**
+ * Minimum buffer growth increment to avoid too many small reallocations.
+ */
+const MIN_BUFFER_GROWTH = 256;
+
+/**
+ * Pool of reusable Serializer instances for temporary serialization operations.
+ * This reduces allocations when using serializeAsBytes() repeatedly.
+ */
+const serializerPool: Serializer[] = [];
+const MAX_POOL_SIZE = 8;
+
+/**
+ * Acquires a Serializer from the pool or creates a new one.
+ * @internal
+ */
+function acquireSerializer(): Serializer {
+  const serializer = serializerPool.pop();
+  if (serializer) {
+    serializer.reset();
+    return serializer;
+  }
+  return new Serializer();
+}
+
+/**
+ * Returns a Serializer to the pool for reuse.
+ * @internal
+ */
+function releaseSerializer(serializer: Serializer): void {
+  if (serializerPool.length < MAX_POOL_SIZE) {
+    serializerPool.push(serializer);
+  }
+}
+
 /**
  * A class for serializing various data types into a binary format.
  * It provides methods to serialize strings, bytes, numbers, and other serializable objects
@@ -90,6 +125,12 @@ export class Serializer {
 
   private offset: number;
 
+  /**
+   * Reusable DataView instance to reduce allocations during serialization.
+   * Recreated when buffer is resized.
+   */
+  private dataView: DataView;
+
   /**
    * Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
    * The `length` must be greater than 0.
@@ -103,23 +144,33 @@ export class Serializer {
       throw new Error("Length needs to be greater than 0");
     }
     this.buffer = new ArrayBuffer(length);
+    this.dataView = new DataView(this.buffer);
     this.offset = 0;
   }
 
   /**
    * Ensures that the internal buffer can accommodate the specified number of bytes.
-   * This function dynamically resizes the buffer if the current size is insufficient.
+   * This function dynamically resizes the buffer using a growth factor of 1.5x with
+   * a minimum growth increment to balance memory usage and reallocation frequency.
    *
    * @param bytes - The number of bytes to ensure the buffer can handle.
    * @group Implementation
    * @category BCS
    */
   private ensureBufferWillHandleSize(bytes: number) {
-    while (this.buffer.byteLength < this.offset + bytes) {
-      const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
-      new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
-      this.buffer = newBuffer;
+    const requiredSize = this.offset + bytes;
+    if (this.buffer.byteLength >= requiredSize) {
+      return;
     }
+
+    // Calculate new size: max of (1.5x current size) or (current + required + MIN_GROWTH)
+    // Using 1.5x instead of 2x provides better memory efficiency
+    const growthSize = Math.max(Math.floor(this.buffer.byteLength * 1.5), requiredSize + MIN_BUFFER_GROWTH);
+
+    const newBuffer = new ArrayBuffer(growthSize);
+    new Uint8Array(newBuffer).set(new Uint8Array(this.buffer, 0, this.offset));
+    this.buffer = newBuffer;
+    this.dataView = new DataView(this.buffer);
   }
 
   /**
@@ -137,6 +188,7 @@ export class Serializer {
 
   /**
    * Serializes a value into the buffer using the provided function, ensuring the buffer can accommodate the size.
+   * Uses the cached DataView instance for better performance.
    *
    * @param fn - The function to serialize the value, which takes a byte offset, the value to serialize, and an optional little-endian flag.
    * @param fn.byteOffset - The byte offset at which to write the value.
@@ -152,8 +204,7 @@ export class Serializer {
     value: number,
   ) {
     this.ensureBufferWillHandleSize(bytesLength);
-    const dv = new DataView(this.buffer, this.offset);
-    fn.apply(dv, [0, value, true]);
+    fn.apply(this.dataView, [this.offset, value, true]);
     this.offset += bytesLength;
   }
 
@@ -177,8 +228,7 @@ export class Serializer {
    * @category BCS
    */
   serializeStr(value: string) {
-    const textEncoder = new TextEncoder();
-    this.serializeBytes(textEncoder.encode(value));
+    this.serializeBytes(TEXT_ENCODER.encode(value));
   }
 
   /**
@@ -473,13 +523,57 @@ export class Serializer {
    * Returns the buffered bytes as a Uint8Array.
    *
    * This function allows you to retrieve the byte representation of the buffer up to the current offset.
+   * For better performance, returns a view when the buffer is exactly the right size, or copies
+   * only the used portion otherwise.
    *
    * @returns Uint8Array - The byte array representation of the buffer.
    * @group Implementation
    * @category BCS
    */
   toUint8Array(): Uint8Array {
-    return new Uint8Array(this.buffer).slice(0, this.offset);
+    // Return a copy of only the used portion of the buffer
+    // Using subarray + slice pattern for efficiency
+    return new Uint8Array(this.buffer, 0, this.offset).slice();
+  }
+
+  /**
+   * Resets the serializer to its initial state, allowing the buffer to be reused.
+   * This clears the buffer contents to prevent data leakage between uses.
+   *
+   * @group Implementation
+   * @category BCS
+   */
+  reset(): void {
+    // Clear buffer contents to prevent data leakage when reusing pooled serializers
+    // Only clear the portion that was used (up to offset) for efficiency
+    if (this.offset > 0) {
+      new Uint8Array(this.buffer, 0, this.offset).fill(0);
+    }
+    this.offset = 0;
+  }
+
+  /**
+   * Returns the current number of bytes written to the serializer.
+   *
+   * @returns The number of bytes written.
+   * @group Implementation
+   * @category BCS
+   */
+  getOffset(): number {
+    return this.offset;
+  }
+
+  /**
+   * Returns a view of the serialized bytes without copying.
+   * WARNING: The returned view is only valid until the next write operation.
+   * Use toUint8Array() if you need a persistent copy.
+   *
+   * @returns A Uint8Array view of the buffer (not a copy).
+   * @group Implementation
+   * @category BCS
+   */
+  toUint8ArrayView(): Uint8Array {
+    return new Uint8Array(this.buffer, 0, this.offset);
   }
 
   /**
@@ -497,6 +591,47 @@ export class Serializer {
     value.serialize(this);
   }
 
+  /**
+   * Serializes a Serializable value as a byte array with a length prefix.
+   * This is the optimized pattern for entry function argument serialization.
+   *
+   * Instead of:
+   * ```typescript
+   * const bcsBytes = value.bcsToBytes();  // Creates new Serializer, copies bytes
+   * serializer.serializeBytes(bcsBytes);
+   * ```
+   *
+   * Use:
+   * ```typescript
+   * serializer.serializeAsBytes(value);  // Uses pooled Serializer, avoids extra copy
+   * ```
+   *
+   * This method uses a pooled Serializer instance to reduce allocations and
+   * directly appends the serialized bytes with a length prefix.
+   *
+   * @param value - The Serializable value to serialize as bytes.
+   * @group Implementation
+   * @category BCS
+   */
+  serializeAsBytes<T extends Serializable>(value: T): void {
+    // Acquire a pooled serializer for temporary use
+    const tempSerializer = acquireSerializer();
+
+    try {
+      // Serialize the value to the temporary serializer
+      value.serialize(tempSerializer);
+
+      // Get the serialized bytes (as a view to avoid copying)
+      const bytes = tempSerializer.toUint8ArrayView();
+
+      // Serialize with length prefix to this serializer
+      this.serializeBytes(bytes);
+    } finally {
+      // Return the serializer to the pool for reuse
+      releaseSerializer(tempSerializer);
+    }
+  }
+
   /**
    * Serializes an array of BCS Serializable values to a serializer instance.
    * The bytes are added to the serializer instance's byte buffer.
@@ -630,7 +765,7 @@ export function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T
 function checkNumberRange<T extends AnyNumber>(minValue: T, maxValue: T) {
   return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {
     const childFunction = descriptor.value;
-    // eslint-disable-next-line no-param-reassign
+
     descriptor.value = function deco(value: AnyNumber) {
       validateNumberInRange(value, minValue, maxValue);
       return childFunction.apply(this, [value]);

package/src/cli/localNode.ts

@@ -1,8 +1,6 @@
-/* eslint-disable no-console */
-
-import { ChildProcessWithoutNullStreams, spawn } from "child_process";
+import { ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import kill from "tree-kill";
-import { platform } from "os";
+import { platform } from "node:os";
 
 import { sleep } from "../utils/helpers";
 
@@ -130,9 +128,8 @@ export class LocalNode {
     let last = start;
 
     while (!operational && start + this.MAXIMUM_WAIT_TIME_SEC > last) {
-      // eslint-disable-next-line no-await-in-loop
       await sleep(1000);
-      // eslint-disable-next-line no-await-in-loop
+
       operational = await this.checkIfProcessIsUp();
       last = Date.now() / 1000;
     }
@@ -161,7 +158,7 @@ export class LocalNode {
         return true;
       }
       return false;
-    } catch (err: any) {
+    } catch {
       return false;
     }
   }

package/src/cli/move.ts

@@ -1,5 +1,5 @@
-import { spawn } from "child_process";
-import { platform } from "os";
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
 
 import { AccountAddress } from "../core";
 import { Network } from "../utils";
@@ -353,7 +353,7 @@ export class Move {
    * @group Implementation
    * @category CLI
    */
-  // eslint-disable-next-line class-methods-use-this
+
   private async runCommand(args: Array<string>, showStdout: boolean = true): Promise<{ result?: any; output: string }> {
     return new Promise((resolve, reject) => {
       const currentPlatform = platform();
@@ -391,7 +391,7 @@ export class Move {
             } else if (parsed.Result) {
               resolve({ result: parsed.Result, output: stdout }); // Resolve if the "Result" key exists
             }
-          } catch (error: any) {
+          } catch {
             // resolve the stdout as it might be just a stdout
             resolve({ output: stdout });
           }
@@ -411,7 +411,7 @@ export class Move {
    * @group Implementation
    * @category CLI
    */
-  // eslint-disable-next-line class-methods-use-this
+
   private prepareNamedAddresses(namedAddresses: Map<string, AccountAddress>): Array<string> {
     const totalNames = namedAddresses.size;
     const newArgs: Array<string> = [];
@@ -442,7 +442,7 @@ export class Move {
    * @group Implementation
    * @category CLI
    */
-  // eslint-disable-next-line class-methods-use-this
+
   private parseNamedAddresses(namedAddresses: Record<string, AccountAddress>): Map<string, AccountAddress> {
     const addressesMap = new Map();
 
@@ -463,7 +463,7 @@ export class Move {
    * @group Implementation
    * @category CLI
    */
-  // eslint-disable-next-line class-methods-use-this
+
   private extractAddressFromOutput(output: string): string {
     const match = output.match("Code was successfully deployed to object address (0x[0-9a-fA-F]+)");
     if (match) {

package/src/client/get.ts

@@ -162,11 +162,10 @@ 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: Res = new Array(0) as Res;
+  let out: Res = [] as unknown as Res;
   let cursor: string | undefined;
   const requestParams = options.params as { start?: string; limit?: number };
   do {
-    // eslint-disable-next-line no-await-in-loop
     const response = await get<Req, Res>({
       type: AptosApiType.FULLNODE,
       aptosConfig: options.aptosConfig,
@@ -186,7 +185,8 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
     // Now that we have the cursor (if any), we remove the headers before
     // adding these to the output of this function.
     delete response.headers;
-    out.push(...response.data);
+    // Use concat instead of push(...) for better performance with large arrays
+    out = out.concat(response.data) as Res;
     requestParams.start = cursor;
   } while (cursor !== null && cursor !== undefined);
   return out;
@@ -196,12 +196,11 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
 export async function paginateWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
-  const out: Res = new Array(0) as Res;
+  let out: Res = [] as unknown as Res;
   let cursor: string | undefined;
   const requestParams = options.params as { start?: string; limit?: number };
   const totalLimit = requestParams.limit;
   do {
-    // eslint-disable-next-line no-await-in-loop
     const { response, cursor: newCursor } = await getPageWithObfuscatedCursor<Req, Res>({ ...options });
 
     /**
@@ -210,7 +209,8 @@ export async function paginateWithObfuscatedCursor<Req extends Record<string, an
      * to query the next chunk of data.
      */
     cursor = newCursor;
-    out.push(...response.data);
+    // Use concat instead of push(...) for better performance with large arrays
+    out = out.concat(response.data) as Res;
     if (options?.params) {
       options.params.start = cursor;
     }
@@ -230,8 +230,7 @@ export async function paginateWithObfuscatedCursor<Req extends Record<string, an
 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 } = {};
+  const requestParams: { start?: string; limit?: number } = {};
 
   // Drop any other values
   // TODO: Throw error if cursor is not a string
@@ -242,7 +241,6 @@ export async function getPageWithObfuscatedCursor<Req extends Record<string, any
     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,
@@ -257,6 +255,6 @@ export async function getPageWithObfuscatedCursor<Req extends Record<string, any
    * 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"];
+  const cursor = response.headers["x-aptos-cursor"] ?? undefined;
   return { response, cursor };
 }

package/src/core/account/utils/address.ts

@@ -1,6 +1,7 @@
 import { sha3_256 } from "@noble/hashes/sha3";
 import { AccountAddress } from "../../accountAddress";
 import { DeriveScheme } from "../../../types";
+import { TEXT_ENCODER } from "../../../utils/const";
 
 /**
  * Creates an object address from creator address and seed
@@ -14,8 +15,7 @@ import { DeriveScheme } from "../../../types";
  */
 export const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {
   const creatorBytes = creatorAddress.bcsToBytes();
-
-  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+  const seedBytes = typeof seed === "string" ? TEXT_ENCODER.encode(seed) : seed;
 
   const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveObjectAddressFromSeed]);
 
@@ -35,7 +35,7 @@ export const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8A
 export const createResourceAddress = (creatorAddress: AccountAddress, seed: Uint8Array | string): AccountAddress => {
   const creatorBytes = creatorAddress.bcsToBytes();
 
-  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+  const seedBytes = typeof seed === "string" ? TEXT_ENCODER.encode(seed) : seed;
 
   const bytes = new Uint8Array([...creatorBytes, ...seedBytes, DeriveScheme.DeriveResourceAccountAddress]);
 

package/src/core/accountAddress.ts

@@ -240,14 +240,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
   /**
    * Serializes the current instance into a byte sequence suitable for entry functions.
    * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+   * Uses the optimized serializeAsBytes method to reduce allocations.
    *
    * @param serializer - The serializer instance used to convert the data into bytes.
    * @group Implementation
    * @category Serialization
    */
   serializeForEntryFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeAsBytes(this);
   }
 
   /**
@@ -339,7 +339,6 @@ export class AccountAddress extends Serializable implements TransactionArgument
       } else if (input.length !== 3) {
         // 0x + one hex char is the only valid SHORT form for special addresses.
         throw new ParsingError(
-          // eslint-disable-next-line max-len
           `The given hex string ${input} is a special address not in LONG form, it must be 0x0 to 0xf without padding zeroes.`,
           AddressInvalidReason.INVALID_PADDING_ZEROES,
         );

package/src/core/crypto/abstraction.ts

@@ -35,17 +35,14 @@ export class AbstractPublicKey extends AccountPublicKey {
     return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
   }
 
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
   verifySignature(args: VerifySignatureArgs): boolean {
     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.");
   }