Fix/analytics service any types

frontend/src/hooks/useAnalyticsTracking.ts

@@ -100,33 +100,29 @@ export function useAnalyticsTracking() {
     [analyticsService]
   );
 
-  // Track feature usage
   const trackFeatureUsage = useCallback(
-    (featureName: string, properties?: Record<string, any>) => {
+    (featureName: string, properties?: Record<string, EventPropertyValue>) => {
       analyticsService.trackFeatureUsage(featureName, properties);
     },
     [analyticsService]
   );
 
-  // Track error
   const trackError = useCallback(
-    (errorName: string, errorMessage: string, context?: Record<string, any>) => {
+    (errorName: string, errorMessage: string, context?: Record<string, EventPropertyValue>) => {
       analyticsService.trackError(errorName, errorMessage, context);
     },
     [analyticsService]
   );
 
-  // Track custom event
   const trackEvent = useCallback(
-    (eventName: string, properties?: Record<string, any>) => {
+    (eventName: string, properties?: Record<string, EventPropertyValue>) => {
       analyticsService.trackEvent(eventName, properties);
     },
     [analyticsService]
   );
 
-  // Update user properties
   const updateUserProperties = useCallback(
-    (properties: Record<string, any>) => {
+    (properties: Record<string, EventPropertyValue>) => {
       analyticsService.updateUserProperties(properties);
     },
     [analyticsService]

frontend/src/hooks/useChartRendering.ts

@@ -1,6 +1,8 @@
 import { useEffect, useRef } from 'react';
 import { Candlestick, ChartScale } from '@/types/charting';
 import { CandlestickRenderer } from '@/services/CandlestickRenderer';
+import type { ChartDataManager } from '@/services/ChartDataManager';
+import type { DrawingToolManager } from '@/services/DrawingToolManager';
 
 interface UseChartRenderingProps {
   canvasRef: React.RefObject<HTMLCanvasElement>;
@@ -11,8 +13,8 @@ interface UseChartRenderingProps {
   candles: Candlestick[];
   scale: ChartScale | null;
   hoveredCandle: Candlestick | null;
-  dataManager: any;
-  drawingManager: any;
+  dataManager: ChartDataManager;
+  drawingManager: DrawingToolManager;
   onScaleChange: (scale: ChartScale) => void;
 }
 

frontend/src/hooks/useLogger.ts

@@ -1,13 +1,14 @@
 import { useCallback, useMemo } from 'react';
 import { logger, type LogEntry, type LogLevel } from '@/utils/logger';
 import { monitoringService } from '@/services/MonitoringService';
+import type { LogData } from '@/types/common';
 
 interface UseLoggerReturn {
-  debug: (message: string, context?: Record<string, unknown>) => void;
-  info: (message: string, context?: Record<string, unknown>) => void;
-  warn: (message: string, context?: Record<string, unknown>) => void;
-  error: (message: string, context?: Record<string, unknown>) => void;
-  fatal: (message: string, context?: Record<string, unknown>) => void;
+  debug: (message: string, context?: LogData) => void;
+  info: (message: string, context?: LogData) => void;
+  warn: (message: string, context?: LogData) => void;
+  error: (message: string, context?: LogData) => void;
+  fatal: (message: string, context?: LogData) => void;
   setRequestId: (id: string) => void;
   setUserId: (id: string) => void;
   setTransactionId: (id: string) => void;
@@ -23,24 +24,24 @@ interface UseLoggerReturn {
     name: string,
     value: number,
     unit?: 'ms' | 'bytes' | 'count',
-    context?: Record<string, unknown>
+    context?: LogData
   ) => void;
-  trackError: (type: string, message: string, context?: Record<string, unknown>) => void;
-  trackUserAction: (action: string, context?: Record<string, unknown>) => void;
+  trackError: (type: string, message: string, context?: LogData) => void;
+  trackUserAction: (action: string, context?: LogData) => void;
   trackContractCall: (
     contract: string,
     functionName: string,
     duration: number,
     success: boolean,
-    context?: Record<string, unknown>
+    context?: LogData
   ) => void;
-  trackPageView: (page: string, context?: Record<string, unknown>) => void;
-  trackButtonClick: (button: string, context?: Record<string, unknown>) => void;
+  trackPageView: (page: string, context?: LogData) => void;
+  trackButtonClick: (button: string, context?: LogData) => void;
   trackTransaction: (
     type: string,
     status: string,
     duration: number,
-    context?: Record<string, unknown>
+    context?: LogData
   ) => void;
 }
 
@@ -50,35 +51,35 @@ export function useLogger(component?: string): UseLoggerReturn {
   }, [component]);
 
   const debug = useCallback(
-    (message: string, ctx?: Record<string, unknown>) => {
+    (message: string, ctx?: LogData) => {
       logger.debug(message, { ...context, ...ctx });
     },
     [context]
   );
 
   const info = useCallback(
-    (message: string, ctx?: Record<string, unknown>) => {
+    (message: string, ctx?: LogData) => {
       logger.info(message, { ...context, ...ctx });
     },
     [context]
   );
 
   const warn = useCallback(
-    (message: string, ctx?: Record<string, unknown>) => {
+    (message: string, ctx?: LogData) => {
       logger.warn(message, { ...context, ...ctx });
     },
     [context]
   );
 
   const error = useCallback(
-    (message: string, ctx?: Record<string, unknown>) => {
+    (message: string, ctx?: LogData) => {
       logger.error(message, { ...context, ...ctx });
     },
     [context]
   );
 
   const fatal = useCallback(
-    (message: string, ctx?: Record<string, unknown>) => {
+    (message: string, ctx?: LogData) => {
       logger.fatal(message, { ...context, ...ctx });
     },
     [context]
@@ -151,22 +152,22 @@ export function useLogger(component?: string): UseLoggerReturn {
       name: string,
       value: number,
       unit: 'ms' | 'bytes' | 'count' = 'ms',
-      ctx?: Record<string, unknown>
+      ctx?: LogData
     ) => {
       monitoringService.trackPerformance(name, value, unit, { ...context, ...ctx });
     },
     [context]
   );
 
   const trackError = useCallback(
-    (type: string, message: string, ctx?: Record<string, unknown>) => {
+    (type: string, message: string, ctx?: LogData) => {
       monitoringService.trackError(type, message, { ...context, ...ctx });
     },
     [context]
   );
 
   const trackUserAction = useCallback(
-    (action: string, ctx?: Record<string, unknown>) => {
+    (action: string, ctx?: LogData) => {
       monitoringService.trackUserAction(action, { ...context, ...ctx });
     },
     [context]
@@ -178,7 +179,7 @@ export function useLogger(component?: string): UseLoggerReturn {
       functionName: string,
       duration: number,
       success: boolean,
-      ctx?: Record<string, unknown>
+      ctx?: LogData
     ) => {
       monitoringService.trackContractCall(
         contract,
@@ -192,21 +193,21 @@ export function useLogger(component?: string): UseLoggerReturn {
   );
 
   const trackPageView = useCallback(
-    (page: string, ctx?: Record<string, unknown>) => {
+    (page: string, ctx?: LogData) => {
       monitoringService.trackPageView(page, { ...context, ...ctx });
     },
     [context]
   );
 
   const trackButtonClick = useCallback(
-    (button: string, ctx?: Record<string, unknown>) => {
+    (button: string, ctx?: LogData) => {
       monitoringService.trackButtonClick(button, { ...context, ...ctx });
     },
     [context]
   );
 
   const trackTransaction = useCallback(
-    (type: string, status: string, duration: number, ctx?: Record<string, unknown>) => {
+    (type: string, status: string, duration: number, ctx?: LogData) => {
       monitoringService.trackTransaction(type, status, duration, { ...context, ...ctx });
     },
     [context]

frontend/src/hooks/useSecureStorage.ts

@@ -2,6 +2,7 @@ import { useState, useEffect, useCallback } from 'react';
 import { SecureStorageV2Service } from '@/services/SecureStorageV2Service';
 import { StorageMigrationService } from '@/services/StorageMigrationService';
 import { EncryptionService } from '@/services/EncryptionService';
+import type { JsonValue } from '@/types/common';
 
 export interface SecureStorageStatus {
   initialized: boolean;
@@ -68,7 +69,7 @@ export function useSecureStorage() {
   }, []);
 
   const setItem = useCallback(
-    async (key: string, value: any, options?: Parameters<typeof SecureStorageV2Service.setItem>[2]) => {
+    async (key: string, value: JsonValue, options?: Parameters<typeof SecureStorageV2Service.setItem>[2]) => {
       return SecureStorageV2Service.setItem(key, value, options);
     },
     []