@aptos-labs/ts-sdk 6.0.0 → 6.2.0

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -76,8 +76,9 @@ import {
   isBcsI256,
 } from "./helpers";
 import { MoveFunction, MoveModule } from "../../types";
-
-const TEXT_ENCODER = new TextEncoder();
+import { warnIfDevelopment } from "../../utils/helpers";
+import { memoizeAsync } from "../../utils/memoize";
+import { TEXT_ENCODER } from "../../utils";
 
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags.
@@ -99,8 +100,15 @@ export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<
   );
 }
 
+/**
+ * Cache TTL for module ABIs in milliseconds (5 minutes).
+ * ABIs rarely change, so a longer cache is acceptable.
+ */
+const MODULE_ABI_CACHE_TTL_MS = 5 * 60 * 1000;
+
 /**
  * Fetches the ABI of a specified module from the on-chain module ABI.
+ * Results are cached for 5 minutes to reduce redundant network calls.
  *
  * @param moduleAddress - The address of the module from which to fetch the ABI.
  * @param moduleName - The name of the module containing the ABI.
@@ -113,8 +121,16 @@ export async function fetchModuleAbi(
   moduleName: string,
   aptosConfig: AptosConfig,
 ): Promise<MoveModule | undefined> {
-  const moduleBytecode = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
-  return moduleBytecode.abi;
+  const cacheKey = `module-abi-${aptosConfig.network}-${moduleAddress}-${moduleName}`;
+
+  return memoizeAsync(
+    async () => {
+      const moduleBytecode = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
+      return moduleBytecode.abi;
+    },
+    cacheKey,
+    MODULE_ABI_CACHE_TTL_MS,
+  )();
 }
 
 /**
@@ -628,10 +644,8 @@ function parseArg(
     }
 
     if (arg instanceof Uint8Array && options?.allowUnknownStructs) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        // eslint-disable-next-line max-len
-        `Unsupported struct input type for argument ${position}. Continuing since 'allowUnknownStructs' is enabled.`,
+      warnIfDevelopment(
+        `[Aptos SDK] Unsupported struct input type for argument ${position}. Continuing since 'allowUnknownStructs' is enabled.`,
       );
       return new FixedBytes(arg);
     }

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -24,6 +24,7 @@ import { getInfo } from "../../internal/utils";
 import { getLedgerInfo } from "../../internal/general";
 import { getGasPriceEstimation } from "../../internal/transaction";
 import { NetworkToChainId } from "../../utils/apiEndpoints";
+import { MIN_MAX_GAS_AMOUNT } from "../../utils/const";
 import { normalizeBundle } from "../../utils/normalizeBundle";
 import {
   AccountAuthenticator,
@@ -222,7 +223,6 @@ export function generateTransactionPayloadWithABI(
   // Check that all arguments are accounted for
   if ((functionArguments?.length ?? 0) !== functionAbi.parameters.length) {
     throw new Error(
-      // eslint-disable-next-line max-len
       `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments?.length ?? 0}`,
     );
   }
@@ -314,7 +314,6 @@ export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWi
   // Check that all arguments are accounted for
   if (functionArguments.length !== functionAbi.parameters.length) {
     throw new Error(
-      // eslint-disable-next-line max-len
       `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,
     );
   }
@@ -392,7 +391,8 @@ export async function generateRawTransaction(args: {
     const getSequenceNumber = async () => {
       if (options?.accountSequenceNumber !== undefined) {
         return options.accountSequenceNumber;
-      } else if (options?.replayProtectionNonce !== undefined) {
+      }
+      if (options?.replayProtectionNonce !== undefined) {
         // If replay nonce is provided, use it as the sequence number
         // This is an unused value, so it's specifically to show that the sequence number is not used
         return 0xdeadbeefn;
@@ -413,7 +413,7 @@ export async function generateRawTransaction(args: {
       try {
         // Check if main signer has been created on chain, if not assign sequence number 0
         return await getSequenceNumber();
-      } catch (e: any) {
+      } catch {
         return 0;
       }
     } else {
@@ -426,8 +426,11 @@ export async function generateRawTransaction(args: {
     getSequenceNumberForAny(),
   ]);
 
+  const userMaxGas = options?.maxGasAmount
+    ? BigInt(options.maxGasAmount)
+    : BigInt(aptosConfig.getDefaultMaxGasAmount());
   const { maxGasAmount, gasUnitPrice, expireTimestamp, replayProtectionNonce } = {
-    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(aptosConfig.getDefaultMaxGasAmount()),
+    maxGasAmount: userMaxGas < BigInt(MIN_MAX_GAS_AMOUNT) ? BigInt(MIN_MAX_GAS_AMOUNT) : userMaxGas,
     gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),
     expireTimestamp:
       options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow()),
@@ -460,12 +463,14 @@ export function convertPayloadToInnerPayload(
       new TransactionExecutableScript(payload.script),
       new TransactionExtraConfigV1(undefined, replayProtectionNonce),
     );
-  } else if (payload instanceof TransactionPayloadEntryFunction) {
+  }
+  if (payload instanceof TransactionPayloadEntryFunction) {
     return new TransactionInnerPayloadV1(
       new TransactionExecutableEntryFunction(payload.entryFunction),
       new TransactionExtraConfigV1(undefined, replayProtectionNonce),
     );
-  } else if (payload instanceof TransactionPayloadMultiSig) {
+  }
+  if (payload instanceof TransactionPayloadMultiSig) {
     const innerPayload = payload.multiSig.transaction_payload;
     let executable: TransactionExecutable;
     if (innerPayload === undefined || innerPayload?.transaction_payload === undefined) {
@@ -481,9 +486,8 @@ export function convertPayloadToInnerPayload(
       executable,
       new TransactionExtraConfigV1(payload.multiSig.multisig_address, replayProtectionNonce),
     );
-  } else {
-    throw new Error(`Unsupported payload type: ${payload}`);
   }
+  throw new Error(`Unsupported payload type: ${payload}`);
 }
 
 /**
@@ -704,9 +708,7 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
           return new AnySignature(invalidSignature);
         }),
         bitmap: accountPublicKey.createBitmap({
-          bits: Array(accountPublicKey.publicKeys.length)
-            .fill(0)
-            .map((_, i) => i),
+          bits: new Array(accountPublicKey.publicKeys.length).fill(0).map((_, i) => i),
         }),
       }),
     );

package/src/transactions/typeTag/index.ts

@@ -1,9 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable class-methods-use-this */
-/* eslint-disable max-classes-per-file */
 import { Deserializer } from "../../bcs/deserializer";
 import { Serializable, Serializer } from "../../bcs/serializer";
 import { AccountAddress } from "../../core";

