@aptos-labs/ts-sdk 6.0.0 → 6.1.0

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,
@@ -77,6 +76,46 @@ export abstract class Serializable {
   }
 }
 
+/**
+ * Minimum buffer growth increment to avoid too many small reallocations.
+ */
+const MIN_BUFFER_GROWTH = 256;
+
+/**
+ * Shared TextEncoder instance for string serialization to avoid repeated instantiation.
+ */
+const TEXT_ENCODER = new TextEncoder();
+
+/**
+ * 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 +129,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 +148,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 +192,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 +208,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 +232,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 +527,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 +595,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 +769,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

@@ -130,9 +130,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 +160,7 @@ export class LocalNode {
         return true;
       }
       return false;
-    } catch (err: any) {
+    } catch {
       return false;
     }
   }

package/src/cli/move.ts

@@ -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/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,17 @@ 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
+  // eslint-disable-next-line @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
+  // eslint-disable-next-line @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
+  // eslint-disable-next-line @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

@@ -250,7 +250,13 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @group Implementation
    * @category Serialization
    */
-  private readonly signingKey: Hex;
+  private signingKey: Hex;
+
+  /**
+   * Whether the key has been cleared from memory
+   * @private
+   */
+  private cleared: boolean = false;
 
   // region Constructors
 
@@ -336,14 +342,63 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
 
   // region PrivateKey
 
+  /**
+   * Checks if the key has been cleared and throws an error if so.
+   * @private
+   */
+  private ensureNotCleared(): void {
+    if (this.cleared) {
+      throw new Error("Private key has been cleared from memory and can no longer be used");
+    }
+  }
+
+  /**
+   * Clears the private key from memory by overwriting it with random bytes.
+   * After calling this method, the private key can no longer be used for signing or deriving public keys.
+   *
+   * Note: Due to JavaScript's memory management, this cannot guarantee complete removal of
+   * sensitive data from memory, but it significantly reduces the window of exposure.
+   *
+   * @group Implementation
+   * @category Serialization
+   */
+  clear(): void {
+    if (!this.cleared) {
+      const keyBytes = this.signingKey.toUint8Array();
+      // Multiple overwrite passes for better security
+      // Pass 1: Random data
+      crypto.getRandomValues(keyBytes);
+      // Pass 2: Ones pattern (0xFF)
+      keyBytes.fill(0xff);
+      // Pass 3: Random data again
+      crypto.getRandomValues(keyBytes);
+      // Pass 4: Zeros pattern (final state)
+      keyBytes.fill(0);
+      this.cleared = true;
+    }
+  }
+
+  /**
+   * Returns whether the private key has been cleared from memory.
+   *
+   * @returns true if the key has been cleared, false otherwise
+   * @group Implementation
+   * @category Serialization
+   */
+  isCleared(): boolean {
+    return this.cleared;
+  }
+
   /**
    * Derive the Ed25519PublicKey for this private key.
    *
    * @returns Ed25519PublicKey - The derived public key corresponding to the private key.
+   * @throws Error if the private key has been cleared from memory.
    * @group Implementation
    * @category Serialization
    */
   publicKey(): Ed25519PublicKey {
+    this.ensureNotCleared();
     const bytes = ed25519.getPublicKey(this.signingKey.toUint8Array());
     return new Ed25519PublicKey(bytes);
   }
@@ -354,10 +409,12 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    *
    * @param message - A message as a string or Uint8Array in HexInput format.
    * @returns A digital signature for the provided message.
+   * @throws Error if the private key has been cleared from memory.
    * @group Implementation
    * @category Serialization
    */
   sign(message: HexInput): Ed25519Signature {
+    this.ensureNotCleared();
     const messageToSign = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();
     const signatureBytes = ed25519.sign(messageBytes, this.signingKey.toUint8Array());
@@ -368,10 +425,12 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * Get the private key in bytes (Uint8Array).
    *
    * @returns Uint8Array representation of the private key
+   * @throws Error if the private key has been cleared from memory.
    * @group Implementation
    * @category Serialization
    */
   toUint8Array(): Uint8Array {
+    this.ensureNotCleared();
     return this.signingKey.toUint8Array();
   }
 
@@ -379,10 +438,12 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * Get the private key as a hex string with the 0x prefix.
    *
    * @returns string representation of the private key.
+   * @throws Error if the private key has been cleared from memory.
    * @group Implementation
    * @category Serialization
    */
   toString(): string {
+    this.ensureNotCleared();
     return this.toAIP80String();
   }
 
@@ -390,8 +451,10 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * Get the private key as a hex string with the 0x prefix.
    *
    * @returns string representation of the private key.
+   * @throws Error if the private key has been cleared from memory.
    */
   toHexString(): string {
+    this.ensureNotCleared();
     return this.signingKey.toString();
   }
 
@@ -401,8 +464,10 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
    *
    * @returns AIP-80 compliant string representation of the private key.
+   * @throws Error if the private key has been cleared from memory.
    */
   toAIP80String(): string {
+    this.ensureNotCleared();
     return PrivateKey.formatPrivateKey(this.signingKey.toString(), PrivateKeyVariants.Ed25519);
   }
 

package/src/core/crypto/federatedKeyless.ts

@@ -84,7 +84,7 @@ export class FederatedKeylessPublicKey extends AccountPublicKey {
     try {
       verifyKeylessSignatureWithJwkAndConfig({ ...args, publicKey: this });
       return true;
-    } catch (error) {
+    } catch {
       return false;
     }
   }