keynesol-shared 1.0.0

package/src/services/syncService.ts

@@ -0,0 +1,238 @@
+/**
+ * Data Synchronization Service
+ * Synchronizes blockchain events to Supabase
+ * Requirements: 10.1, 10.2, 10.3, 10.4, 10.5
+ */
+import { Connection, PublicKey } from '@solana/web3.js';
+import { getSupabaseClient, isSupabaseConfigured, SupabaseConfig } from '../utils/supabase';
+import { errorHandler } from '../utils/errorHandler';
+import { cacheManager } from '../utils/cacheManager';
+
+interface SyncConfig {
+  enabled: boolean;
+  interval: number; // milliseconds
+  batchSize: number;
+  supabaseConfig?: SupabaseConfig;
+}
+
+class SyncService {
+  private connection: Connection | null = null;
+  private syncInterval: NodeJS.Timeout | null = null;
+  private config: SyncConfig = {
+    enabled: false,
+    interval: 60000, // 1 minute
+    batchSize: 100,
+  };
+
+  /**
+   * Initialize sync service
+   */
+  initialize(connection: Connection, supabaseConfig?: SupabaseConfig): void {
+    this.connection = connection;
+    this.config.supabaseConfig = supabaseConfig;
+    this.config.enabled = isSupabaseConfigured(supabaseConfig);
+    
+    if (this.config.enabled) {
+      this.startSync();
+    }
+  }
+
+  /**
+   * Start periodic synchronization
+   */
+  startSync(): void {
+    if (this.syncInterval) {
+      return; // Already running
+    }
+
+    // Initial sync
+    this.syncAll();
+
+    // Periodic sync
+    this.syncInterval = setInterval(() => {
+      this.syncAll();
+    }, this.config.interval);
+  }
+
+  /**
+   * Stop synchronization
+   */
+  stopSync(): void {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+    }
+  }
+
+  /**
+   * Sync all data types
+   */
+  async syncAll(): Promise<void> {
+    if (!this.config.enabled || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      await Promise.all([
+        this.syncTransactions(),
+        this.syncRewards(),
+        this.syncPlatformMetrics(),
+        this.syncVaultHistory(),
+      ]);
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService');
+    }
+  }
+
+  /**
+   * Sync transactions from blockchain to Supabase
+   */
+  async syncTransactions(): Promise<void> {
+    if (!this.connection || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.config.supabaseConfig);
+      
+      // Get latest transaction signature from Supabase
+      const { data: latestTx } = await supabase
+        .from('transactions')
+        .select('signature, timestamp')
+        .order('timestamp', { ascending: false })
+        .limit(1)
+        .single();
+
+      // In a real implementation, you would:
+      // 1. Query blockchain for new transactions since latestTx.timestamp
+      // 2. Parse transaction data
+      // 3. Insert into Supabase
+      
+      // For now, this is a placeholder
+      console.log('Syncing transactions...');
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService.syncTransactions');
+    }
+  }
+
+  /**
+   * Sync rewards from blockchain to Supabase
+   */
+  async syncRewards(): Promise<void> {
+    if (!this.connection || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.config.supabaseConfig);
+      
+      // Get latest reward timestamp from Supabase
+      const { data: latestReward } = await supabase
+        .from('rewards')
+        .select('timestamp')
+        .order('timestamp', { ascending: false })
+        .limit(1)
+        .single();
+
+      // In a real implementation, you would:
+      // 1. Query blockchain for new rewards since latestReward.timestamp
+      // 2. Parse reward data
+      // 3. Insert into Supabase
+      
+      console.log('Syncing rewards...');
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService.syncRewards');
+    }
+  }
+
+  /**
+   * Sync platform metrics
+   */
+  async syncPlatformMetrics(): Promise<void> {
+    if (!this.connection || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.config.supabaseConfig);
+      
+      // Calculate current platform metrics
+      // This would typically involve:
+      // 1. Fetching all vaults
+      // 2. Calculating TVL, user count, etc.
+      // 3. Inserting into platform_metrics table
+      
+      const metrics = {
+        timestamp: new Date().toISOString(),
+        total_value_locked: 0,
+        total_users: 0,
+        active_vaults: 0,
+        average_apr: 0,
+        current_epoch: 0,
+        volume_24h: 0,
+      };
+
+      await (supabase.from('platform_metrics') as any).insert(metrics);
+      
+      // Invalidate cache
+      cacheManager.invalidate('platformMetrics');
+      
+      console.log('Syncing platform metrics...');
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService.syncPlatformMetrics');
+    }
+  }
+
+  /**
+   * Sync vault history
+   */
+  async syncVaultHistory(): Promise<void> {
+    if (!this.connection || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.config.supabaseConfig);
+      
+      // In a real implementation, you would:
+      // 1. Fetch all vaults from blockchain
+      // 2. For each vault, create history entry
+      // 3. Insert into vault_history table
+      
+      console.log('Syncing vault history...');
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService.syncVaultHistory');
+    }
+  }
+
+  /**
+   * Manually trigger sync for a specific transaction
+   */
+  async syncTransaction(signature: string): Promise<void> {
+    if (!this.connection || !isSupabaseConfigured(this.config.supabaseConfig)) {
+      return;
+    }
+
+    try {
+      // Fetch transaction from blockchain
+      const tx = await this.connection!.getTransaction(signature, {
+        maxSupportedTransactionVersion: 0,
+      });
+
+      if (!tx) {
+        throw new Error('Transaction not found');
+      }
+
+      // Parse and insert into Supabase
+      // This would require parsing the transaction logs
+      // to extract stake/unstake/reward information
+      
+      console.log('Syncing transaction:', signature);
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'SyncService.syncTransaction');
+    }
+  }
+}
+
+// Export singleton instance
+export const syncService = new SyncService();