package/src/transactions/typeTag/parser.ts

@@ -299,7 +299,6 @@ export function parseTypeTag(typeStr: string, options?: { allowGenerics?: boolea
         throw new TypeTagParserError(typeStr, TypeTagParserErrorType.UnexpectedWhitespaceCharacter);
       }
 
-      // eslint-disable-next-line no-continue
       continue;
     } else {
       // Any other characters just append to the current string
@@ -383,7 +382,7 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
         throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedVectorTypeArgumentCount);
       }
       return new TypeTagVector(types[0]);
-    default:
+    default: {
       // Reference will have to handle the inner type
       if (isRef(trimmedStr)) {
         const actualType = trimmedStr.substring(1);
@@ -404,18 +403,16 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
       }
 
       // Parse for a struct tag
-      // eslint-disable-next-line no-case-declarations
       const structParts = trimmedStr.split("::");
       if (structParts.length !== 3) {
         throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedStructFormat);
       }
 
       // Validate struct address
-      // eslint-disable-next-line no-case-declarations
       let address: AccountAddress;
       try {
         address = AccountAddress.fromString(structParts[0]);
-      } catch (error: any) {
+      } catch {
         throw new TypeTagParserError(str, TypeTagParserErrorType.InvalidAddress);
       }
 
@@ -430,5 +427,6 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
       return new TypeTagStruct(
         new StructTag(address, new Identifier(structParts[1]), new Identifier(structParts[2]), types),
       );
