TradingReadinessCache.ts

/**
 * Global singleton cache for Perps signing operations
 *
 * This cache persists across provider reconnections to prevent repeated
 * signing requests for hardware wallets. Critical for preventing repeated
 * hardware wallet signing prompts.
 *
 * Cache is intentionally kept separate from provider instances because providers
 * are recreated on account/network changes, which would reset instance-level caches.
 *
 * Tracks three signing operations:
 * 1. Unified Account enablement (one-time, replaces deprecated DEX abstraction)
 * 2. Builder Fee approval (required for trading)
 * 3. Referral code setup (one-time per account)
 *
 * Cache Structure:
 * - Key: `network:userAddress` (e.g., "mainnet:0x123...")
 * - Value: { unifiedAccount, builderFee, referral, timestamp }
 *
 * Lifecycle:
 * - Cache persists throughout app session
 * - Individual entries can be cleared per user/network
 * - Full cache can be cleared on app restart or explicit user action
 */

type SigningOperationState = {
  attempted: boolean; // Whether we've attempted this operation
  success: boolean; // Whether it succeeded (only valid if attempted=true)
};

type PerpsSigningCacheEntry = {
  unifiedAccount: SigningOperationState;
  builderFee: SigningOperationState;
  referral: SigningOperationState;
  timestamp: number; // When this entry was last updated
};

// Legacy interface for backward compatibility
type TradingReadinessCacheEntry = {
  attempted: boolean;
  enabled: boolean;
  timestamp: number;
};

class PerpsSigningCacheManager {
  static #instance: PerpsSigningCacheManager;

  readonly #cache: Map<string, PerpsSigningCacheEntry> = new Map();

  // Global in-flight locks to prevent concurrent signing attempts across providers
  // Key: operationType:network:userAddress, Value: Promise that resolves when operation completes
  readonly #inFlightOperations: Map<string, Promise<void>> = new Map();

  // Singleton: use getInstance() instead of new
  protected constructor() {
    // Protected constructor for singleton
  }

  public static getInstance(): PerpsSigningCacheManager {
    PerpsSigningCacheManager.#instance ??= new PerpsSigningCacheManager();
    return PerpsSigningCacheManager.#instance;
  }

  // ===== In-Flight Lock Methods =====

  /**
   * Check if an operation is currently in-flight for this user/network
   *
   * @param operationType - The type of operation being performed.
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @returns The resulting string value.
   */
  public isInFlight(
    operationType: 'unifiedAccount' | 'builderFee' | 'referral',
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): Promise<void> | undefined {
    const key = `${operationType}:${network}:${userAddress.toLowerCase()}`;
    return this.#inFlightOperations.get(key);
  }

  /**
   * Set an operation as in-flight
   * Returns a function to call when operation completes
   *
   * @param operationType - The type of operation being performed.
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @returns The resulting string value.
   */
  public setInFlight(
    operationType: 'unifiedAccount' | 'builderFee' | 'referral',
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): () => void {
    const key = `${operationType}:${network}:${userAddress.toLowerCase()}`;
    let resolvePromise: () => void;
    const promise = new Promise<void>((resolve) => {
      resolvePromise = resolve;
    });
    this.#inFlightOperations.set(key, promise);
    return () => {
      this.#inFlightOperations.delete(key);
      resolvePromise();
    };
  }