package/src/types/index.ts

@@ -0,0 +1,233 @@
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+
+// Core platform types
+export interface PredictionPlatform {
+  admin: PublicKey;
+  totalVaults: BN;
+  currentEpoch: BN;
+  platformFee: number;
+  earlyUnstakeFee: number;
+  isPaused: boolean;
+}
+
+// Blockchain Vault type (from Anchor program)
+export interface BlockchainVault {
+  id: BN;
+  aprRate: BN;
+  totalStaked: BN;
+  stakerCount: BN;
+  currentEpoch: BN;
+  isActive: boolean;
+  tokenMint: PublicKey;
+  currentRewardPool: BN;
+  totalRewardsDistributed: BN;
+  createdAt: BN;
+  lastUpdated: BN;
+}
+
+export interface UserStake {
+  user: PublicKey;
+  vaultId: BN;
+  amount: BN;
+  epochJoined: BN;
+  lastRewardEpoch: BN;
+  pendingRewards: BN;
+  stakedAt: BN;
+  cooldownEnd?: BN;
+}
+
+export interface Epoch {
+  id: BN;
+  vaultId: BN;
+  startTime: BN;
+  endTime?: BN;
+  totalRewards: BN;
+  participants: BN;
+  isActive: boolean;
+  rewardRate: BN;
+}
+
+// Frontend state types
+export interface WalletState {
+  connected: boolean;
+  publicKey: PublicKey | null;
+  balance: number;
+  connecting: boolean;
+  disconnecting: boolean;
+}
+
+export interface VaultDisplayData {
+  id: number;
+  aprRate: number;
+  totalStaked: number;
+  stakerCount: number;
+  userStake: number;
+  currentRewardPool: number;
+  isActive: boolean;
+  loading: boolean;
+  historicalAPR: APRHistoryPoint[];
+}
+
+export interface APRHistoryPoint {
+  date: string;
+  apr: number;
+  totalStaked: number;
+  participants: number;
+}
+
+export interface UserPortfolio {
+  totalStaked: number;
+  totalRewards: number;
+  activeVaults: number;
+  portfolioValue: number;
+  performanceMetrics: PerformanceData;
+}
+
+export interface PerformanceData {
+  totalReturn: number;
+  annualizedReturn: number;
+  sharpeRatio: number;
+  maxDrawdown: number;
+  winRate: number;
+}
+
+export interface TransactionHistory {
+  id: string;
+  type: 'stake' | 'unstake' | 'claim' | 'reward';
+  amount: number;
+  vaultId: number;
+  timestamp: Date;
+  signature: string;
+  status: 'pending' | 'confirmed' | 'failed';
+}
+
+export interface PlatformStats {
+  totalValueLocked: number;
+  totalUsers: number;
+  totalVaults: number;
+  averageAPR: number;
+  currentEpoch: number;
+  totalRewardsDistributed: number;
+}
+
+// UI component types
+export interface StakeModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  vault: VaultDisplayData;
+  onStake: (amount: number) => Promise<void>;
+}
+
+export interface UnstakeModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  vault: VaultDisplayData;
+  userStake: number;
+  onUnstake: (amount: number, immediate: boolean) => Promise<void>;
+}
+
+export interface VaultCardProps {
+  vault: VaultDisplayData;
+  onStake: () => void;
+  onUnstake: () => void;
+  onViewDetails: () => void;
+}
+
+// Error types
+export interface PlatformError {
+  code: string;
+  message: string;
+  details?: any;
+}
+
+// Theme types
+export interface Theme {
+  colors: {
+    primary: string;
+    secondary: string;
+    background: string;
+    surface: string;
+    border: string;
+    text: string;
+    textSecondary: string;
+    success: string;
+    warning: string;
+    error: string;
+    accent: string;
+  };
+  spacing: {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    xxl: string;
+  };
+  borderRadius: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+  shadows: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+  };
+  breakpoints?: {
+    mobile: string;
+    tablet: string;
+    desktop: string;
+    wide: string;
+    ultrawide: string;
+  };
+}
+
+// API response types
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: PlatformError;
+  timestamp: string;
+}
+
+// Sustainability types
+export interface SustainabilityMetrics {
+  energyConsumption: number;
+  carbonFootprint: number;
+  resourceEfficiency: number;
+  renewablePercentage: number;
+  sustainabilityScore: number;
+}
+
+// Property test types for correctness validation
+export interface PropertyTestConfig {
+  iterations: number;
+  seed?: number;
+  timeout?: number;
+  verbose?: boolean;
+}
+
+export interface PropertyTestResult {
+  property: string;
+  passed: boolean;
+  iterations: number;
+  counterexample?: any;
+  error?: string;
+}
+
+// Real-time sync types
+export interface SyncState {
+  lastSync: Date;
+  syncing: boolean;
+  syncError?: string;
+  pendingUpdates: number;
+}
+
+// Export utility types
+export type VaultId = number;
+export type EpochId = number;
+export type UserId = string;
+export type TransactionSignature = string;