keynesol-shared 1.0.0

package/src/hooks/useTokenBalance.ts

@@ -0,0 +1,113 @@
+/**
+ * Token Balance Hook
+ * Fetches balance for both SOL and SPL tokens (USDC)
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { useConnection, useWallet } from '@solana/wallet-adapter-react';
+import { PublicKey, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { getAccount, getAssociatedTokenAddress, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { isNativeSOL, getTokenDecimals, fromLamports } from '../utils/tokenUtils';
+import { retryRpcCall } from '../utils/rpcRetry';
+
+export interface TokenBalance {
+  sol: number;
+  usdc: number;
+  loading: boolean;
+  error: string | null;
+}
+
+export const useTokenBalance = (tokenMint?: PublicKey | string) => {
+  const { connection } = useConnection();
+  const { publicKey } = useWallet();
+  const [solBalance, setSolBalance] = useState<number>(0);
+  const [usdcBalance, setUsdcBalance] = useState<number>(0);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchBalances = useCallback(async () => {
+    if (!connection || !publicKey) {
+      setSolBalance(0);
+      setUsdcBalance(0);
+      setLoading(false);
+      return;
+    }
+
+    try {
+      setLoading(true);
+      setError(null);
+
+      // Fetch SOL balance
+      const solBalanceLamports = await retryRpcCall(
+        () => connection.getBalance(publicKey)
+      );
+      setSolBalance(Number(solBalanceLamports) / LAMPORTS_PER_SOL);
+
+      // Fetch USDC balance if needed
+      try {
+        // USDC devnet mint
+        const usdcMint = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+        const usdcTokenAccount = await getAssociatedTokenAddress(
+          usdcMint,
+          publicKey,
+          false,
+          TOKEN_PROGRAM_ID,
+          ASSOCIATED_TOKEN_PROGRAM_ID
+        );
+
+        try {
+          const tokenAccount = await retryRpcCall(
+            () => getAccount(connection, usdcTokenAccount)
+          );
+          const amount = typeof tokenAccount.amount === 'bigint' 
+            ? Number(tokenAccount.amount) 
+            : tokenAccount.amount;
+          setUsdcBalance(fromLamports(amount, usdcMint));
+        } catch (err: any) {
+          // Token account doesn't exist, balance is 0
+          if (err.message?.includes('InvalidAccountData') || err.message?.includes('could not find account')) {
+            setUsdcBalance(0);
+          } else {
+            throw err;
+          }
+        }
+      } catch (err: any) {
+        console.warn('Error fetching USDC balance:', err);
+        setUsdcBalance(0);
+      }
+    } catch (err: any) {
+      console.error('Error fetching balances:', err);
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [connection, publicKey]);
+
+  useEffect(() => {
+    fetchBalances();
+    
+    // Poll for balance updates every 5 seconds
+    const interval = setInterval(fetchBalances, 5000);
+    return () => clearInterval(interval);
+  }, [fetchBalances]);
+
+  // Get balance for specific token mint
+  const getBalance = useCallback((mint?: PublicKey | string): number => {
+    if (!mint) return solBalance; // Default to SOL
+    
+    if (isNativeSOL(mint)) {
+      return solBalance;
+    }
+    
+    // Assume USDC for now (can be extended for other tokens)
+    return usdcBalance;
+  }, [solBalance, usdcBalance]);
+
+  return {
+    sol: solBalance,
+    usdc: usdcBalance,
+    getBalance,
+    loading,
+    error,
+    refresh: fetchBalances,
+  };
+};

package/src/hooks/useVaults.ts

@@ -0,0 +1,122 @@
+import { useState, useEffect, useCallback } from 'react';
+import { useConnection, useWallet } from '@solana/wallet-adapter-react';
+import { PublicKey } from '@solana/web3.js';
+import { useProgram } from './useProgram';
+import { usePolling } from './usePolling';
+import { retryRpcCall } from '../utils/rpcRetry';
+import * as anchor from '@coral-xyz/anchor';
+
+// Frontend Vault type (different from blockchain Vault type in types/index.ts)
+export interface Vault {
+  id: number;
+  aprRate: number;
+  totalStaked: number;
+  stakerCount: number;
+  isActive: boolean;
+  tokenMint: PublicKey | string; // Can be PublicKey or string for flexibility
+  // Admin-managed metadata
+  name?: string;
+  logo?: string;
+  lpOperation?: string;
+  lpOperationLogo?: string;
+  contentTitle?: string;
+  content?: string;
+  currentEpoch?: number;
+}
+
+export const useVaults = () => {
+  const { connection } = useConnection();
+  const { publicKey } = useWallet();
+  const { program } = useProgram();
+  const [vaults, setVaults] = useState<Vault[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const loadVaults = useCallback(async () => {
+    if (!program) {
+      setLoading(false);
+      return;
+    }
+
+    try {
+      setLoading(true);
+      setError(null);
+
+      // Load all vault accounts with retry
+      const vaultAccounts = await retryRpcCall(
+        () => (program.account as any).vault.all()
+      ) as any[];
+      
+      // Load vault metadata from localStorage
+      let vaultMetadata: Record<number, any> = {};
+      if (typeof window !== 'undefined') {
+        try {
+          vaultMetadata = JSON.parse(localStorage.getItem('vaultMetadata') || '{}');
+        } catch (e) {
+          console.warn('Failed to load vault metadata from localStorage:', e);
+        }
+      }
+      
+      const loadedVaults: Vault[] = vaultAccounts.map((account: any) => {
+        // Handle both camelCase and snake_case field names (depending on IDL generation)
+        const vault = account.account;
+        const tokenMint = vault.tokenMint || vault.token_mint;
+        const vaultId = (vault.id || vault.vaultId)?.toNumber?.() || 0;
+        const metadata = vaultMetadata[vaultId] || {};
+        
+        return {
+          id: vaultId,
+          aprRate: (vault.aprRate || vault.apr_rate)?.toNumber?.() || 0,
+          totalStaked: (vault.totalStaked || vault.total_staked)?.toNumber?.() || 0,
+          stakerCount: (vault.stakerCount || vault.staker_count)?.toNumber?.() || 0,
+          isActive: vault.isActive ?? vault.is_active ?? false,
+          tokenMint: tokenMint ? (typeof tokenMint === 'string' ? tokenMint : tokenMint.toString()) : '',
+          currentEpoch: (vault.currentEpoch || vault.current_epoch)?.toNumber?.() || 0,
+          // Load metadata from localStorage
+          name: metadata.name,
+          logo: metadata.logo,
+          lpOperation: metadata.lpOperation,
+          lpOperationLogo: metadata.lpOperationLogo,
+          contentTitle: metadata.contentTitle,
+          content: metadata.content,
+        };
+      });
+
+      setVaults(loadedVaults);
+    } catch (err: any) {
+      console.error('Error loading vaults:', err);
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [program]);
+
+  // Initial load
+  useEffect(() => {
+    loadVaults();
+  }, [loadVaults]);
+
+  // Real-time synchronization: Requirement 10.1 - 5-second blockchain sync
+  usePolling(
+    loadVaults,
+    {
+      interval: 5000, // 5 seconds as per Requirement 10.1
+      enabled: !!program, // Only poll when program is available
+      onError: (error) => {
+        console.error('Polling error in useVaults:', error);
+        setError(error.message);
+      },
+    }
+  );
+
+  const refreshVaults = useCallback(() => {
+    loadVaults();
+  }, [loadVaults]);
+
+  return {
+    vaults,
+    loading,
+    error,
+    refreshVaults,
+  };
+};

package/src/index.ts

@@ -0,0 +1,23 @@
+/**
+ * @keynesol/shared
+ * Shared code package for Keynesol Web3 Prediction Platform
+ */
+
+// Export all components
+export * from './components';
+
+// Export all hooks
+export * from './hooks';
+
+// Export all utils
+export * from './utils';
+export * from './utils/supabase';
+
+// Export all services
+export * from './services';
+
+// Export all types
+export * from './types';
+
+// Export IDL path (for reference)
+export const IDL_PATH = '/web3_prediction_platform.json';