+    }
   }
 }

package/src/types/generated/operations.ts

@@ -403,17 +403,6 @@ export type GetCollectionDataQuery = {
     description: string;
     last_transaction_timestamp: any;
     last_transaction_version: any;
-    cdn_asset_uris?: {
-      cdn_image_uri?: string | null;
-      asset_uri: string;
-      animation_optimizer_retry_count: number;
-      cdn_animation_uri?: string | null;
-      cdn_json_uri?: string | null;
-      image_optimizer_retry_count: number;
-      json_parser_retry_count: number;
-      raw_animation_uri?: string | null;
-      raw_image_uri?: string | null;
-    } | null;
   }>;
 };
 

package/src/types/generated/queries.ts

@@ -267,17 +267,6 @@ export const GetCollectionData = `
     description
     last_transaction_timestamp
     last_transaction_version
-    cdn_asset_uris {
-      cdn_image_uri
-      asset_uri
-      animation_optimizer_retry_count
-      cdn_animation_uri
-      cdn_json_uri
-      image_optimizer_retry_count
-      json_parser_retry_count
-      raw_animation_uri
-      raw_image_uri
-    }
   }
 }
     `;

package/src/types/types.ts

@@ -172,6 +172,11 @@ export enum AnyPublicKeyVariant {
   Secp256r1 = 2,
   Keyless = 3,
   FederatedKeyless = 4,
+  /**
+   * Post-quantum signature scheme (SLH-DSA-SHA2-128s).
+   * Note: Full implementation not yet available in this SDK.
+   */
+  SlhDsaSha2_128s = 5,
 }
 
 export function anyPublicKeyVariantToString(variant: AnyPublicKeyVariant): string {
@@ -186,6 +191,8 @@ export function anyPublicKeyVariantToString(variant: AnyPublicKeyVariant): strin
       return "keyless";
     case AnyPublicKeyVariant.FederatedKeyless:
       return "federated_keyless";
+    case AnyPublicKeyVariant.SlhDsaSha2_128s:
+      return "slh_dsa_sha2_128s";
     default:
       throw new Error("Unknown public key variant");
   }