  #getCacheKey(network: 'mainnet' | 'testnet', userAddress: string): string {
    return `${network}:${userAddress.toLowerCase()}`;
  }

  #getOrCreateEntry(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): PerpsSigningCacheEntry {
    const key = this.#getCacheKey(network, userAddress);
    let entry = this.#cache.get(key);
    if (!entry) {
      entry = {
        unifiedAccount: { attempted: false, success: false },
        builderFee: { attempted: false, success: false },
        referral: { attempted: false, success: false },
        timestamp: Date.now(),
      };
      this.#cache.set(key, entry);
    }
    return entry;
  }

  // ===== Unified Account Methods =====

  /**
   * Get unified account cache entry (legacy compatibility)
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @returns The resulting string value.
   */
  public get(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): TradingReadinessCacheEntry | undefined {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    if (!entry) {
      return undefined;
    }
    return {
      attempted: entry.unifiedAccount.attempted,
      enabled: entry.unifiedAccount.success,
      timestamp: entry.timestamp,
    };
  }

  /**
   * Set unified account cache entry (legacy compatibility)
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @param data - The transaction data payload.
   * @param data.attempted - Whether the operation was attempted.
   * @param data.enabled - Whether the feature is enabled.
   */
  public set(
    network: 'mainnet' | 'testnet',
    userAddress: string,
    data: { attempted: boolean; enabled: boolean },
  ): void {
    const entry = this.#getOrCreateEntry(network, userAddress);
    entry.unifiedAccount = { attempted: data.attempted, success: data.enabled };
    entry.timestamp = Date.now();
  }

  // ===== Builder Fee Methods =====

  /**
   * Check if builder fee approval was attempted
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @returns The resulting string value.
   */
  public getBuilderFee(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): SigningOperationState | undefined {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    return entry?.builderFee;
  }

  /**
   * Set builder fee approval state
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @param state - The current state.
   */
  public setBuilderFee(
    network: 'mainnet' | 'testnet',
    userAddress: string,
    state: SigningOperationState,
  ): void {
    const entry = this.#getOrCreateEntry(network, userAddress);
    entry.builderFee = state;
    entry.timestamp = Date.now();
  }

  // ===== Referral Methods =====

  /**
   * Check if referral setup was attempted
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @returns The resulting string value.
   */
  public getReferral(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): SigningOperationState | undefined {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    return entry?.referral;
  }

  /**
   * Set referral setup state
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   * @param state - The current state.
   */
  public setReferral(
    network: 'mainnet' | 'testnet',
    userAddress: string,
    state: SigningOperationState,
  ): void {
    const entry = this.#getOrCreateEntry(network, userAddress);
    entry.referral = state;
    entry.timestamp = Date.now();
  }

  // ===== General Methods =====

  /**
   * Clear only unified account state for a specific network and user address
   * This preserves builder fee and referral states
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   */
  public clearUnifiedAccount(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): void {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    if (entry) {
      entry.unifiedAccount = { attempted: false, success: false };
      entry.timestamp = Date.now();
    }
  }

  /**
   * Clear only builder fee state for a specific network and user address
   * This preserves unified account and referral states
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   */
  public clearBuilderFee(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): void {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    if (entry) {
      entry.builderFee = { attempted: false, success: false };
      entry.timestamp = Date.now();
    }
  }

  /**
   * Clear only referral state for a specific network and user address
   * This preserves unified account and builder fee states
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   */
  public clearReferral(
    network: 'mainnet' | 'testnet',
    userAddress: string,
  ): void {
    const key = this.#getCacheKey(network, userAddress);
    const entry = this.#cache.get(key);
    if (entry) {
      entry.referral = { attempted: false, success: false };
      entry.timestamp = Date.now();
    }
  }

  /**
   * Clear entire cache entry for a specific network and user address
   * WARNING: This clears ALL signing operation states (unifiedAccount, builderFee, referral)
   *
   * @param network - The network environment.
   * @param userAddress - The user's wallet address.
   */
  public clear(network: 'mainnet' | 'testnet', userAddress: string): void {
    const key = this.#getCacheKey(network, userAddress);
    this.#cache.delete(key);
  }

  /**
   * Clear all cache entries
   * WARNING: This clears ALL signing operation states for ALL users
   */
  public clearAll(): void {
    this.#cache.clear();
  }

  /**
   * Get all cache entries (for debugging)
   *
   * @returns The result of the operation.
   */
  public getAll(): Map<string, PerpsSigningCacheEntry> {
    return new Map(this.#cache);
  }

  /**
   * Get cache size (for debugging)
   *
   * @returns The resulting numeric value.
   */
  public size(): number {
    return this.#cache.size;
  }

  /**
   * Get full cache state for debugging
   *
   * @returns The resulting string value.
   */
  public debugState(): string {
    const entries: string[] = [];
    this.#cache.forEach((entry, key) => {
      entries.push(
        `${key}: unified=${entry.unifiedAccount.attempted}/${entry.unifiedAccount.success}, ` +
          `builder=${entry.builderFee.attempted}/${entry.builderFee.success}, ` +
          `referral=${entry.referral.attempted}/${entry.referral.success}`,
      );
    });
    return entries.join('\n') || '(empty)';
  }
}

// Export singleton instance with backward-compatible name
export const TradingReadinessCache = PerpsSigningCacheManager.getInstance();

// Export with new name for clarity
export const PerpsSigningCache = PerpsSigningCacheManager.getInstance();