package/src/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Services Index
+ * Export all shared services
+ */
+export * from './syncService';
+export * from './reconciliationService';

package/src/services/reconciliationService.ts

@@ -0,0 +1,246 @@
+/**
+ * Data Reconciliation Service
+ * Ensures consistency between Supabase and blockchain
+ * Requirements: 10.5
+ */
+import { Connection } from '@solana/web3.js';
+import { getSupabaseClient, isSupabaseConfigured, SupabaseConfig } from '../utils/supabase';
+import { errorHandler } from '../utils/errorHandler';
+import { cacheManager } from '../utils/cacheManager';
+
+interface ReconciliationResult {
+  transactions: {
+    missing: number;
+    inconsistent: number;
+    fixed: number;
+  };
+  rewards: {
+    missing: number;
+    inconsistent: number;
+    fixed: number;
+  };
+  vaults: {
+    missing: number;
+    inconsistent: number;
+    fixed: number;
+  };
+}
+
+class ReconciliationService {
+  private connection: Connection | null = null;
+  private reconciliationInterval: NodeJS.Timeout | null = null;
+  private supabaseConfig?: SupabaseConfig;
+
+  /**
+   * Initialize reconciliation service
+   */
+  initialize(connection: Connection, supabaseConfig?: SupabaseConfig): void {
+    this.connection = connection;
+    this.supabaseConfig = supabaseConfig;
+  }
+
+  /**
+   * Start periodic reconciliation
+   */
+  startReconciliation(interval: number = 3600000): void {
+    if (this.reconciliationInterval) {
+      return; // Already running
+    }
+
+    // Initial reconciliation
+    this.reconcileAll();
+
+    // Periodic reconciliation (default: 1 hour)
+    this.reconciliationInterval = setInterval(() => {
+      this.reconcileAll();
+    }, interval);
+  }
+
+  /**
+   * Stop reconciliation
+   */
+  stopReconciliation(): void {
+    if (this.reconciliationInterval) {
+      clearInterval(this.reconciliationInterval);
+      this.reconciliationInterval = null;
+    }
+  }
+
+  /**
+   * Reconcile all data types
+   */
+  async reconcileAll(): Promise<ReconciliationResult> {
+    if (!isSupabaseConfigured(this.supabaseConfig) || !this.connection) {
+      return {
+        transactions: { missing: 0, inconsistent: 0, fixed: 0 },
+        rewards: { missing: 0, inconsistent: 0, fixed: 0 },
+        vaults: { missing: 0, inconsistent: 0, fixed: 0 },
+      };
+    }
+
+    try {
+      const [transactions, rewards, vaults] = await Promise.all([
+        this.reconcileTransactions(),
+        this.reconcileRewards(),
+        this.reconcileVaults(),
+      ]);
+
+      return {
+        transactions,
+        rewards,
+        vaults,
+      };
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'ReconciliationService');
+      throw error;
+    }
+  }
+
+  /**
+   * Reconcile transactions
+   */
+  async reconcileTransactions(): Promise<{ missing: number; inconsistent: number; fixed: number }> {
+    if (!isSupabaseConfigured(this.supabaseConfig) || !this.connection) {
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.supabaseConfig);
+      
+      // Get recent transactions from Supabase
+      const { data: supabaseTxs } = await supabase
+        .from('transactions')
+        .select('signature, status, amount, vault_id')
+        .order('timestamp', { ascending: false })
+        .limit(100);
+
+      if (!supabaseTxs) {
+        return { missing: 0, inconsistent: 0, fixed: 0 };
+      }
+
+      let missing = 0;
+      let inconsistent = 0;
+      let fixed = 0;
+
+      // Verify each transaction on blockchain
+      const transactions = supabaseTxs as any[];
+      for (const tx of transactions) {
+        try {
+          const blockchainTx = await this.connection!.getTransaction(tx.signature, {
+            maxSupportedTransactionVersion: 0,
+          });
+
+          if (!blockchainTx) {
+            // Transaction not found on blockchain - mark as failed
+            if (tx.status !== 'failed') {
+              const updateData: Record<string, string> = { status: 'failed' };
+              await (supabase
+                .from('transactions') as any)
+                .update(updateData)
+                .eq('signature', tx.signature);
+              fixed++;
+            }
+            missing++;
+          } else {
+            // Transaction found - verify status
+            const isConfirmed = blockchainTx.meta?.err === null;
+            const expectedStatus = isConfirmed ? 'confirmed' : 'failed';
+            
+            if (tx.status !== expectedStatus) {
+              const updateData = { status: expectedStatus };
+              await (supabase
+                .from('transactions') as any)
+                .update(updateData as any)
+                .eq('signature', tx.signature);
+              fixed++;
+              inconsistent++;
+            }
+          }
+        } catch (error) {
+          console.error(`Error reconciling transaction ${tx.signature}:`, error);
+        }
+      }
+
+      // Invalidate cache
+      cacheManager.invalidate('transactions');
+
+      return { missing, inconsistent, fixed };
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'ReconciliationService.reconcileTransactions');
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+  }
+
+  /**
+   * Reconcile rewards
+   */
+  async reconcileRewards(): Promise<{ missing: number; inconsistent: number; fixed: number }> {
+    if (!isSupabaseConfigured(this.supabaseConfig) || !this.connection) {
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+
+    try {
+      const supabase = getSupabaseClient(this.supabaseConfig);
+      
+      // Get unclaimed rewards from Supabase
+      const { data: unclaimedRewards } = await supabase
+        .from('rewards')
+        .select('*')
+        .eq('claimed', false)
+        .limit(100);
+
+      if (!unclaimedRewards) {
+        return { missing: 0, inconsistent: 0, fixed: 0 };
+      }
+
+      let missing = 0;
+      let inconsistent = 0;
+      let fixed = 0;
+
+      // Verify rewards on blockchain
+      // This would require checking reward distribution transactions
+      // For now, this is a placeholder
+
+      cacheManager.invalidate('rewards');
+
+      return { missing, inconsistent, fixed };
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'ReconciliationService.reconcileRewards');
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+  }
+
+  /**
+   * Reconcile vaults
+   */
+  async reconcileVaults(): Promise<{ missing: number; inconsistent: number; fixed: number }> {
+    if (!isSupabaseConfigured(this.supabaseConfig) || !this.connection) {
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+
+    try {
+      // Reconcile vault history with current vault state
+      // This would involve:
+      // 1. Fetching current vault state from blockchain
+      // 2. Comparing with latest vault_history entry
+      // 3. Creating new history entry if state changed
+
+      cacheManager.invalidate('vaultHistory');
+
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    } catch (error) {
+      errorHandler.handleError(error as Error, 'ReconciliationService.reconcileVaults');
+      return { missing: 0, inconsistent: 0, fixed: 0 };
+    }
+  }
+
+  /**
+   * Manual reconciliation trigger
+   */
+  async manualReconcile(): Promise<ReconciliationResult> {
+    return this.reconcileAll();
+  }
+}
+
+// Export singleton instance
+export const reconciliationService = new ReconciliationService();