@@ -199,6 +206,11 @@ export enum AnySignatureVariant {
   Secp256k1 = 1,
   WebAuthn = 2,
   Keyless = 3,
+  /**
+   * Post-quantum signature scheme (SLH-DSA-SHA2-128s).
+   * Note: Full implementation not yet available in this SDK.
+   */
+  SlhDsaSha2_128s = 4,
 }
 
 /**
@@ -368,6 +380,20 @@ export interface WhereArg<T extends {}> {
 
 /**
  * A configuration object for requests to the server, including API key, extra headers, and cookie handling options.
+ *
+ * Security Note: Consider implementing client-side rate limiting in your application to prevent
+ * accidental API abuse. You can use libraries like 'bottleneck' or 'p-queue' to limit request rates.
+ *
+ * @example
+ * ```typescript
+ * import Bottleneck from 'bottleneck';
+ *
+ * // Create a limiter that allows 10 requests per second
+ * const limiter = new Bottleneck({ minTime: 100, maxConcurrent: 5 });
+ *
+ * // Wrap your Aptos calls with the limiter
+ * const result = await limiter.schedule(() => aptos.getAccountInfo({ accountAddress }));
+ * ```
  */
 export type ClientConfig = ClientHeadersType & {
   WITH_CREDENTIALS?: boolean;

package/src/utils/const.ts

@@ -24,7 +24,18 @@ export enum AptosApiType {
  * @group Implementation
  * @category Utils
  */
-export const DEFAULT_MAX_GAS_AMOUNT = 200000;
+export const DEFAULT_MAX_GAS_AMOUNT = 2000000;
+
+/**
+ * The minimum max gas amount that the SDK will allow for a transaction.
+ *
+ * This value acts as a floor to prevent transactions from being built with a max gas amount
+ * below the network's minimum transaction gas units, which would cause
+ * MAX_GAS_UNITS_BELOW_MIN_TRANSACTION_GAS_UNITS errors.
+ * @group Implementation
+ * @category Utils
+ */
+export const MIN_MAX_GAS_AMOUNT = 2000;
 
 /**
  * The default transaction expiration seconds from now.
@@ -98,3 +109,8 @@ export enum ProcessorType {
  * where project-id can contain letters, numbers, hyphens, and underscores
  */
 export const FIREBASE_AUTH_ISS_PATTERN = /^https:\/\/securetoken\.google\.com\/[a-zA-Z0-9-_]+$/;
+
+/**
+ * Shared TextEncoder instance for string serialization to avoid repeated instantiation.
+ */
+export const TEXT_ENCODER = new TextEncoder();

package/src/utils/helpers.ts

@@ -1,11 +1,52 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { decode } from "js-base64";
+import { Base64, decode } from "js-base64";
 import { MoveFunctionId, MoveStructId } from "../types";
 import { AccountAddress } from "../core/accountAddress";
 import { createObjectAddress } from "../core/account/utils/address";
 
+/**
+ * Checks if the current runtime environment is Bun.
+ * This is useful for detecting Bun-specific compatibility issues.
+ *
+ * @returns true if running in Bun, false otherwise.
+ * @group Implementation
+ * @category Utils
+ */
+export function isBun(): boolean {
+  try {
+    // Bun exposes a global `Bun` object.
+    return typeof globalThis !== "undefined" && "Bun" in globalThis;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Logs a warning message to the console only in development environments.
+ * This function helps reduce information leakage in production while maintaining
+ * helpful warnings during development.
+ *
+ * @param message - The warning message to log.
+ * @group Implementation
+ * @category Utils
+ */
+export function warnIfDevelopment(message: string): void {
+  // Check common environment variables to determine if we're in development
+  // This works in Node.js, bundlers like webpack/vite, and most build systems
+  const isDevelopment =
+    typeof process !== "undefined" &&
+    process.env &&
+    (process.env.NODE_ENV === "development" ||
+      process.env.NODE_ENV === "test" ||
+      process.env.APTOS_SDK_WARNINGS === "true");
+
+  if (isDevelopment) {
+    console.warn(message);
+  }
+}
+
 /**
  * Sleep for the specified amount of time in milliseconds.
  * This function can be used to introduce delays in asynchronous operations.
@@ -80,8 +121,8 @@ export function base64UrlToBytes(base64Url: string): Uint8Array {
   while (base64.length % 4 !== 0) {
     base64 += "=";
   }
-  // Use Buffer to convert base64 to Uint8Array
-  return new Uint8Array(Buffer.from(base64, "base64"));
+  // Use js-base64 to convert base64 to Uint8Array
+  return Base64.toUint8Array(base64);
 }
 
 /**
@@ -154,7 +195,6 @@ export const parseEncodedStruct = (structObj: {
   module_name: string;
   struct_name: string;
 }): MoveStructId => {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
   const { account_address, module_name, struct_name } = structObj;
   const moduleName = hexToAscii(module_name);
   const structName = hexToAscii(struct_name);
@@ -241,7 +281,6 @@ export function truncateAddress(address: string, start: number = 6, end: number
  * Constants for metadata address calculation
  */
 const APTOS_COIN_TYPE_STR = "0x1::aptos_coin::AptosCoin";
-const APT_METADATA_ADDRESS_HEX = AccountAddress.A.toStringLong();
 
 /**
  * Helper function to standardize Move type string by converting all addresses to short form,
@@ -252,10 +291,10 @@ function standardizeMoveTypeString(input: string): string {
   // This regex matches "0x" followed by hex digits, handling both standalone addresses and those within <>
   const addressRegex = /0x[0-9a-fA-F]+/g;
 
-  return input.replace(addressRegex, (match) => {
+  return input.replace(addressRegex, (match) =>
     // Use AccountAddress to handle the address
-    return AccountAddress.from(match, { maxMissingChars: 63 }).toStringShort();
-  });
+    AccountAddress.from(match, { maxMissingChars: 63 }).toStringShort(),
+  );
 }
 
 /**

package/src/utils/memoize.ts

@@ -2,18 +2,130 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * The global cache Map shared across all functions.  Must keep care to ensure that the
- * cache keys are unique across all functions.
+ * Maximum number of entries to keep in the cache to prevent unbounded memory growth.
+ * When this limit is exceeded, the oldest entries are evicted.
+ */
+const MAX_CACHE_SIZE = 1000;
+
+/**
+ * Interval in milliseconds for periodic cleanup of expired cache entries.
+ */
+const CLEANUP_INTERVAL_MS = 60000; // 1 minute
+
+/**
+ * Minimum required key length to help ensure uniqueness.
+ * Keys should include a namespace prefix (e.g., "module-abi-", "ledger-info-").
+ */
+const MIN_KEY_LENGTH = 10;
+
+/**
+ * Set of known cache key prefixes to help detect potential collisions.
+ * Each caller should use a unique prefix.
+ */
+const knownKeyPrefixes = new Set<string>();
+
+/**
+ * Validates a cache key for basic security requirements.
+ * @param key - The cache key to validate
+ * @throws Error if the key is invalid
+ */
+function validateCacheKey(key: string): void {
+  if (!key || typeof key !== "string") {
+    throw new Error("Cache key must be a non-empty string");
+  }
+  if (key.length < MIN_KEY_LENGTH) {
+    throw new Error(
+      `Cache key "${key}" is too short. Keys should be at least ${MIN_KEY_LENGTH} characters and include a namespace prefix.`,
+    );
+  }
+  // Extract prefix (everything before the last hyphen or the first 10 chars)
+  const prefixMatch = key.match(/^([a-z]+-[a-z]+-)/i);
+  if (prefixMatch) {
+    knownKeyPrefixes.add(prefixMatch[1]);
+  }
+}
+
+/**
+ * Cache entry structure with value, timestamp, and last access time for LRU eviction.
+ */
+interface CacheEntry<T> {
+  value: T;
+  timestamp: number;
+  lastAccess: number;
+  ttlMs?: number;
+}
+
+/**
+ * The global cache Map shared across all functions with LRU eviction support.
+ * SECURITY: All cache keys should include a unique namespace prefix to prevent
+ * collisions between different caching use cases (e.g., "module-abi-", "ledger-info-").
  * @group Implementation
  * @category Utils
  */
-const cache = new Map<string, { value: any; timestamp: number }>();
+const cache = new Map<string, CacheEntry<any>>();
+
+/**
+ * Track whether cleanup interval is set up.
+ */
+let cleanupIntervalId: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Sets up periodic cleanup of expired cache entries if not already running.
+ * This prevents memory leaks from accumulating expired entries.
+ */
+function ensureCleanupInterval(): void {
+  if (cleanupIntervalId === null) {
+    cleanupIntervalId = setInterval(() => {
+      const now = Date.now();
+      const keysToDelete: string[] = [];
+
+      cache.forEach((entry, key) => {
+        // Remove entries that have expired
+        if (entry.ttlMs !== undefined && now - entry.timestamp > entry.ttlMs) {
+          keysToDelete.push(key);
+        }
+      });
+
+      keysToDelete.forEach((key) => cache.delete(key));
+
+      // If cache is empty, stop the cleanup interval to avoid unnecessary overhead
+      if (cache.size === 0 && cleanupIntervalId !== null) {
+        clearInterval(cleanupIntervalId);
+        cleanupIntervalId = null;
+      }
+    }, CLEANUP_INTERVAL_MS);
+
+    // Ensure the interval doesn't prevent Node.js from exiting
+    if (typeof cleanupIntervalId === "object" && "unref" in cleanupIntervalId) {
+      cleanupIntervalId.unref();
+    }
+  }
+}
+
+/**
+ * Evicts the least recently used entries when cache exceeds maximum size.
+ */
+function evictIfNeeded(): void {
+  if (cache.size >= MAX_CACHE_SIZE) {
+    // Find and remove the least recently accessed entries (remove ~10% of cache)
+    const entriesToRemove = Math.ceil(MAX_CACHE_SIZE * 0.1);
+    const entries = Array.from(cache.entries()).sort((a, b) => a[1].lastAccess - b[1].lastAccess);
+
+    for (let i = 0; i < entriesToRemove && i < entries.length; i += 1) {
+      cache.delete(entries[i][0]);
+    }
+  }
+}
 
 /**
  * A memoize higher-order function to cache the response of an async function.
  * This function helps to improve performance by avoiding repeated calls to the same async function with the same arguments
  * within a specified time-to-live (TTL).
  *
+ * Features:
+ * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries
+ * - Periodic cleanup of expired entries to prevent memory leaks
+ *
  * @param func The async function to cache the result of.
  * @param key The cache key used to store the result.
  * @param ttlMs The time-to-live in milliseconds for cached data.
@@ -26,20 +138,35 @@ export function memoizeAsync<T>(
   key: string,
   ttlMs?: number,
 ): (...args: any[]) => Promise<T> {
+  // Validate key format on first call to catch misuse early
+  validateCacheKey(key);
+
   return async (...args: any[]) => {
+    const now = Date.now();
+
     // Check if the cached result exists and is within TTL
     if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key)!;
-      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
-        return value;
+      const entry = cache.get(key)!;
+      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {
+        // Update last access time for LRU
+        entry.lastAccess = now;
+        return entry.value;
       }
+      // Entry expired, remove it
+      cache.delete(key);
     }
 
     // If not cached or TTL expired, compute the result
     const result = await func(...args);
 
+    // Evict old entries if needed before adding new one
+    evictIfNeeded();
+
     // Cache the result with a timestamp
-    cache.set(key, { value: result, timestamp: Date.now() });
+    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });
+
+    // Ensure cleanup is running
+    ensureCleanupInterval();
 
     return result;
   };
@@ -48,6 +175,10 @@ export function memoizeAsync<T>(
 /**
  * Caches the result of a function call to improve performance on subsequent calls with the same arguments.
  *
+ * Features:
+ * - LRU eviction when cache exceeds MAX_CACHE_SIZE entries
+ * - Periodic cleanup of expired entries to prevent memory leaks
+ *
  * @param key - The key to cache on, all accesses by this key will return the cached value.
  * @param func - The function whose result will be cached.
  * @param ttlMs - The time-to-live in milliseconds for cached data.
@@ -56,21 +187,56 @@ export function memoizeAsync<T>(
  * @category Utils
  */
 export function memoize<T>(func: (...args: any[]) => T, key: string, ttlMs?: number): (...args: any[]) => T {
+  // Validate key format on first call to catch misuse early
+  validateCacheKey(key);
+
   return (...args: any[]) => {
+    const now = Date.now();
+
     // Check if the cached result exists and is within TTL
     if (cache.has(key)) {
-      const { value, timestamp } = cache.get(key)!;
-      if (ttlMs === undefined || Date.now() - timestamp <= ttlMs) {
-        return value;
+      const entry = cache.get(key)!;
+      if (ttlMs === undefined || now - entry.timestamp <= ttlMs) {
+        // Update last access time for LRU
+        entry.lastAccess = now;
+        return entry.value;
       }
+      // Entry expired, remove it
+      cache.delete(key);
     }
 
     // If not cached or TTL expired, compute the result
     const result = func(...args);
 
+    // Evict old entries if needed before adding new one
+    evictIfNeeded();
+
     // Cache the result with a timestamp
-    cache.set(key, { value: result, timestamp: Date.now() });
+    cache.set(key, { value: result, timestamp: now, lastAccess: now, ttlMs });
+
+    // Ensure cleanup is running
+    ensureCleanupInterval();
 
     return result;
   };
 }
+
+/**
+ * Clears all entries from the memoization cache.
+ * Useful for testing or when you need to force fresh data.
+ * @group Implementation
+ * @category Utils
+ */
+export function clearMemoizeCache(): void {
+  cache.clear();
+}
+
+/**
+ * Returns the current size of the memoization cache.
+ * Useful for monitoring and debugging.
+ * @group Implementation
+ * @category Utils
+ */
+export function getMemoizeCacheSize(): number {
+  return cache.size;
+}

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "6.0.0";
+export const VERSION = "6.2.0";