diff --git a/package.json b/package.json
new file mode 100644
index 0000000..27ccc5b
--- /dev/null
+++ b/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "arber2",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}
diff --git a/src/api/kalshi.ts b/src/api/kalshi.ts
new file mode 100644
index 0000000..346fb2a
--- /dev/null
+++ b/src/api/kalshi.ts
@@ -0,0 +1,239 @@
+// Kalshi API integration layer
+import { 
+  KalshiMarket, 
+  KalshiOrderbook, 
+  CommonMarket, 
+  MarketCondition, 
+  ApiResponse,
+  EnvironmentConfig 
+} from './types';
+
+// Environment configuration with defaults
+const config: EnvironmentConfig = {
+  KALSHI_API_KEY: process.env.KALSHI_API_KEY,
+  KALSHI_BASE_URL: process.env.KALSHI_BASE_URL || 'https://trading-api.kalshi.com',
+  POLYMARKET_GAMMA_URL: process.env.POLYMARKET_GAMMA_URL || 'https://gamma-api.polymarket.com',
+  POLYMARKET_CLOB_URL: process.env.POLYMARKET_CLOB_URL || 'https://clob.polymarket.com',
+  POLYMARKET_PRICE_URL: process.env.POLYMARKET_PRICE_URL || 'https://strapi-matic.poly.market',
+};
+
+/**
+ * Fetch open/active markets from Kalshi
+ */
+export async function fetchKalshiMarkets(): Promise<ApiResponse<KalshiMarket[]>> {
+  try {
+    const url = `${config.KALSHI_BASE_URL}/v1/markets?status=open&limit=100`;
+    const headers: HeadersInit = {
+      'Accept': 'application/json',
+    };
+
+    // Add API key if available
+    if (config.KALSHI_API_KEY) {
+      headers['Authorization'] = `Bearer ${config.KALSHI_API_KEY}`;
+    }
+
+    const response = await fetch(url, { headers });
+    
+    if (!response.ok) {
+      throw new Error(`Kalshi API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    const markets = data.markets || data.data || [];
+
+    return {
+      success: true,
+      data: markets,
+      timestamp: new Date(),
+    };
+  } catch (error) {
+    console.error('Error fetching Kalshi markets:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Fetch orderbook for a specific Kalshi market
+ */
+export async function fetchKalshiOrderbook(ticker: string): Promise<ApiResponse<KalshiOrderbook>> {
+  try {
+    const url = `${config.KALSHI_BASE_URL}/v1/markets/${ticker}/orderbook`;
+    const headers: HeadersInit = {
+      'Accept': 'application/json',
+    };
+
+    if (config.KALSHI_API_KEY) {
+      headers['Authorization'] = `Bearer ${config.KALSHI_API_KEY}`;
+    }
+
+    const response = await fetch(url, { headers });
+    
+    if (!response.ok) {
+      throw new Error(`Kalshi orderbook API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    
+    return {
+      success: true,
+      data: data.orderbook || data,
+      timestamp: new Date(),
+    };
+  } catch (error) {
+    console.error(`Error fetching Kalshi orderbook for ${ticker}:`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Convert Kalshi market to CommonMarket format
+ */
+export function normalizeKalshiMarket(market: KalshiMarket, orderbook?: KalshiOrderbook): CommonMarket {
+  // Extract pricing from orderbook if available, otherwise use market data
+  let yesBid = market.yes_bid;
+  let yesAsk = market.yes_ask;
+  let noBid = market.no_bid;
+  let noAsk = market.no_ask;
+
+  if (orderbook) {
+    if (orderbook.yes && orderbook.yes.length > 0) {
+      yesBid = orderbook.yes[0].price; // Best bid
+      yesAsk = orderbook.yes.find(order => order.size > 0)?.price;
+    }
+    if (orderbook.no && orderbook.no.length > 0) {
+      noBid = orderbook.no[0].price; // Best bid
+      noAsk = orderbook.no.find(order => order.size > 0)?.price;
+    }
+  }
+
+  // For Kalshi, calculate No prices as 1 - opposite side when needed
+  if (yesBid && !noBid) {
+    noBid = 1 - yesBid;
+  }
+  if (yesAsk && !noAsk) {
+    noAsk = 1 - yesAsk;
+  }
+  if (noBid && !yesBid) {
+    yesBid = 1 - noBid;
+  }
+  if (noAsk && !yesAsk) {
+    yesAsk = 1 - noAsk;
+  }
+
+  // Create outcomes for binary markets
+  const outcomes: MarketCondition[] = [];
+
+  if (yesBid !== undefined && yesAsk !== undefined) {
+    outcomes.push({
+      id: `${market.ticker}-yes`,
+      name: 'Yes',
+      yesPrice: yesAsk, // Ask price to buy YES
+      noPrice: noBid || (1 - yesAsk), // Bid price to buy NO (or calculated)
+      volume: market.volume,
+    });
+  }
+
+  if (noBid !== undefined && noAsk !== undefined) {
+    outcomes.push({
+      id: `${market.ticker}-no`,
+      name: 'No',
+      yesPrice: noAsk, // Ask price to buy NO
+      noPrice: yesBid || (1 - noAsk), // Bid price to buy YES (or calculated)
+      volume: market.volume,
+    });
+  }
+
+  return {
+    id: market.ticker,
+    platform: 'kalshi',
+    title: market.title,
+    subtitle: market.subtitle,
+    category: market.category || 'Unknown',
+    closeTime: new Date(market.close_time),
+    volume: market.dollar_volume || market.volume,
+    liquidity: market.open_interest,
+    yesBid,
+    yesAsk,
+    noBid,
+    noAsk,
+    outcomes,
+  };
+}
+
+/**
+ * Fetch and normalize all Kalshi markets
+ */
+export async function fetchNormalizedKalshiMarkets(): Promise<ApiResponse<CommonMarket[]>> {
+  const marketsResponse = await fetchKalshiMarkets();
+  
+  if (!marketsResponse.success || !marketsResponse.data) {
+    return marketsResponse as ApiResponse<CommonMarket[]>;
+  }
+
+  try {
+    // Normalize markets, optionally with orderbook data
+    const normalizedMarkets: CommonMarket[] = marketsResponse.data.map(market => {
+      return normalizeKalshiMarket(market);
+    });
+
+    return {
+      success: true,
+      data: normalizedMarkets,
+      timestamp: new Date(),
+    };
+  } catch (error) {
+    console.error('Error normalizing Kalshi markets:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Error normalizing markets',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Fetch orderbooks for multiple markets (for live pricing updates)
+ */
+export async function fetchKalshiOrderbooks(tickers: string[]): Promise<Map<string, KalshiOrderbook>> {
+  const orderbooks = new Map<string, KalshiOrderbook>();
+  
+  // Fetch orderbooks in parallel with reasonable rate limiting
+  const promises = tickers.map(async (ticker, index) => {
+    // Add small delay to avoid rate limiting
+    await new Promise(resolve => setTimeout(resolve, index * 100));
+    
+    const response = await fetchKalshiOrderbook(ticker);
+    if (response.success && response.data) {
+      orderbooks.set(ticker, response.data);
+    }
+  });
+
+  await Promise.allSettled(promises);
+  return orderbooks;
+}
+
+/**
+ * Check if Kalshi API is accessible (health check)
+ */
+export async function checkKalshiConnection(): Promise<boolean> {
+  try {
+    const response = await fetch(`${config.KALSHI_BASE_URL}/v1/status`, {
+      method: 'GET',
+      headers: { 'Accept': 'application/json' },
+      signal: AbortSignal.timeout(5000), // 5 second timeout
+    });
+    
+    return response.ok;
+  } catch (error) {
+    console.warn('Kalshi API connection check failed:', error);
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/src/api/polymarket.ts b/src/api/polymarket.ts
new file mode 100644
index 0000000..8c11d76
--- /dev/null
+++ b/src/api/polymarket.ts
@@ -0,0 +1,331 @@
+// Polymarket API integration layer
+import {
+  PolymarketMarket,
+  PolymarketOrderbook,
+  CommonMarket,
+  MarketCondition,
+  ApiResponse,
+  EnvironmentConfig
+} from './types';
+
+// Environment configuration (imported from kalshi.ts pattern)
+const config: EnvironmentConfig = {
+  KALSHI_API_KEY: process.env.KALSHI_API_KEY,
+  KALSHI_BASE_URL: process.env.KALSHI_BASE_URL || 'https://trading-api.kalshi.com',
+  POLYMARKET_GAMMA_URL: process.env.POLYMARKET_GAMMA_URL || 'https://gamma-api.polymarket.com',
+  POLYMARKET_CLOB_URL: process.env.POLYMARKET_CLOB_URL || 'https://clob.polymarket.com',
+  POLYMARKET_PRICE_URL: process.env.POLYMARKET_PRICE_URL || 'https://strapi-matic.poly.market',
+};
+
+/**
+ * Fetch active markets from Polymarket Gamma API
+ */
+export async function fetchPolymarketMarkets(): Promise<ApiResponse<PolymarketMarket[]>> {
+  try {
+    // Fetch from Gamma API - get active markets
+    const url = `${config.POLYMARKET_GAMMA_URL}/markets?active=true&limit=100`;
+    
+    const response = await fetch(url, {
+      headers: {
+        'Accept': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Polymarket Gamma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    const markets = data.data || data.markets || data;
+
+    return {
+      success: true,
+      data: Array.isArray(markets) ? markets : [],
+      timestamp: new Date(),
+    };
+  } catch (error) {
+    console.error('Error fetching Polymarket markets:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Fetch orderbook/price data for specific Polymarket token
+ */
+export async function fetchPolymarketOrderbook(tokenId: string): Promise<ApiResponse<PolymarketOrderbook>> {
+  try {
+    // Try CLOB API first
+    const clobUrl = `${config.POLYMARKET_CLOB_URL}/book?token_id=${tokenId}`;
+    
+    const response = await fetch(clobUrl, {
+      headers: {
+        'Accept': 'application/json',
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        success: true,
+        data: {
+          market: tokenId,
+          asset_id: tokenId,
+          bids: data.bids || [],
+          asks: data.asks || [],
+        },
+        timestamp: new Date(),
+      };
+    }
+
+    // Fallback to price API if CLOB fails
+    const priceUrl = `${config.POLYMARKET_PRICE_URL}/markets/${tokenId}/price`;
+    const priceResponse = await fetch(priceUrl);
+    
+    if (priceResponse.ok) {
+      const priceData = await priceResponse.json();
+      // Convert price data to orderbook format
+      return {
+        success: true,
+        data: {
+          market: tokenId,
+          asset_id: tokenId,
+          bids: [{ price: priceData.price || 0.5, size: 1 }],
+          asks: [{ price: priceData.price || 0.5, size: 1 }],
+        },
+        timestamp: new Date(),
+      };
+    }
+
+    throw new Error('Both CLOB and price APIs failed');
+  } catch (error) {
+    console.error(`Error fetching Polymarket orderbook for ${tokenId}:`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Fetch price data for multiple Polymarket tokens
+ */
+export async function fetchPolymarketPrices(tokenIds: string[]): Promise<Map<string, number>> {
+  const prices = new Map<string, number>();
+  
+  // Batch fetch prices with rate limiting
+  const promises = tokenIds.map(async (tokenId, index) => {
+    // Add small delay to avoid rate limiting
+    await new Promise(resolve => setTimeout(resolve, index * 50));
+    
+    const response = await fetchPolymarketOrderbook(tokenId);
+    if (response.success && response.data) {
+      const orderbook = response.data;
+      // Use mid price from best bid/ask
+      const bestBid = orderbook.bids[0]?.price || 0;
+      const bestAsk = orderbook.asks[0]?.price || 1;
+      const midPrice = (bestBid + bestAsk) / 2;
+      prices.set(tokenId, midPrice);
+    }
+  });
+
+  await Promise.allSettled(promises);
+  return prices;
+}
+
+/**
+ * Convert Polymarket market to CommonMarket format
+ */
+export function normalizePolymarketMarket(
+  market: PolymarketMarket, 
+  priceData?: Map<string, PolymarketOrderbook>
+): CommonMarket {
+  const outcomes: MarketCondition[] = [];
+
+  // Handle binary markets (2 outcomes)
+  if (market.outcomes.length === 2 && market.clobTokenIds.length >= 2) {
+    market.outcomes.forEach((outcomeName, index) => {
+      const tokenId = market.clobTokenIds[index];
+      const orderbook = priceData?.get(tokenId);
+
+      let yesPrice = 0.5; // Default mid price
+      let noPrice = 0.5;
+
+      if (orderbook) {
+        const bestBid = orderbook.bids[0]?.price || 0;
+        const bestAsk = orderbook.asks[0]?.price || 1;
+        yesPrice = bestAsk; // Price to buy YES
+        noPrice = 1 - bestBid; // Price to buy NO (complement)
+      }
+
+      outcomes.push({
+        id: tokenId,
+        name: outcomeName,
+        yesPrice,
+        noPrice,
+        clobTokenId: tokenId,
+      });
+    });
+  } 
+  // Handle multi-outcome markets (>2 outcomes)
+  else if (market.outcomes.length > 2) {
+    market.outcomes.forEach((outcomeName, index) => {
+      const tokenId = market.clobTokenIds[index];
+      const orderbook = priceData?.get(tokenId);
+
+      let yesPrice = 1 / market.outcomes.length; // Equal probability default
+      let noPrice = 1 - yesPrice;
+
+      if (orderbook) {
+        const bestBid = orderbook.bids[0]?.price || 0;
+        const bestAsk = orderbook.asks[0]?.price || 1;
+        yesPrice = bestAsk;
+        // For multi-outcome, "no" price is more complex - use complement for now
+        noPrice = 1 - bestBid;
+      }
+
+      outcomes.push({
+        id: tokenId,
+        name: outcomeName,
+        yesPrice,
+        noPrice,
+        clobTokenId: tokenId,
+      });
+    });
+  }
+
+  // Calculate overall market prices for binary markets
+  let yesBid, yesAsk, noBid, noAsk;
+  if (outcomes.length === 2) {
+    const yesOutcome = outcomes[0];
+    const noOutcome = outcomes[1];
+    
+    yesAsk = yesOutcome.yesPrice;
+    noAsk = noOutcome.yesPrice;
+    yesBid = 1 - noOutcome.yesPrice;
+    noBid = 1 - yesOutcome.yesPrice;
+  }
+
+  return {
+    id: market.conditionId,
+    platform: 'polymarket',
+    title: market.question,
+    subtitle: market.description,
+    category: market.category || 'Unknown',
+    closeTime: new Date(market.endDate),
+    volume: market.volume,
+    settlementSource: market.resolutionSource,
+    yesBid,
+    yesAsk,
+    noBid,
+    noAsk,
+    outcomes,
+  };
+}
+
+/**
+ * Fetch and normalize all Polymarket markets
+ */
+export async function fetchNormalizedPolymarketMarkets(): Promise<ApiResponse<CommonMarket[]>> {
+  const marketsResponse = await fetchPolymarketMarkets();
+  
+  if (!marketsResponse.success || !marketsResponse.data) {
+    return marketsResponse as ApiResponse<CommonMarket[]>;
+  }
+
+  try {
+    // Collect all token IDs for price fetching
+    const allTokenIds: string[] = [];
+    marketsResponse.data.forEach(market => {
+      allTokenIds.push(...market.clobTokenIds);
+    });
+
+    // Fetch prices for all tokens
+    const priceMap = new Map<string, PolymarketOrderbook>();
+    
+    // Convert price data to orderbook format for normalization
+    const prices = await fetchPolymarketPrices(allTokenIds.slice(0, 50)); // Limit for initial load
+    prices.forEach((price, tokenId) => {
+      priceMap.set(tokenId, {
+        market: tokenId,
+        asset_id: tokenId,
+        bids: [{ price: price * 0.95, size: 1 }], // Approximate spread
+        asks: [{ price: price * 1.05, size: 1 }],
+      });
+    });
+
+    // Normalize markets with price data
+    const normalizedMarkets: CommonMarket[] = marketsResponse.data
+      .filter(market => market.active && market.clobTokenIds.length > 0)
+      .map(market => normalizePolymarketMarket(market, priceMap));
+
+    return {
+      success: true,
+      data: normalizedMarkets,
+      timestamp: new Date(),
+    };
+  } catch (error) {
+    console.error('Error normalizing Polymarket markets:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Error normalizing markets',
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Check if Polymarket APIs are accessible (health check)
+ */
+export async function checkPolymarketConnection(): Promise<{ gamma: boolean; clob: boolean }> {
+  const results = { gamma: false, clob: false };
+
+  try {
+    // Check Gamma API
+    const gammaResponse = await fetch(`${config.POLYMARKET_GAMMA_URL}/markets?limit=1`, {
+      method: 'GET',
+      headers: { 'Accept': 'application/json' },
+      signal: AbortSignal.timeout(5000),
+    });
+    results.gamma = gammaResponse.ok;
+  } catch (error) {
+    console.warn('Polymarket Gamma API connection check failed:', error);
+  }
+
+  try {
+    // Check CLOB API with a known endpoint
+    const clobResponse = await fetch(`${config.POLYMARKET_CLOB_URL}/ping`, {
+      method: 'GET',
+      signal: AbortSignal.timeout(5000),
+    });
+    results.clob = clobResponse.ok;
+  } catch (error) {
+    console.warn('Polymarket CLOB API connection check failed:', error);
+  }
+
+  return results;
+}
+
+/**
+ * Get real-time price updates for specific tokens (for SSE/polling)
+ */
+export async function getPolymarketLivePrices(tokenIds: string[]): Promise<Map<string, { price: number; timestamp: Date }>> {
+  const livePrices = new Map<string, { price: number; timestamp: Date }>();
+  
+  try {
+    const prices = await fetchPolymarketPrices(tokenIds);
+    const timestamp = new Date();
+    
+    prices.forEach((price, tokenId) => {
+      livePrices.set(tokenId, { price, timestamp });
+    });
+  } catch (error) {
+    console.error('Error fetching live Polymarket prices:', error);
+  }
+
+  return livePrices;
+}
\ No newline at end of file
diff --git a/src/api/types.ts b/src/api/types.ts
new file mode 100644
index 0000000..a4230ee
--- /dev/null
+++ b/src/api/types.ts
@@ -0,0 +1,216 @@
+// Shared TypeScript types for arbitrage detection system
+
+// Platform identifier
+export type Platform = 'kalshi' | 'polymarket';
+
+// Relationship types for condition mapping
+export type RelationshipType = 'same' | 'subset' | 'mutually-exclusive' | 'complementary' | 'opposites' | 'overlapping';
+
+// Common market structure normalized across platforms
+export interface CommonMarket {
+  id: string;
+  platform: Platform;
+  title: string;
+  subtitle?: string;
+  category: string;
+  closeTime: Date;
+  volume?: number;
+  liquidity?: number;
+  settlementSource?: string;
+  rules?: string;
+  // Pricing for binary markets
+  yesBid?: number;
+  yesAsk?: number;
+  noBid?: number;
+  noAsk?: number;
+  // Multi-outcome conditions
+  outcomes: MarketCondition[];
+}
+
+// Individual condition/outcome within a market
+export interface MarketCondition {
+  id: string;
+  name: string;
+  yesPrice: number;
+  noPrice: number;
+  volume?: number;
+  // For Polymarket multi-outcome markets
+  clobTokenId?: string;
+}
+
+// Kalshi-specific market data
+export interface KalshiMarket {
+  event_ticker: string;
+  ticker: string;
+  title: string;
+  subtitle?: string;
+  status: string;
+  close_time: string;
+  expiration_time: string;
+  category: string;
+  yes_bid?: number;
+  yes_ask?: number;
+  no_bid?: number;
+  no_ask?: number;
+  volume?: number;
+  open_interest?: number;
+  dollar_volume?: number;
+}
+
+// Kalshi orderbook structure
+export interface KalshiOrderbook {
+  market: string;
+  yes?: Array<{ price: number; size: number }>;
+  no?: Array<{ price: number; size: number }>;
+}
+
+// Polymarket-specific market data
+export interface PolymarketMarket {
+  conditionId: string;
+  questionId: string;
+  question: string;
+  description?: string;
+  outcomes: string[];
+  outcomeSlots: string[];
+  resolutionSource: string;
+  endDate: string;
+  category: string;
+  clobTokenIds: string[];
+  active: boolean;
+  volume?: number;
+}
+
+// Polymarket orderbook/price data
+export interface PolymarketOrderbook {
+  market: string;
+  asset_id: string;
+  bids: Array<{ price: number; size: number }>;
+  asks: Array<{ price: number; size: number }>;
+}
+
+// Condition mapping between different platforms
+export interface ConditionMapping {
+  id: string;
+  kalshiCondition?: string;
+  polymarketCondition?: string;
+  relationship: RelationshipType;
+  confidence?: number;
+  createdAt: Date;
+}
+
+// Market match between platforms
+export interface MarketMatch {
+  id: string;
+  kalshiMarketId: string;
+  polymarketMarketId: string;
+  createdAt: Date;
+  confidence: number;
+  conditionMappings: ConditionMapping[];
+  conditionsMatched: boolean;
+  totalVolume?: number;
+}
+
+// Ecosystem containing multiple markets across exchanges
+export interface Ecosystem {
+  id: string;
+  name: string;
+  createdAt: Date;
+  marketRefs: Array<{
+    platform: Platform;
+    marketId: string;
+    market?: CommonMarket;
+  }>;
+  conditionMappings: ConditionMapping[];
+  conditionsMatched: boolean;
+  // Derived stats
+  exchanges: number;
+  markets: number;
+  conditions: number;
+  earliestEndTime?: Date;
+}
+
+// Arbitrage opportunity
+export interface ArbitrageOpportunity {
+  id: string;
+  eventName: string;
+  eventType: string;
+  market: string;
+  earliestEndTime: Date;
+  daysUntilClose: number;
+  // Arbitrage calculation
+  minYes: number;
+  minNo: number;
+  C: number; // minYes + minNo
+  periodReturn: number; // (1 - C) / C
+  apr: number; // periodReturn * (365 / daysUntilClose)
+  profitOn100: number; // 100 * periodReturn
+  // Underlying bets
+  yesBet: {
+    platform: Platform;
+    marketId: string;
+    condition: string;
+    price: number;
+  };
+  noBet: {
+    platform: Platform;
+    marketId: string;
+    condition: string;
+    price: number;
+  };
+  // Metadata
+  updatedAt: Date;
+  // All underlying conditions for expanded view
+  allConditions: Array<{
+    platform: Platform;
+    marketId: string;
+    condition: string;
+    yesPrice: number;
+    noPrice: number;
+  }>;
+}
+
+// API response wrapper
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  timestamp: Date;
+}
+
+// Market similarity scoring
+export interface SimilarityScore {
+  overall: number;
+  title: number;
+  date: number;
+  conditions: number;
+  settlement: number;
+}
+
+// Polling configuration
+export interface PollingConfig {
+  kalshiInterval: number; // milliseconds
+  polymarketInterval: number; // milliseconds
+  enabled: boolean;
+}
+
+// Store state interface
+export interface MatchesStore {
+  markets: {
+    kalshi: CommonMarket[];
+    polymarket: CommonMarket[];
+    lastUpdated: Date;
+  };
+  matches: MarketMatch[];
+  ecosystems: Ecosystem[];
+  arbitrageOpportunities: ArbitrageOpportunity[];
+  polling: PollingConfig;
+}
+
+// Environment configuration
+export interface EnvironmentConfig {
+  KALSHI_API_KEY?: string;
+  KALSHI_BASE_URL: string;
+  POLYMARKET_GAMMA_URL: string;
+  POLYMARKET_CLOB_URL: string;
+  POLYMARKET_PRICE_URL: string;
+}
\ No newline at end of file
diff --git a/src/arbitrage-bets-component.tsx b/src/arbitrage-bets-component.tsx
index 97acbbb..7cc1b68 100644
--- a/src/arbitrage-bets-component.tsx
+++ b/src/arbitrage-bets-component.tsx
@@ -1,144 +1,39 @@
 import React, { useState, useEffect } from 'react';
 import { Circle, Square, Search, Settings, RefreshCw, ChevronDown } from 'lucide-react';
+import { useLiveOrderbooks } from './hooks/useLiveOrderbooks';
+import { getStore, subscribeToStore } from './state/matches-store';
+import { ArbitrageOpportunity } from './api/types';
 
 const ArbitrageBets = () => {
   const [activeTab, setActiveTab] = useState('pre-match');
   const [searchTerm, setSearchTerm] = useState('');
-  const [arbitrageData, setArbitrageData] = useState([]);
-  const [expandedRows, setExpandedRows] = useState([]);
+  const [arbitrageData, setArbitrageData] = useState<ArbitrageOpportunity[]>([]);
+  const [expandedRows, setExpandedRows] = useState<string[]>([]);
 
-  // Mock data for demonstration with conditions
-  const mockArbitrageData = [
-    {
-      id: 1,
-      percentage: 1.64,
-      event: 'Toronto Blue Jays vs Cleveland Guardians',
-      eventType: 'Baseball | MLB',
-      market: '1st inning Total Runs',
-      startTime: '7:10 PM',
-      bets: [
-        { outcome: 'Over 0.5', venue: 'NoVig', odds: '+125', stake: 100, payout: 225 },
-        { outcome: 'Under 0.5', venue: 'Sporttrade', odds: '-117', stake: 117, payout: 217 }
-      ],
-      profit: 8,
-      totalStake: 217,
-      updated: '2 min ago',
-      kalshiConditions: [
-        { name: 'Over 0.5', yesPrice: 0.44, noPrice: 0.56 },
-        { name: 'Under 0.5', yesPrice: 0.54, noPrice: 0.46 }
-      ],
-      polymarketConditions: [
-        { name: 'Over 0.5 runs', yesPrice: 0.42, noPrice: 0.58 },
-        { name: 'Under 0.5 runs', yesPrice: 0.56, noPrice: 0.44 }
-      ]
-    },
-    {
-      id: 2,
-      percentage: 1.6,
-      event: 'Atlanta Braves vs Pittsburgh Pirates',
-      eventType: 'Baseball | MLB',
-      market: 'Total Runs',
-      startTime: '8:39 PM',
-      bets: [
-        { outcome: 'Over 8.5', venue: 'ProphetX', odds: '-108', stake: 108, payout: 208 },
-        { outcome: 'Under 8.5', venue: 'NoVig', odds: '+113', stake: 100, payout: 213 }
-      ],
-      profit: 5,
-      totalStake: 208,
-      updated: '5 min ago',
-      kalshiConditions: [
-        { name: 'Over 8.5', yesPrice: 0.52, noPrice: 0.48 },
-        { name: 'Under 8.5', yesPrice: 0.47, noPrice: 0.53 }
-      ],
-      polymarketConditions: [
-        { name: 'Over 8.5 total', yesPrice: 0.50, noPrice: 0.50 },
-        { name: 'Under 8.5 total', yesPrice: 0.49, noPrice: 0.51 }
-      ]
-    },
-    {
-      id: 3,
-      percentage: 1.35,
-      event: 'Atlanta Braves vs Pittsburgh Pirates',
-      eventType: 'Baseball | MLB',
-      market: '1st Half Total Runs',
-      startTime: '8:30 PM',
-      bets: [
-        { outcome: 'Over 7.5', venue: 'Kalshi', odds: '-235', stake: 235, payout: 335 },
-        { outcome: 'Under 7.5', venue: 'Polymarket', odds: '+240', stake: 100, payout: 340 }
-      ],
-      profit: 5,
-      totalStake: 335,
-      updated: '8 min ago',
-      kalshiConditions: [
-        { name: 'Over 7.5', yesPrice: 0.70, noPrice: 0.30 },
-        { name: 'Under 7.5', yesPrice: 0.29, noPrice: 0.71 }
-      ],
-      polymarketConditions: [
-        { name: 'Over 7.5 runs', yesPrice: 0.68, noPrice: 0.32 },
-        { name: 'Under 7.5 runs', yesPrice: 0.31, noPrice: 0.69 }
-      ]
-    },
-    {
-      id: 4,
-      percentage: 2.1,
-      event: 'Fed Rate Decision - September 2025',
-      eventType: 'Politics | Economics',
-      market: 'Will Fed raise rates?',
-      startTime: 'Sep 18',
-      bets: [
-        { outcome: 'Yes', venue: 'Kalshi', odds: '+180', stake: 100, payout: 280 },
-        { outcome: 'No', venue: 'Polymarket', odds: '-165', stake: 165, payout: 265 }
-      ],
-      profit: 15,
-      totalStake: 265,
-      updated: '12 min ago',
-      kalshiConditions: [
-        { name: '25 bps increase', yesPrice: 0.35, noPrice: 0.65 },
-        { name: 'No change', yesPrice: 0.45, noPrice: 0.55 },
-        { name: '25 bps decrease', yesPrice: 0.18, noPrice: 0.82 },
-        { name: '50+ bps increase', yesPrice: 0.02, noPrice: 0.98 }
-      ],
-      polymarketConditions: [
-        { name: 'Rate increase', yesPrice: 0.37, noPrice: 0.63 },
-        { name: 'No change', yesPrice: 0.44, noPrice: 0.56 },
-        { name: 'Rate decrease', yesPrice: 0.19, noPrice: 0.81 }
-      ]
-    },
-    {
-      id: 5,
-      percentage: 1.8,
-      event: 'Bitcoin above $100k by EOY',
-      eventType: 'Crypto | Finance',
-      market: 'Bitcoin > $100,000',
-      startTime: 'Dec 31',
-      bets: [
-        { outcome: 'Yes', venue: 'Polymarket', odds: '+145', stake: 100, payout: 245 },
-        { outcome: 'No', venue: 'Kalshi', odds: '-135', stake: 135, payout: 235 }
-      ],
-      profit: 10,
-      totalStake: 235,
-      updated: '15 min ago',
-      kalshiConditions: [
-        { name: 'Yes', yesPrice: 0.40, noPrice: 0.60 },
-        { name: 'No', yesPrice: 0.60, noPrice: 0.40 }
-      ],
-      polymarketConditions: [
-        { name: 'Yes', yesPrice: 0.38, noPrice: 0.62 },
-        { name: 'No', yesPrice: 0.62, noPrice: 0.38 }
-      ]
-    }
-  ];
+  // Use live data hook
+  const { loading, error, forceRefresh } = useLiveOrderbooks();
 
+  // Subscribe to arbitrage opportunities from store
   useEffect(() => {
-    setArbitrageData(mockArbitrageData);
+    const updateArbitrageData = () => {
+      const store = getStore();
+      setArbitrageData(store.arbitrageOpportunities);
+    };
+
+    // Initial load
+    updateArbitrageData();
+
+    // Subscribe to updates
+    const unsubscribe = subscribeToStore(updateArbitrageData);
+    return unsubscribe;
   }, []);
 
   const filteredData = arbitrageData.filter(item =>
-    item.event.toLowerCase().includes(searchTerm.toLowerCase()) ||
+    item.eventName.toLowerCase().includes(searchTerm.toLowerCase()) ||
     item.market.toLowerCase().includes(searchTerm.toLowerCase())
   );
 
-  const toggleRowExpansion = (id) => {
+  const toggleRowExpansion = (id: string) => {
     setExpandedRows(prev => 
       prev.includes(id) 
         ? prev.filter(rowId => rowId !== id)
@@ -146,27 +41,66 @@ const ArbitrageBets = () => {
     );
   };
 
-  const ExpandedConditions = ({ item }) => (
+  const handleRefresh = () => {
+    forceRefresh();
+  };
+
+  const formatTimeAgo = (date: Date): string => {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMin = Math.floor(diffMs / (1000 * 60));
+    
+    if (diffMin < 1) return 'Just now';
+    if (diffMin === 1) return '1 min ago';
+    if (diffMin < 60) return `${diffMin} min ago`;
+    
+    const diffHours = Math.floor(diffMin / 60);
+    if (diffHours === 1) return '1 hour ago';
+    if (diffHours < 24) return `${diffHours} hours ago`;
+    
+    const diffDays = Math.floor(diffHours / 24);
+    return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+  };
+
+  const formatDate = (date: Date): string => {
+    return date.toLocaleDateString('en-US', { 
+      month: 'short', 
+      day: 'numeric',
+      year: date.getFullYear() !== new Date().getFullYear() ? 'numeric' : undefined
+    });
+  };
+
+  const ExpandedConditions = ({ item }: { item: ArbitrageOpportunity }) => (
     <tr>
       <td colSpan="10" className="p-0">
         <div className="bg-gray-800 border-t border-gray-700">
           <div className="p-4">
             <div className="grid grid-cols-2 gap-6">
-              {/* Kalshi Conditions */}
+              {/* All Conditions */}
               <div>
-                <h4 className="text-sm font-semibold text-blue-400 mb-3">Kalshi Conditions</h4>
+                <h4 className="text-sm font-semibold text-gray-300 mb-3">All Market Conditions</h4>
                 <table className="w-full">
                   <thead>
                     <tr className="text-xs text-gray-400 border-b border-gray-700">
+                      <th className="text-left pb-2">Platform</th>
                       <th className="text-left pb-2">Condition</th>
                       <th className="text-right pb-2">Yes Price</th>
                       <th className="text-right pb-2">No Price</th>
                     </tr>
                   </thead>
                   <tbody>
-                    {item.kalshiConditions.map((condition, idx) => (
+                    {item.allConditions.map((condition, idx) => (
                       <tr key={idx} className="text-sm">
-                        <td className="py-2">{condition.name}</td>
+                        <td className="py-2">
+                          <span className={`px-2 py-1 rounded text-xs font-medium ${
+                            condition.platform === 'kalshi' 
+                              ? 'bg-blue-900 text-blue-300' 
+                              : 'bg-purple-900 text-purple-300'
+                          }`}>
+                            {condition.platform === 'kalshi' ? 'Kalshi' : 'Polymarket'}
+                          </span>
+                        </td>
+                        <td className="py-2">{condition.condition}</td>
                         <td className="py-2 text-right text-green-400">{(condition.yesPrice * 100).toFixed(0)}¢</td>
                         <td className="py-2 text-right text-red-400">{(condition.noPrice * 100).toFixed(0)}¢</td>
                       </tr>
@@ -175,27 +109,41 @@ const ArbitrageBets = () => {
                 </table>
               </div>
 
-              {/* Polymarket Conditions */}
+              {/* Arbitrage Details */}
               <div>
-                <h4 className="text-sm font-semibold text-purple-400 mb-3">Polymarket Conditions</h4>
-                <table className="w-full">
-                  <thead>
-                    <tr className="text-xs text-gray-400 border-b border-gray-700">
-                      <th className="text-left pb-2">Condition</th>
-                      <th className="text-right pb-2">Yes Price</th>
-                      <th className="text-right pb-2">No Price</th>
-                    </tr>
-                  </thead>
-                  <tbody>
-                    {item.polymarketConditions.map((condition, idx) => (
-                      <tr key={idx} className="text-sm">
-                        <td className="py-2">{condition.name}</td>
-                        <td className="py-2 text-right text-green-400">{(condition.yesPrice * 100).toFixed(0)}¢</td>
-                        <td className="py-2 text-right text-red-400">{(condition.noPrice * 100).toFixed(0)}¢</td>
-                      </tr>
-                    ))}
-                  </tbody>
-                </table>
+                <h4 className="text-sm font-semibold text-gray-300 mb-3">Arbitrage Calculation</h4>
+                <div className="space-y-3">
+                  <div className="bg-gray-700 p-3 rounded">
+                    <div className="text-xs text-gray-400">Best YES Price</div>
+                    <div className="text-green-400 font-medium">
+                      {(item.minYes * 100).toFixed(0)}¢ 
+                      <span className="text-xs text-gray-400 ml-1">
+                        ({item.yesBet.platform})
+                      </span>
+                    </div>
+                  </div>
+                  <div className="bg-gray-700 p-3 rounded">
+                    <div className="text-xs text-gray-400">Best NO Price</div>
+                    <div className="text-red-400 font-medium">
+                      {(item.minNo * 100).toFixed(0)}¢ 
+                      <span className="text-xs text-gray-400 ml-1">
+                        ({item.noBet.platform})
+                      </span>
+                    </div>
+                  </div>
+                  <div className="bg-gray-700 p-3 rounded">
+                    <div className="text-xs text-gray-400">Total Cost (C)</div>
+                    <div className="text-yellow-400 font-medium">{(item.C * 100).toFixed(0)}¢</div>
+                  </div>
+                  <div className="bg-gray-700 p-3 rounded">
+                    <div className="text-xs text-gray-400">Period Return</div>
+                    <div className="text-blue-400 font-medium">{(item.periodReturn * 100).toFixed(2)}%</div>
+                  </div>
+                  <div className="bg-gray-700 p-3 rounded">
+                    <div className="text-xs text-gray-400">Days to Close</div>
+                    <div className="text-gray-300 font-medium">{item.daysUntilClose} days</div>
+                  </div>
+                </div>
               </div>
             </div>
           </div>
@@ -226,8 +174,8 @@ const ArbitrageBets = () => {
               />
             </div>
             
-            <button className="p-2 hover:bg-gray-800 rounded">
-              <RefreshCw className="w-5 h-5" />
+            <button onClick={handleRefresh} className="p-2 hover:bg-gray-800 rounded">
+              <RefreshCw className={`w-5 h-5 ${loading ? 'animate-spin' : ''}`} />
             </button>
           </div>
         </div>
@@ -235,6 +183,32 @@ const ArbitrageBets = () => {
 
       {/* Main Content */}
       <div className="p-4">
+        {/* Error Display */}
+        {error && (
+          <div className="bg-red-900 bg-opacity-20 border border-red-600 rounded-lg p-3 mb-4">
+            <div className="text-red-300 text-sm">
+              <strong>Connection Error:</strong> {error}
+            </div>
+          </div>
+        )}
+
+        {/* Loading State */}
+        {loading && arbitrageData.length === 0 && (
+          <div className="bg-gray-900 rounded-lg p-8 text-center">
+            <RefreshCw className="w-8 h-8 animate-spin text-blue-400 mx-auto mb-2" />
+            <div className="text-gray-400">Loading arbitrage opportunities...</div>
+          </div>
+        )}
+
+        {/* No Data State */}
+        {!loading && arbitrageData.length === 0 && !error && (
+          <div className="bg-gray-900 rounded-lg p-8 text-center">
+            <div className="text-gray-400 mb-2">No arbitrage opportunities found</div>
+            <div className="text-xs text-gray-500">
+              Opportunities appear when matched markets have profitable price differences
+            </div>
+          </div>
+        )}
         {/* Info Bar */}
         <div className="bg-gray-900 rounded-lg p-3 mb-4 flex items-center justify-between">
           <span className="text-sm text-gray-300">
@@ -253,102 +227,116 @@ const ArbitrageBets = () => {
         </div>
 
         {/* Table */}
-        <div className="bg-gray-900 rounded-lg overflow-hidden">
-          <table className="w-full">
-            <thead>
-              <tr className="bg-gray-800 text-left text-xs uppercase text-gray-400">
-                <th className="p-3">Percent ↓</th>
-                <th className="p-3">Event Name</th>
-                <th className="p-3">Start Time</th>
-                <th className="p-3">Market</th>
-                <th className="p-3">Bets</th>
-                <th className="p-3">Odds</th>
-                <th className="p-3">Stake</th>
-                <th className="p-3">Profit</th>
-                <th className="p-3">Updated</th>
-                <th className="p-3"></th>
-              </tr>
-            </thead>
-            <tbody>
-              {filteredData.map((item) => (
-                <React.Fragment key={item.id}>
-                  <tr 
-                    className="border-t border-gray-800 hover:bg-gray-800 cursor-pointer"
-                    onClick={() => toggleRowExpansion(item.id)}
-                  >
-                    <td className="p-3">
-                      <div className="flex items-center space-x-2">
-                        <Square className="w-4 h-4 text-gray-600" />
-                        <Circle className="w-4 h-4 text-blue-500" />
-                        <span className="text-green-400 font-medium">{item.percentage}%</span>
-                      </div>
-                    </td>
-                    <td className="p-3">
-                      <div className="text-sm">{item.event}</div>
-                      <div className="text-xs text-gray-500">{item.eventType}</div>
-                    </td>
-                    <td className="p-3 text-center">
-                      <span className="text-sm">{item.startTime}</span>
-                    </td>
-                    <td className="p-3">
-                      <span className="text-sm">{item.market}</span>
-                    </td>
-                    <td className="p-3">
-                      <div className="space-y-1">
-                        {item.bets.map((bet, i) => (
-                          <div key={i} className="text-sm">
-                            {i === 0 ? (
-                              <span className="text-green-400">{bet.outcome}</span>
-                            ) : (
-                              <span className="text-red-400">{bet.outcome}</span>
-                            )}
+        {arbitrageData.length > 0 && (
+          <div className="bg-gray-900 rounded-lg overflow-hidden">
+            <table className="w-full">
+              <thead>
+                <tr className="bg-gray-800 text-left text-xs uppercase text-gray-400">
+                  <th className="p-3">APR ↓</th>
+                  <th className="p-3">Event Name</th>
+                  <th className="p-3">End Time</th>
+                  <th className="p-3">Days Left</th>
+                  <th className="p-3">Market</th>
+                  <th className="p-3">Bets</th>
+                  <th className="p-3">Odds</th>
+                  <th className="p-3">Profit on $100</th>
+                  <th className="p-3">Updated</th>
+                  <th className="p-3"></th>
+                </tr>
+              </thead>
+              <tbody>
+                {filteredData.map((item) => (
+                  <React.Fragment key={item.id}>
+                    <tr 
+                      className="border-t border-gray-800 hover:bg-gray-800 cursor-pointer"
+                      onClick={() => toggleRowExpansion(item.id)}
+                    >
+                      <td className="p-3">
+                        <div className="flex items-center space-x-2">
+                          <Square className="w-4 h-4 text-gray-600" />
+                          <Circle className="w-4 h-4 text-blue-500" />
+                          <span className="text-green-400 font-medium">{(item.apr * 100).toFixed(1)}%</span>
+                        </div>
+                      </td>
+                      <td className="p-3">
+                        <div className="text-sm">{item.eventName}</div>
+                        <div className="text-xs text-gray-500">{item.eventType}</div>
+                      </td>
+                      <td className="p-3 text-center">
+                        <span className="text-sm">{formatDate(item.earliestEndTime)}</span>
+                      </td>
+                      <td className="p-3 text-center">
+                        <span className="text-sm">{item.daysUntilClose}</span>
+                      </td>
+                      <td className="p-3">
+                        <span className="text-sm">{item.market}</span>
+                      </td>
+                      <td className="p-3">
+                        <div className="space-y-1">
+                          <div className="text-sm">
+                            <span className="text-green-400">{item.yesBet.condition}</span>
+                          </div>
+                          <div className="text-sm">
+                            <span className="text-red-400">{item.noBet.condition}</span>
                           </div>
-                        ))}
-                      </div>
-                    </td>
-                    <td className="p-3">
-                      <div className="space-y-1">
-                        {item.bets.map((bet, i) => (
-                          <div key={i} className="flex items-center space-x-2 text-sm">
-                            <span className="bg-gray-800 px-2 py-1 rounded text-xs">
-                              {bet.venue}
+                        </div>
+                      </td>
+                      <td className="p-3">
+                        <div className="space-y-1">
+                          <div className="flex items-center space-x-2 text-sm">
+                            <span className={`px-2 py-1 rounded text-xs ${
+                              item.yesBet.platform === 'kalshi' 
+                                ? 'bg-blue-800 text-blue-300' 
+                                : 'bg-purple-800 text-purple-300'
+                            }`}>
+                              {item.yesBet.platform === 'kalshi' ? 'Kalshi' : 'Polymarket'}
                             </span>
-                            <span className="font-medium">{bet.odds}</span>
+                            <span className="font-medium">{(item.yesBet.price * 100).toFixed(0)}¢</span>
                           </div>
-                        ))}
-                      </div>
-                    </td>
-                    <td className="p-3">
-                      <div className="text-sm font-medium">${item.totalStake}</div>
-                    </td>
-                    <td className="p-3">
-                      <div className="text-green-400 font-medium">+${item.profit}</div>
-                    </td>
-                    <td className="p-3">
-                      <span className="text-xs text-gray-400">{item.updated}</span>
-                    </td>
-                    <td className="p-3">
-                      <ChevronDown 
-                        className={`w-4 h-4 text-gray-400 transform transition-transform ${
-                          expandedRows.includes(item.id) ? 'rotate-180' : ''
-                        }`} 
-                      />
-                    </td>
-                  </tr>
-                  {expandedRows.includes(item.id) && <ExpandedConditions item={item} />}
-                </React.Fragment>
-              ))}
-            </tbody>
-          </table>
-        </div>
+                          <div className="flex items-center space-x-2 text-sm">
+                            <span className={`px-2 py-1 rounded text-xs ${
+                              item.noBet.platform === 'kalshi' 
+                                ? 'bg-blue-800 text-blue-300' 
+                                : 'bg-purple-800 text-purple-300'
+                            }`}>
+                              {item.noBet.platform === 'kalshi' ? 'Kalshi' : 'Polymarket'}
+                            </span>
+                            <span className="font-medium">{(item.noBet.price * 100).toFixed(0)}¢</span>
+                          </div>
+                        </div>
+                      </td>
+                      <td className="p-3">
+                        <div className="text-green-400 font-medium">+${item.profitOn100.toFixed(2)}</div>
+                      </td>
+                      <td className="p-3">
+                        <span className="text-xs text-gray-400">{formatTimeAgo(item.updatedAt)}</span>
+                      </td>
+                      <td className="p-3">
+                        <ChevronDown 
+                          className={`w-4 h-4 text-gray-400 transform transition-transform ${
+                            expandedRows.includes(item.id) ? 'rotate-180' : ''
+                          }`} 
+                        />
+                      </td>
+                    </tr>
+                    {expandedRows.includes(item.id) && <ExpandedConditions item={item} />}
+                  </React.Fragment>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        )}
 
         {/* Settings and Refresh buttons */}
         <div className="fixed bottom-6 right-6 flex space-x-2">
           <button className="bg-gray-800 hover:bg-gray-700 p-3 rounded-full shadow-lg">
             <Settings className="w-5 h-5" />
           </button>
-          <button className="bg-blue-600 hover:bg-blue-700 p-3 rounded-full shadow-lg">
-            <RefreshCw className="w-5 h-5" />
+          <button 
+            onClick={handleRefresh}
+            className={`bg-blue-600 hover:bg-blue-700 p-3 rounded-full shadow-lg ${loading ? 'animate-pulse' : ''}`}
+          >
+            <RefreshCw className={`w-5 h-5 ${loading ? 'animate-spin' : ''}`} />
           </button>
         </div>
       </div>
diff --git a/src/ecosystem-matcher-component.tsx b/src/ecosystem-matcher-component.tsx
index e00b2a1..1a408ac 100644
--- a/src/ecosystem-matcher-component.tsx
+++ b/src/ecosystem-matcher-component.tsx
@@ -1,194 +1,52 @@
 import React, { useState, useEffect } from 'react';
 import { Search, Check, X, CheckCircle, XCircle, Edit2 } from 'lucide-react';
+import { useMarketData } from './hooks/useLiveOrderbooks';
+import { 
+  getStore, 
+  subscribeToStore, 
+  createEcosystem, 
+  updateEcosystemConditions 
+} from './state/matches-store';
+import { 
+  CommonMarket, 
+  Ecosystem, 
+  ConditionMapping, 
+  RelationshipType,
+  Platform 
+} from './api/types';
 
 const EcosystemMatcher = () => {
   const [activeTab, setActiveTab] = useState('manual');
-  const [selectedMarkets, setSelectedMarkets] = useState([]);
+  const [selectedMarkets, setSelectedMarkets] = useState<Array<{ market: CommonMarket; platform: Platform }>>([]);
   const [searchTermKalshi, setSearchTermKalshi] = useState('');
   const [searchTermPoly, setSearchTermPoly] = useState('');
   const [showConditionMatcher, setShowConditionMatcher] = useState(false);
-  const [selectedEcosystem, setSelectedEcosystem] = useState(null);
-
-  // Mock data for markets
-  const [kalshiMarkets] = useState([
-    {
-      id: 'FED-SEPT-2025',
-      title: 'Fed decision in September?',
-      category: 'Economics',
-      volume: 450000,
-      liquidity: 120000,
-      closeDate: '2025-09-18',
-      conditions: [
-        { name: '25 bps decrease', yesPrice: 0.80, noPrice: 0.20 },
-        { name: 'No change', yesPrice: 0.15, noPrice: 0.85 },
-        { name: '25+ bps increase', yesPrice: 0.01, noPrice: 0.99 }
-      ]
-    },
-    {
-      id: 'BTCPRICE-25DEC31',
-      title: 'Bitcoin above $100k by year end?',
-      category: 'Crypto',
-      volume: 890000,
-      liquidity: 250000,
-      closeDate: '2025-12-31',
-      conditions: [
-        { name: 'Yes', yesPrice: 0.40, noPrice: 0.60 },
-        { name: 'No', yesPrice: 0.60, noPrice: 0.40 }
-      ]
-    },
-    {
-      id: 'ELECTION-2028-WINNER',
-      title: 'Presidential Election Winner 2028',
-      category: 'Politics',
-      volume: 6000000,
-      liquidity: 450000,
-      closeDate: '2028-11-05',
-      conditions: [
-        { name: 'JD Vance', yesPrice: 0.28, noPrice: 0.72 },
-        { name: 'Gavin Newsom', yesPrice: 0.13, noPrice: 0.87 },
-        { name: 'Alexandria Ocasio-Cortez', yesPrice: 0.09, noPrice: 0.91 },
-        { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93 },
-        { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94 },
-        { name: 'Andy Beshear', yesPrice: 0.05, noPrice: 0.95 },
-        { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96 }
-      ]
-    }
-  ]);
-
-  const [polymarketMarkets] = useState([
-    {
-      id: '0xfedrate092025',
-      title: 'Federal Reserve Rate Decision September 2025',
-      category: 'Macro',
-      volume: 420000,
-      liquidity: 110000,
-      closeDate: '2025-09-18',
-      conditions: [
-        { name: 'Rate decrease', yesPrice: 0.78, noPrice: 0.22 },
-        { name: 'No change', yesPrice: 0.16, noPrice: 0.84 },
-        { name: 'Rate increase', yesPrice: 0.02, noPrice: 0.98 }
-      ]
-    },
-    {
-      id: '0xbtc100keoy',
-      title: 'BTC above $100,000 by EOY',
-      category: 'Cryptocurrency',
-      volume: 670000,
-      liquidity: 180000,
-      closeDate: '2025-12-31',
-      conditions: [
-        { name: 'Yes', yesPrice: 0.38, noPrice: 0.62 },
-        { name: 'No', yesPrice: 0.62, noPrice: 0.38 }
-      ]
-    },
-    {
-      id: '0x2028election',
-      title: '2028 US Presidential Election',
-      category: 'Politics',
-      volume: 5200000,
-      liquidity: 380000,
-      closeDate: '2028-11-05',
-      conditions: [
-        { name: 'J.D. Vance', yesPrice: 0.27, noPrice: 0.73 },
-        { name: 'Gavin Newsom', yesPrice: 0.14, noPrice: 0.86 },
-        { name: 'AOC', yesPrice: 0.08, noPrice: 0.92 },
-        { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93 },
-        { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94 },
-        { name: 'Andrew Beshear', yesPrice: 0.05, noPrice: 0.95 },
-        { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96 }
-      ]
-    }
-  ]);
-
-  const [ecosystemHistory, setEcosystemHistory] = useState([
-    {
-      id: 1,
-      name: 'Fed Rate Decision - September 2025',
-      createdDate: '2025-08-01',
-      exchanges: 4,
-      markets: 6,
-      conditions: 13,
-      status: 'active',
-      conditionsMatched: true,
-      conditionMappings: [
-        {
-          conditions: {
-            'Kalshi-Fed decision in September?': '25 bps decrease',
-            'Polymarket-Federal Reserve Rate Decision September 2025': 'Rate decrease',
-            'ProphetX-FOMC September Outcome': 'Dovish',
-            'NoVig-Fed Rates Sep': null
-          },
-          relationship: 'same'
-        },
-        {
-          conditions: {
-            'Kalshi-Fed decision in September?': 'No change',
-            'Polymarket-Federal Reserve Rate Decision September 2025': 'No change',
-            'ProphetX-FOMC September Outcome': 'Neutral',
-            'NoVig-Fed Rates Sep': null
-          },
-          relationship: 'same'
-        }
-      ],
-      marketData: [
-        {
-          exchange: 'Kalshi',
-          market: 'Fed decision in September?',
-          conditions: [
-            { name: '25 bps decrease', yesPrice: 0.80, noPrice: 0.20 },
-            { name: 'No change', yesPrice: 0.15, noPrice: 0.85 },
-            { name: '25+ bps increase', yesPrice: 0.01, noPrice: 0.99 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'Federal Reserve Rate Decision September 2025',
-          conditions: [
-            { name: 'Rate decrease', yesPrice: 0.78, noPrice: 0.22 },
-            { name: 'No change', yesPrice: 0.16, noPrice: 0.84 },
-            { name: 'Rate increase', yesPrice: 0.02, noPrice: 0.98 }
-          ]
-        },
-        {
-          exchange: 'ProphetX',
-          market: 'FOMC September Outcome',
-          conditions: [
-            { name: 'Hawkish', yesPrice: 0.40, noPrice: 0.60 },
-            { name: 'Dovish', yesPrice: 0.35, noPrice: 0.65 },
-            { name: 'Neutral', yesPrice: 0.25, noPrice: 0.75 }
-          ]
-        },
-        {
-          exchange: 'NoVig',
-          market: 'Fed Rates Sep',
-          conditions: [
-            { name: 'Increase', yesPrice: 0.38, noPrice: 0.62 }
-          ]
-        }
-      ]
-    },
-    {
-      id: 2,
-      name: '2028 Presidential Election',
-      createdDate: '2025-07-15',
-      exchanges: 3,
-      markets: 5,
-      conditions: 21,
-      status: 'active',
-      conditionsMatched: false,
-      conditionMappings: [],
-      marketData: []
-    }
-  ]);
+  const [selectedEcosystem, setSelectedEcosystem] = useState<Ecosystem | null>(null);
+  const [ecosystemHistory, setEcosystemHistory] = useState<Ecosystem[]>([]);
+
+  // Use live market data
+  const { kalshiMarkets, polymarketMarkets, loading, error } = useMarketData();
+
+  // Subscribe to ecosystem history from store
+  useEffect(() => {
+    const updateEcosystemHistory = () => {
+      const store = getStore();
+      setEcosystemHistory(store.ecosystems);
+    };
+
+    updateEcosystemHistory();
+    const unsubscribe = subscribeToStore(updateEcosystemHistory);
+    return unsubscribe;
+  }, []);
 
   const EcosystemConditionMatcher = () => {
-    const [mappings, setMappings] = useState(
+    const [mappings, setMappings] = useState<ConditionMapping[]>(
       selectedEcosystem?.conditionMappings || []
     );
-    const [selectedConditions, setSelectedConditions] = useState({});
-    const [selectedRelationship, setSelectedRelationship] = useState('same');
+    const [selectedConditions, setSelectedConditions] = useState<Record<string, string>>({});
+    const [selectedRelationship, setSelectedRelationship] = useState<RelationshipType>('same');
 
-    const relationshipTypes = [
+    const relationshipTypes: Array<{ value: RelationshipType; label: string; color: string }> = [
       { value: 'same', label: 'Same', color: 'text-green-400' },
       { value: 'subset', label: 'Subset', color: 'text-blue-400' },
       { value: 'mutually-exclusive', label: 'Mutually Exclusive', color: 'text-orange-400' },
@@ -199,9 +57,9 @@ const EcosystemMatcher = () => {
 
     // Initialize selected conditions for each market
     useEffect(() => {
-      const initialConditions = {};
-      selectedEcosystem?.marketData.forEach(market => {
-        const key = `${market.exchange}-${market.market}`;
+      const initialConditions: Record<string, string> = {};
+      selectedEcosystem?.marketRefs.forEach(marketRef => {
+        const key = `${marketRef.platform}-${marketRef.marketId}`;
         initialConditions[key] = '';
       });
       setSelectedConditions(initialConditions);
@@ -215,36 +73,45 @@ const EcosystemMatcher = () => {
         return;
       }
 
-      const newMapping = {
-        conditions: { ...selectedConditions },
-        relationship: selectedRelationship
+      const newMapping: ConditionMapping = {
+        id: `mapping-${Date.now()}`,
+        relationship: selectedRelationship,
+        confidence: 1.0,
+        createdAt: new Date(),
+        // Store all selected conditions in a format that matches our types
+        kalshiCondition: Object.entries(selectedConditions)
+          .filter(([key, value]) => key.startsWith('kalshi-') && value)
+          .map(([key, value]) => `${key}: ${value}`)
+          .join(', '),
+        polymarketCondition: Object.entries(selectedConditions)
+          .filter(([key, value]) => key.startsWith('polymarket-') && value)
+          .map(([key, value]) => `${key}: ${value}`)
+          .join(', '),
       };
       
       setMappings([...mappings, newMapping]);
       
       // Reset selections
-      const resetConditions = {};
+      const resetConditions: Record<string, string> = {};
       Object.keys(selectedConditions).forEach(key => {
         resetConditions[key] = '';
       });
       setSelectedConditions(resetConditions);
     };
 
-    const removeMapping = (index) => {
+    const removeMapping = (index: number) => {
       setMappings(mappings.filter((_, i) => i !== index));
     };
 
     const saveConditionMappings = () => {
-      setEcosystemHistory(ecosystemHistory.map(ecosystem => 
-        ecosystem.id === selectedEcosystem.id
-          ? { ...ecosystem, conditionMappings: mappings, conditionsMatched: mappings.length > 0 }
-          : ecosystem
-      ));
+      if (selectedEcosystem) {
+        updateEcosystemConditions(selectedEcosystem.id, mappings);
+      }
       setShowConditionMatcher(false);
       setSelectedEcosystem(null);
     };
 
-    const getRelationshipColor = (relationship) => {
+    const getRelationshipColor = (relationship: RelationshipType) => {
       const rel = relationshipTypes.find(r => r.value === relationship);
       return rel ? rel.color : 'text-gray-400';
     };
@@ -417,23 +284,23 @@ const EcosystemMatcher = () => {
     market.id.toLowerCase().includes(searchTermPoly.toLowerCase())
   );
 
-  const toggleMarketSelection = (market, exchange) => {
-    const marketWithExchange = { ...market, exchange };
-    const marketId = `${exchange}-${market.id}`;
+  const toggleMarketSelection = (market: CommonMarket, platform: Platform) => {
+    const marketWithPlatform = { market, platform };
+    const marketId = `${platform}-${market.id}`;
     
     setSelectedMarkets(prev => {
-      const isSelected = prev.some(m => `${m.exchange}-${m.id}` === marketId);
+      const isSelected = prev.some(m => `${m.platform}-${m.market.id}` === marketId);
       if (isSelected) {
-        return prev.filter(m => `${m.exchange}-${m.id}` !== marketId);
+        return prev.filter(m => `${m.platform}-${m.market.id}` !== marketId);
       } else {
-        return [...prev, marketWithExchange];
+        return [...prev, marketWithPlatform];
       }
     });
   };
 
-  const isMarketSelected = (market, exchange) => {
-    const marketId = `${exchange}-${market.id}`;
-    return selectedMarkets.some(m => `${m.exchange}-${m.id}` === marketId);
+  const isMarketSelected = (market: CommonMarket, platform: Platform) => {
+    const marketId = `${platform}-${market.id}`;
+    return selectedMarkets.some(m => `${m.platform}-${m.market.id}` === marketId);
   };
 
   const handleCreateEcosystem = () => {
@@ -442,30 +309,11 @@ const EcosystemMatcher = () => {
       return;
     }
     
-    const exchanges = new Set(selectedMarkets.map(m => m.exchange)).size;
-    const totalConditions = selectedMarkets.reduce((sum, m) => sum + m.conditions.length, 0);
+    const ecosystemName = `Ecosystem - ${new Date().toLocaleDateString()}`;
+    const newEcosystem = createEcosystem(ecosystemName, selectedMarkets);
     
-    // Create new ecosystem
-    const newEcosystem = {
-      id: Date.now(),
-      name: `New Ecosystem - ${new Date().toLocaleDateString()}`,
-      createdDate: new Date().toISOString().split('T')[0],
-      exchanges: exchanges,
-      markets: selectedMarkets.length,
-      conditions: totalConditions,
-      status: 'active',
-      conditionsMatched: false,
-      conditionMappings: [],
-      marketData: selectedMarkets.map(m => ({
-        exchange: m.exchange,
-        market: m.title,
-        conditions: m.conditions
-      }))
-    };
-    
-    setEcosystemHistory([newEcosystem, ...ecosystemHistory]);
     setSelectedMarkets([]);
-    alert(`Created ecosystem with ${selectedMarkets.length} markets from ${exchanges} exchange(s)`);
+    alert(`Created ecosystem "${newEcosystem.name}" with ${selectedMarkets.length} markets from ${newEcosystem.exchanges} exchange(s)`);
   };
 
   return (
@@ -479,6 +327,15 @@ const EcosystemMatcher = () => {
       </div>
 
       <div className="p-4">
+        {/* Error Display */}
+        {error && (
+          <div className="bg-red-900 bg-opacity-20 border border-red-600 rounded-lg p-3 mb-4">
+            <div className="text-red-300 text-sm">
+              <strong>Connection Error:</strong> {error}
+            </div>
+          </div>
+        )}
+
         {/* Tabs */}
         <div className="flex space-x-1 mb-4">
           <button
@@ -540,34 +397,45 @@ const EcosystemMatcher = () => {
                   </div>
                 </div>
                 <div className="space-y-2 max-h-96 overflow-y-auto">
-                  {filteredKalshiMarkets.map(market => (
-                    <div
-                      key={market.id}
-                      onClick={() => toggleMarketSelection(market, 'Kalshi')}
-                      className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
-                        isMarketSelected(market, 'Kalshi') ? 'ring-2 ring-blue-500 bg-gray-700' : ''
-                      }`}
-                    >
-                      <div className="flex items-start justify-between">
-                        <div className="flex-1">
-                          <div className="font-medium text-sm">{market.title}</div>
-                          <div className="text-xs text-gray-500 mt-1">
-                            {market.category} • ${(market.volume / 1000).toFixed(0)}k vol • {market.conditions.length} conditions
+                  {loading ? (
+                    <div className="text-center py-8 text-gray-500">
+                      <div className="animate-spin w-5 h-5 border-2 border-blue-400 border-t-transparent rounded-full mx-auto mb-2"></div>
+                      Loading Kalshi markets...
+                    </div>
+                  ) : filteredKalshiMarkets.length === 0 ? (
+                    <div className="text-center py-8 text-gray-500">
+                      No markets found
+                    </div>
+                  ) : (
+                    filteredKalshiMarkets.map(market => (
+                      <div
+                        key={market.id}
+                        onClick={() => toggleMarketSelection(market, 'kalshi')}
+                        className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
+                          isMarketSelected(market, 'kalshi') ? 'ring-2 ring-blue-500 bg-gray-700' : ''
+                        }`}
+                      >
+                        <div className="flex items-start justify-between">
+                          <div className="flex-1">
+                            <div className="font-medium text-sm">{market.title}</div>
+                            <div className="text-xs text-gray-500 mt-1">
+                              {market.category} • ${((market.volume || 0) / 1000).toFixed(0)}k vol • {market.outcomes.length} conditions
+                            </div>
+                            <div className="text-xs text-gray-600 mt-1">Closes {market.closeTime.toLocaleDateString()}</div>
+                          </div>
+                          <div className={`w-5 h-5 rounded border-2 flex items-center justify-center ml-2 ${
+                            isMarketSelected(market, 'kalshi') 
+                              ? 'bg-blue-500 border-blue-500' 
+                              : 'border-gray-600'
+                          }`}>
+                            {isMarketSelected(market, 'kalshi') && (
+                              <Check className="w-3 h-3 text-white" />
+                            )}
                           </div>
-                          <div className="text-xs text-gray-600 mt-1">Closes {market.closeDate}</div>
-                        </div>
-                        <div className={`w-5 h-5 rounded border-2 flex items-center justify-center ml-2 ${
-                          isMarketSelected(market, 'Kalshi') 
-                            ? 'bg-blue-500 border-blue-500' 
-                            : 'border-gray-600'
-                        }`}>
-                          {isMarketSelected(market, 'Kalshi') && (
-                            <Check className="w-3 h-3 text-white" />
-                          )}
                         </div>
                       </div>
-                    </div>
-                  ))}
+                    ))
+                  )}
                 </div>
               </div>
 
@@ -587,34 +455,45 @@ const EcosystemMatcher = () => {
                   </div>
                 </div>
                 <div className="space-y-2 max-h-96 overflow-y-auto">
-                  {filteredPolyMarkets.map(market => (
-                    <div
-                      key={market.id}
-                      onClick={() => toggleMarketSelection(market, 'Polymarket')}
-                      className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
-                        isMarketSelected(market, 'Polymarket') ? 'ring-2 ring-purple-500 bg-gray-700' : ''
-                      }`}
-                    >
-                      <div className="flex items-start justify-between">
-                        <div className="flex-1">
-                          <div className="font-medium text-sm">{market.title}</div>
-                          <div className="text-xs text-gray-500 mt-1">
-                            {market.category} • ${(market.volume / 1000).toFixed(0)}k vol • {market.conditions.length} conditions
+                  {loading ? (
+                    <div className="text-center py-8 text-gray-500">
+                      <div className="animate-spin w-5 h-5 border-2 border-purple-400 border-t-transparent rounded-full mx-auto mb-2"></div>
+                      Loading Polymarket markets...
+                    </div>
+                  ) : filteredPolyMarkets.length === 0 ? (
+                    <div className="text-center py-8 text-gray-500">
+                      No markets found
+                    </div>
+                  ) : (
+                    filteredPolyMarkets.map(market => (
+                      <div
+                        key={market.id}
+                        onClick={() => toggleMarketSelection(market, 'polymarket')}
+                        className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
+                          isMarketSelected(market, 'polymarket') ? 'ring-2 ring-purple-500 bg-gray-700' : ''
+                        }`}
+                      >
+                        <div className="flex items-start justify-between">
+                          <div className="flex-1">
+                            <div className="font-medium text-sm">{market.title}</div>
+                            <div className="text-xs text-gray-500 mt-1">
+                              {market.category} • ${((market.volume || 0) / 1000).toFixed(0)}k vol • {market.outcomes.length} conditions
+                            </div>
+                            <div className="text-xs text-gray-600 mt-1">Closes {market.closeTime.toLocaleDateString()}</div>
+                          </div>
+                          <div className={`w-5 h-5 rounded border-2 flex items-center justify-center ml-2 ${
+                            isMarketSelected(market, 'polymarket') 
+                              ? 'bg-purple-500 border-purple-500' 
+                              : 'border-gray-600'
+                          }`}>
+                            {isMarketSelected(market, 'polymarket') && (
+                              <Check className="w-3 h-3 text-white" />
+                            )}
                           </div>
-                          <div className="text-xs text-gray-600 mt-1">Closes {market.closeDate}</div>
-                        </div>
-                        <div className={`w-5 h-5 rounded border-2 flex items-center justify-center ml-2 ${
-                          isMarketSelected(market, 'Polymarket') 
-                            ? 'bg-purple-500 border-purple-500' 
-                            : 'border-gray-600'
-                        }`}>
-                          {isMarketSelected(market, 'Polymarket') && (
-                            <Check className="w-3 h-3 text-white" />
-                          )}
                         </div>
                       </div>
-                    </div>
-                  ))}
+                    ))
+                  )}
                 </div>
               </div>
             </div>
@@ -624,23 +503,23 @@ const EcosystemMatcher = () => {
               <div className="bg-gray-900 rounded-lg p-4">
                 <h3 className="text-sm font-semibold text-gray-400 mb-3">Selected Markets for Ecosystem</h3>
                 <div className="space-y-2">
-                  {selectedMarkets.map((market) => (
-                    <div key={`${market.exchange}-${market.id}`} className="flex items-center justify-between bg-gray-800 p-2 rounded">
+                  {selectedMarkets.map((selectedMarket) => (
+                    <div key={`${selectedMarket.platform}-${selectedMarket.market.id}`} className="flex items-center justify-between bg-gray-800 p-2 rounded">
                       <div className="flex items-center">
                         <span className={`px-2 py-1 rounded text-xs font-medium mr-3 ${
-                          market.exchange === 'Kalshi' 
+                          selectedMarket.platform === 'kalshi' 
                             ? 'bg-blue-900 text-blue-300' 
                             : 'bg-purple-900 text-purple-300'
                         }`}>
-                          {market.exchange}
+                          {selectedMarket.platform === 'kalshi' ? 'Kalshi' : 'Polymarket'}
                         </span>
                         <div>
-                          <div className="text-sm font-medium">{market.title}</div>
-                          <div className="text-xs text-gray-500">{market.conditions.length} conditions</div>
+                          <div className="text-sm font-medium">{selectedMarket.market.title}</div>
+                          <div className="text-xs text-gray-500">{selectedMarket.market.outcomes.length} conditions</div>
                         </div>
                       </div>
                       <button
-                        onClick={() => toggleMarketSelection(market, market.exchange)}
+                        onClick={() => toggleMarketSelection(selectedMarket.market, selectedMarket.platform)}
                         className="text-red-400 hover:text-red-300"
                       >
                         <X className="w-4 h-4" />
@@ -674,17 +553,13 @@ const EcosystemMatcher = () => {
                     <td className="p-3">
                       <div className="font-medium text-sm">{ecosystem.name}</div>
                     </td>
-                    <td className="p-3 text-sm">{ecosystem.createdDate}</td>
+                    <td className="p-3 text-sm">{ecosystem.createdAt.toLocaleDateString()}</td>
                     <td className="p-3 text-sm">{ecosystem.exchanges}</td>
                     <td className="p-3 text-sm">{ecosystem.markets}</td>
                     <td className="p-3 text-sm">{ecosystem.conditions}</td>
                     <td className="p-3">
-                      <span className={`inline-flex px-2 py-1 rounded text-xs font-medium ${
-                        ecosystem.status === 'active' 
-                          ? 'bg-green-900 text-green-300' 
-                          : 'bg-gray-700 text-gray-300'
-                      }`}>
-                        {ecosystem.status}
+                      <span className="inline-flex px-2 py-1 rounded text-xs font-medium bg-green-900 text-green-300">
+                        active
                       </span>
                     </td>
                     <td className="p-3">
diff --git a/src/hooks/useLiveOrderbooks.ts b/src/hooks/useLiveOrderbooks.ts
new file mode 100644
index 0000000..de11440
--- /dev/null
+++ b/src/hooks/useLiveOrderbooks.ts
@@ -0,0 +1,383 @@
+// Live data polling hook for markets and orderbooks
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { CommonMarket, PollingConfig } from '../api/types';
+import { fetchNormalizedKalshiMarkets } from '../api/kalshi';
+import { fetchNormalizedPolymarketMarkets } from '../api/polymarket';
+import { 
+  updateMarkets, 
+  getStore, 
+  subscribeToStore,
+  updateArbitrageOpportunities 
+} from '../state/matches-store';
+import { calculateArbitrageOpportunities } from '../lib/arbitrage';
+
+export interface PollingHookState {
+  loading: boolean;
+  error: string | null;
+  kalshiMarkets: CommonMarket[];
+  polymarketMarkets: CommonMarket[];
+  lastUpdated: Date | null;
+  connectionStatus: {
+    kalshi: boolean;
+    polymarket: boolean;
+  };
+}
+
+export interface PollingHookActions {
+  startPolling: () => void;
+  stopPolling: () => void;
+  forceRefresh: () => Promise<void>;
+  updateConfig: (config: Partial<PollingConfig>) => void;
+}
+
+/**
+ * Custom hook for live market data polling
+ */
+export function useLiveOrderbooks(): PollingHookState & PollingHookActions {
+  const [state, setState] = useState<PollingHookState>({
+    loading: false,
+    error: null,
+    kalshiMarkets: [],
+    polymarketMarkets: [],
+    lastUpdated: null,
+    connectionStatus: {
+      kalshi: false,
+      polymarket: false,
+    },
+  });
+
+  const intervalRef = useRef<{
+    kalshi?: NodeJS.Timeout;
+    polymarket?: NodeJS.Timeout;
+  }>({});
+
+  const isPollingRef = useRef(false);
+
+  // Get initial data from store
+  useEffect(() => {
+    const store = getStore();
+    setState(prev => ({
+      ...prev,
+      kalshiMarkets: store.markets.kalshi,
+      polymarketMarkets: store.markets.polymarket,
+      lastUpdated: store.markets.lastUpdated,
+    }));
+  }, []);
+
+  // Subscribe to store updates
+  useEffect(() => {
+    const unsubscribe = subscribeToStore((store) => {
+      setState(prev => ({
+        ...prev,
+        kalshiMarkets: store.markets.kalshi,
+        polymarketMarkets: store.markets.polymarket,
+        lastUpdated: store.markets.lastUpdated,
+      }));
+    });
+
+    return unsubscribe;
+  }, []);
+
+  /**
+   * Fetch Kalshi markets with error handling
+   */
+  const fetchKalshiData = useCallback(async (): Promise<CommonMarket[]> => {
+    try {
+      const response = await fetchNormalizedKalshiMarkets();
+      
+      if (response.success && response.data) {
+        setState(prev => ({
+          ...prev,
+          connectionStatus: { ...prev.connectionStatus, kalshi: true },
+          error: prev.error?.includes('Kalshi') ? null : prev.error,
+        }));
+        return response.data;
+      } else {
+        throw new Error(response.error || 'Failed to fetch Kalshi markets');
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      console.error('Kalshi polling error:', errorMessage);
+      
+      setState(prev => ({
+        ...prev,
+        connectionStatus: { ...prev.connectionStatus, kalshi: false },
+        error: `Kalshi: ${errorMessage}`,
+      }));
+      
+      return [];
+    }
+  }, []);
+
+  /**
+   * Fetch Polymarket markets with error handling
+   */
+  const fetchPolymarketData = useCallback(async (): Promise<CommonMarket[]> => {
+    try {
+      const response = await fetchNormalizedPolymarketMarkets();
+      
+      if (response.success && response.data) {
+        setState(prev => ({
+          ...prev,
+          connectionStatus: { ...prev.connectionStatus, polymarket: true },
+          error: prev.error?.includes('Polymarket') ? null : prev.error,
+        }));
+        return response.data;
+      } else {
+        throw new Error(response.error || 'Failed to fetch Polymarket markets');
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      console.error('Polymarket polling error:', errorMessage);
+      
+      setState(prev => ({
+        ...prev,
+        connectionStatus: { ...prev.connectionStatus, polymarket: false },
+        error: `Polymarket: ${errorMessage}`,
+      }));
+      
+      return [];
+    }
+  }, []);
+
+  /**
+   * Update arbitrage opportunities when market data changes
+   */
+  const updateArbitrage = useCallback((kalshi: CommonMarket[], polymarket: CommonMarket[]) => {
+    try {
+      const store = getStore();
+      const opportunities = calculateArbitrageOpportunities(
+        store.matches,
+        kalshi,
+        polymarket
+      );
+      updateArbitrageOpportunities(opportunities);
+    } catch (error) {
+      console.error('Error updating arbitrage opportunities:', error);
+    }
+  }, []);
+
+  /**
+   * Fetch and update market data
+   */
+  const refreshData = useCallback(async (source: 'kalshi' | 'polymarket' | 'both' = 'both') => {
+    setState(prev => ({ ...prev, loading: true }));
+
+    try {
+      const store = getStore();
+      let kalshiData = store.markets.kalshi;
+      let polymarketData = store.markets.polymarket;
+
+      if (source === 'kalshi' || source === 'both') {
+        kalshiData = await fetchKalshiData();
+      }
+
+      if (source === 'polymarket' || source === 'both') {
+        polymarketData = await fetchPolymarketData();
+      }
+
+      // Update store with new data
+      updateMarkets(kalshiData, polymarketData);
+
+      // Update arbitrage opportunities
+      updateArbitrage(kalshiData, polymarketData);
+
+      setState(prev => ({
+        ...prev,
+        loading: false,
+        lastUpdated: new Date(),
+      }));
+    } catch (error) {
+      console.error('Error refreshing data:', error);
+      setState(prev => ({
+        ...prev,
+        loading: false,
+        error: error instanceof Error ? error.message : 'Refresh failed',
+      }));
+    }
+  }, [fetchKalshiData, fetchPolymarketData, updateArbitrage]);
+
+  /**
+   * Start polling with configured intervals
+   */
+  const startPolling = useCallback(() => {
+    if (isPollingRef.current) return;
+
+    const store = getStore();
+    const config = store.polling;
+
+    if (!config.enabled) return;
+
+    isPollingRef.current = true;
+
+    // Initial fetch
+    refreshData();
+
+    // Set up Kalshi polling
+    intervalRef.current.kalshi = setInterval(() => {
+      if (isPollingRef.current) {
+        refreshData('kalshi');
+      }
+    }, config.kalshiInterval);
+
+    // Set up Polymarket polling (more frequent)
+    intervalRef.current.polymarket = setInterval(() => {
+      if (isPollingRef.current) {
+        refreshData('polymarket');
+      }
+    }, config.polymarketInterval);
+
+    console.log(`Started polling: Kalshi every ${config.kalshiInterval}ms, Polymarket every ${config.polymarketInterval}ms`);
+  }, [refreshData]);
+
+  /**
+   * Stop polling
+   */
+  const stopPolling = useCallback(() => {
+    isPollingRef.current = false;
+
+    if (intervalRef.current.kalshi) {
+      clearInterval(intervalRef.current.kalshi);
+      intervalRef.current.kalshi = undefined;
+    }
+
+    if (intervalRef.current.polymarket) {
+      clearInterval(intervalRef.current.polymarket);
+      intervalRef.current.polymarket = undefined;
+    }
+
+    console.log('Stopped polling');
+  }, []);
+
+  /**
+   * Force refresh all data
+   */
+  const forceRefresh = useCallback(async () => {
+    await refreshData('both');
+  }, [refreshData]);
+
+  /**
+   * Update polling configuration
+   */
+  const updateConfig = useCallback((newConfig: Partial<PollingConfig>) => {
+    const store = getStore();
+    const updatedConfig = { ...store.polling, ...newConfig };
+
+    // If polling is currently active, restart with new intervals
+    if (isPollingRef.current) {
+      stopPolling();
+      // Small delay to ensure cleanup
+      setTimeout(() => {
+        if (updatedConfig.enabled) {
+          startPolling();
+        }
+      }, 100);
+    }
+  }, [startPolling, stopPolling]);
+
+  // Auto-start polling on mount if enabled
+  useEffect(() => {
+    const store = getStore();
+    if (store.polling.enabled) {
+      startPolling();
+    }
+
+    // Cleanup on unmount
+    return () => {
+      stopPolling();
+    };
+  }, [startPolling, stopPolling]);
+
+  // Handle visibility change to pause/resume polling
+  useEffect(() => {
+    const handleVisibilityChange = () => {
+      if (document.hidden) {
+        // Page is hidden, stop polling
+        stopPolling();
+      } else {
+        // Page is visible again, restart polling
+        const store = getStore();
+        if (store.polling.enabled) {
+          startPolling();
+        }
+      }
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    return () => {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    };
+  }, [startPolling, stopPolling]);
+
+  return {
+    ...state,
+    startPolling,
+    stopPolling,
+    forceRefresh,
+    updateConfig,
+  };
+}
+
+/**
+ * Hook for component-specific market data with optional filtering
+ */
+export function useMarketData(filters?: {
+  platform?: 'kalshi' | 'polymarket';
+  category?: string;
+  search?: string;
+}) {
+  const { kalshiMarkets, polymarketMarkets, loading, error, lastUpdated } = useLiveOrderbooks();
+
+  const filteredMarkets = useCallback(() => {
+    let markets: CommonMarket[] = [];
+
+    if (!filters?.platform || filters.platform === 'kalshi') {
+      markets.push(...kalshiMarkets);
+    }
+    if (!filters?.platform || filters.platform === 'polymarket') {
+      markets.push(...polymarketMarkets);
+    }
+
+    // Apply category filter
+    if (filters?.category) {
+      markets = markets.filter(market => 
+        market.category.toLowerCase().includes(filters.category!.toLowerCase())
+      );
+    }
+
+    // Apply search filter
+    if (filters?.search) {
+      const searchTerm = filters.search.toLowerCase();
+      markets = markets.filter(market =>
+        market.title.toLowerCase().includes(searchTerm) ||
+        market.category.toLowerCase().includes(searchTerm) ||
+        market.id.toLowerCase().includes(searchTerm)
+      );
+    }
+
+    return markets;
+  }, [kalshiMarkets, polymarketMarkets, filters]);
+
+  return {
+    markets: filteredMarkets(),
+    kalshiMarkets,
+    polymarketMarkets,
+    loading,
+    error,
+    lastUpdated,
+  };
+}
+
+/**
+ * TODO: Future enhancement - SSE (Server-Sent Events) support
+ * This hook can be extended to accept an SSE endpoint for real-time updates
+ * following the pattern mentioned in dashboard.js requirements
+ */
+export function useSSEOrderbooks(sseEndpoint?: string) {
+  // TODO: Implement SSE connection for real-time price updates
+  // This would supplement the polling approach with push notifications
+  // when price changes occur, reducing latency for arbitrage detection
+  
+  console.warn('SSE support not yet implemented - using polling fallback');
+  return useLiveOrderbooks();
+}
\ No newline at end of file
diff --git a/src/lib/arbitrage.ts b/src/lib/arbitrage.ts
new file mode 100644
index 0000000..63b2ac1
--- /dev/null
+++ b/src/lib/arbitrage.ts
@@ -0,0 +1,383 @@
+// Arbitrage detection and APR calculation utilities
+import {
+  ArbitrageOpportunity,
+  CommonMarket,
+  MarketMatch,
+  ConditionMapping,
+  Platform
+} from '../api/types';
+
+/**
+ * Calculate arbitrage opportunities from matched markets with 'same' condition mappings
+ * 
+ * Formula per PredictionMarketArb.txt:
+ * - C = minYes + minNo (total cost to guarantee win)
+ * - If C < 1, arbitrage exists
+ * - periodReturn = (1 - C) / C (assumed interpretation of ambiguous formula)
+ * - APR = periodReturn * (365 / D) where D = days until earliest end time
+ */
+export function calculateArbitrageOpportunities(
+  matches: MarketMatch[],
+  kalshiMarkets: CommonMarket[],
+  polymarketMarkets: CommonMarket[]
+): ArbitrageOpportunity[] {
+  const opportunities: ArbitrageOpportunity[] = [];
+
+  for (const match of matches) {
+    // Only process matches with at least one 'same' condition mapping
+    const sameConditionMappings = match.conditionMappings.filter(
+      mapping => mapping.relationship === 'same'
+    );
+
+    if (sameConditionMappings.length === 0) {
+      continue;
+    }
+
+    // Get the matched markets
+    const kalshiMarket = kalshiMarkets.find(m => m.id === match.kalshiMarketId);
+    const polymarketMarket = polymarketMarkets.find(m => m.id === match.polymarketMarketId);
+
+    if (!kalshiMarket || !polymarketMarket) {
+      continue;
+    }
+
+    // Process each 'same' condition mapping
+    for (const mapping of sameConditionMappings) {
+      const opportunity = calculateConditionArbitrage(
+        mapping,
+        kalshiMarket,
+        polymarketMarket,
+        match
+      );
+
+      if (opportunity) {
+        opportunities.push(opportunity);
+      }
+    }
+  }
+
+  return opportunities.sort((a, b) => b.apr - a.apr); // Sort by APR descending
+}
+
+/**
+ * Calculate arbitrage for a specific condition mapping
+ */
+function calculateConditionArbitrage(
+  mapping: ConditionMapping,
+  kalshiMarket: CommonMarket,
+  polymarketMarket: CommonMarket,
+  match: MarketMatch
+): ArbitrageOpportunity | null {
+  if (!mapping.kalshiCondition || !mapping.polymarketCondition) {
+    return null;
+  }
+
+  // Find the conditions in each market
+  const kalshiCondition = kalshiMarket.outcomes.find(
+    c => c.name === mapping.kalshiCondition
+  );
+  const polymarketCondition = polymarketMarket.outcomes.find(
+    c => c.name === mapping.polymarketCondition
+  );
+
+  if (!kalshiCondition || !polymarketCondition) {
+    return null;
+  }
+
+  // Get prices for YES and NO across both exchanges
+  const kalshiYesAsk = kalshiCondition.yesPrice;
+  const kalshiNoAsk = kalshiCondition.noPrice;
+  const polymarketYesAsk = polymarketCondition.yesPrice;
+  const polymarketNoAsk = polymarketCondition.noPrice;
+
+  // Find minimum costs to buy YES and NO
+  const yesPrices = [kalshiYesAsk, polymarketYesAsk].filter(p => p !== undefined && p > 0);
+  const noPrices = [kalshiNoAsk, polymarketNoAsk].filter(p => p !== undefined && p > 0);
+
+  if (yesPrices.length === 0 || noPrices.length === 0) {
+    return null;
+  }
+
+  const minYes = Math.min(...yesPrices);
+  const minNo = Math.min(...noPrices);
+
+  // Calculate arbitrage
+  const C = minYes + minNo;
+
+  // Only proceed if arbitrage exists (C < 1)
+  if (C >= 1) {
+    return null;
+  }
+
+  // Calculate returns
+  // Note: PredictionMarketArb.txt shows "rPeriod = 1 - C / C" which simplifies to 0
+  // Assuming intended formula is (1 - C) / C based on standard arbitrage calculations
+  const periodReturn = (1 - C) / C;
+
+  // Calculate days until earliest end time
+  const earliestEndTime = new Date(Math.min(
+    kalshiMarket.closeTime.getTime(),
+    polymarketMarket.closeTime.getTime()
+  ));
+  const daysUntilClose = Math.max(1, Math.ceil(
+    (earliestEndTime.getTime() - Date.now()) / (1000 * 60 * 60 * 24)
+  ));
+
+  // Calculate APR
+  const apr = periodReturn * (365 / daysUntilClose);
+  const profitOn100 = 100 * periodReturn;
+
+  // Determine which exchange offers the best prices
+  const yesBet = minYes === kalshiYesAsk ? {
+    platform: 'kalshi' as Platform,
+    marketId: kalshiMarket.id,
+    condition: mapping.kalshiCondition,
+    price: minYes,
+  } : {
+    platform: 'polymarket' as Platform,
+    marketId: polymarketMarket.id,
+    condition: mapping.polymarketCondition,
+    price: minYes,
+  };
+
+  const noBet = minNo === kalshiNoAsk ? {
+    platform: 'kalshi' as Platform,
+    marketId: kalshiMarket.id,
+    condition: mapping.kalshiCondition,
+    price: minNo,
+  } : {
+    platform: 'polymarket' as Platform,
+    marketId: polymarketMarket.id,
+    condition: mapping.polymarketCondition,
+    price: minNo,
+  };
+
+  // Collect all underlying conditions for expanded view
+  const allConditions = [
+    {
+      platform: 'kalshi' as Platform,
+      marketId: kalshiMarket.id,
+      condition: mapping.kalshiCondition,
+      yesPrice: kalshiYesAsk,
+      noPrice: kalshiNoAsk,
+    },
+    {
+      platform: 'polymarket' as Platform,
+      marketId: polymarketMarket.id,
+      condition: mapping.polymarketCondition,
+      yesPrice: polymarketYesAsk,
+      noPrice: polymarketNoAsk,
+    },
+  ];
+
+  return {
+    id: `${match.id}-${mapping.id}`,
+    eventName: kalshiMarket.title || polymarketMarket.title,
+    eventType: `${kalshiMarket.category} | ${polymarketMarket.category}`,
+    market: mapping.kalshiCondition,
+    earliestEndTime,
+    daysUntilClose,
+    minYes,
+    minNo,
+    C,
+    periodReturn,
+    apr,
+    profitOn100,
+    yesBet,
+    noBet,
+    updatedAt: new Date(),
+    allConditions,
+  };
+}
+
+/**
+ * Update arbitrage opportunities with new price data
+ * Efficiently recalculates only when underlying prices change
+ */
+export function updateArbitrageOpportunities(
+  existingOpportunities: ArbitrageOpportunity[],
+  updatedKalshiMarkets: CommonMarket[],
+  updatedPolymarketMarkets: CommonMarket[]
+): ArbitrageOpportunity[] {
+  return existingOpportunities.map(opportunity => {
+    // Find updated market data
+    const kalshiMarket = updatedKalshiMarkets.find(m => 
+      m.id === opportunity.yesBet.marketId || m.id === opportunity.noBet.marketId
+    );
+    const polymarketMarket = updatedPolymarketMarkets.find(m => 
+      m.id === opportunity.yesBet.marketId || m.id === opportunity.noBet.marketId
+    );
+
+    if (!kalshiMarket || !polymarketMarket) {
+      return opportunity; // Return unchanged if markets not found
+    }
+
+    // Get updated condition prices
+    const kalshiCondition = kalshiMarket.outcomes.find(c => 
+      c.name === opportunity.allConditions.find(ac => ac.platform === 'kalshi')?.condition
+    );
+    const polymarketCondition = polymarketMarket.outcomes.find(c => 
+      c.name === opportunity.allConditions.find(ac => ac.platform === 'polymarket')?.condition
+    );
+
+    if (!kalshiCondition || !polymarketCondition) {
+      return opportunity;
+    }
+
+    // Check if prices have changed
+    const kalshiConditionData = opportunity.allConditions.find(ac => ac.platform === 'kalshi');
+    const polymarketConditionData = opportunity.allConditions.find(ac => ac.platform === 'polymarket');
+
+    const pricesChanged = 
+      kalshiCondition.yesPrice !== kalshiConditionData?.yesPrice ||
+      kalshiCondition.noPrice !== kalshiConditionData?.noPrice ||
+      polymarketCondition.yesPrice !== polymarketConditionData?.yesPrice ||
+      polymarketCondition.noPrice !== polymarketConditionData?.noPrice;
+
+    if (!pricesChanged) {
+      return opportunity; // No price changes, return as-is
+    }
+
+    // Recalculate with new prices
+    const yesPrices = [kalshiCondition.yesPrice, polymarketCondition.yesPrice]
+      .filter(p => p !== undefined && p > 0);
+    const noPrices = [kalshiCondition.noPrice, polymarketCondition.noPrice]
+      .filter(p => p !== undefined && p > 0);
+
+    if (yesPrices.length === 0 || noPrices.length === 0) {
+      return opportunity; // Can't calculate, return as-is
+    }
+
+    const minYes = Math.min(...yesPrices);
+    const minNo = Math.min(...noPrices);
+    const C = minYes + minNo;
+
+    // If no longer an arbitrage opportunity, mark for removal by setting APR to 0
+    if (C >= 1) {
+      return {
+        ...opportunity,
+        minYes,
+        minNo,
+        C,
+        periodReturn: 0,
+        apr: 0,
+        profitOn100: 0,
+        updatedAt: new Date(),
+      };
+    }
+
+    const periodReturn = (1 - C) / C;
+    const apr = periodReturn * (365 / opportunity.daysUntilClose);
+    const profitOn100 = 100 * periodReturn;
+
+    // Update bet information
+    const yesBet = minYes === kalshiCondition.yesPrice ? {
+      platform: 'kalshi' as Platform,
+      marketId: kalshiMarket.id,
+      condition: kalshiCondition.name,
+      price: minYes,
+    } : {
+      platform: 'polymarket' as Platform,
+      marketId: polymarketMarket.id,
+      condition: polymarketCondition.name,
+      price: minYes,
+    };
+
+    const noBet = minNo === kalshiCondition.noPrice ? {
+      platform: 'kalshi' as Platform,
+      marketId: kalshiMarket.id,
+      condition: kalshiCondition.name,
+      price: minNo,
+    } : {
+      platform: 'polymarket' as Platform,
+      marketId: polymarketMarket.id,
+      condition: polymarketCondition.name,
+      price: minNo,
+    };
+
+    // Update all conditions data
+    const allConditions = [
+      {
+        platform: 'kalshi' as Platform,
+        marketId: kalshiMarket.id,
+        condition: kalshiCondition.name,
+        yesPrice: kalshiCondition.yesPrice,
+        noPrice: kalshiCondition.noPrice,
+      },
+      {
+        platform: 'polymarket' as Platform,
+        marketId: polymarketMarket.id,
+        condition: polymarketCondition.name,
+        yesPrice: polymarketCondition.yesPrice,
+        noPrice: polymarketCondition.noPrice,
+      },
+    ];
+
+    return {
+      ...opportunity,
+      minYes,
+      minNo,
+      C,
+      periodReturn,
+      apr,
+      profitOn100,
+      yesBet,
+      noBet,
+      updatedAt: new Date(),
+      allConditions,
+    };
+  }).filter(opp => opp.apr > 0); // Remove opportunities that are no longer profitable
+}
+
+/**
+ * Calculate portfolio-level arbitrage metrics
+ */
+export function calculatePortfolioMetrics(opportunities: ArbitrageOpportunity[]) {
+  if (opportunities.length === 0) {
+    return {
+      totalOpportunities: 0,
+      averageAPR: 0,
+      totalProfitOn100: 0,
+      bestAPR: 0,
+      averageDaysToExpiry: 0,
+    };
+  }
+
+  const totalAPR = opportunities.reduce((sum, opp) => sum + opp.apr, 0);
+  const totalProfit = opportunities.reduce((sum, opp) => sum + opp.profitOn100, 0);
+  const totalDays = opportunities.reduce((sum, opp) => sum + opp.daysUntilClose, 0);
+
+  return {
+    totalOpportunities: opportunities.length,
+    averageAPR: totalAPR / opportunities.length,
+    totalProfitOn100: totalProfit,
+    bestAPR: Math.max(...opportunities.map(opp => opp.apr)),
+    averageDaysToExpiry: totalDays / opportunities.length,
+  };
+}
+
+/**
+ * Filter arbitrage opportunities by criteria
+ */
+export function filterArbitrageOpportunities(
+  opportunities: ArbitrageOpportunity[],
+  filters: {
+    minAPR?: number;
+    maxDaysToExpiry?: number;
+    minProfitOn100?: number;
+    categories?: string[];
+  }
+): ArbitrageOpportunity[] {
+  return opportunities.filter(opp => {
+    if (filters.minAPR && opp.apr < filters.minAPR) return false;
+    if (filters.maxDaysToExpiry && opp.daysUntilClose > filters.maxDaysToExpiry) return false;
+    if (filters.minProfitOn100 && opp.profitOn100 < filters.minProfitOn100) return false;
+    if (filters.categories && filters.categories.length > 0) {
+      const categoryMatch = filters.categories.some(cat => 
+        opp.eventType.toLowerCase().includes(cat.toLowerCase())
+      );
+      if (!categoryMatch) return false;
+    }
+    return true;
+  });
+}
\ No newline at end of file
diff --git a/src/lib/matching.ts b/src/lib/matching.ts
new file mode 100644
index 0000000..e98cee4
--- /dev/null
+++ b/src/lib/matching.ts
@@ -0,0 +1,412 @@
+// Market matching utilities with fuzzy similarity and condition matching
+import {
+  CommonMarket,
+  SimilarityScore,
+  MarketMatch,
+  ConditionMapping,
+  RelationshipType
+} from '../api/types';
+
+/**
+ * Calculate similarity score between two markets
+ * Uses title token overlap, category match, close date proximity, and condition count similarity
+ */
+export function calculateSimilarity(market1: CommonMarket, market2: CommonMarket): SimilarityScore {
+  // Title similarity using token overlap
+  const titleSimilarity = calculateTitleSimilarity(market1.title, market2.title);
+  
+  // Category similarity
+  const categorySimilarity = calculateCategorySimilarity(market1.category, market2.category);
+  
+  // Close date proximity (exact date = 1, else decays)
+  const dateSimilarity = calculateDateSimilarity(market1.closeTime, market2.closeTime);
+  
+  // Condition count similarity
+  const conditionSimilarity = calculateConditionCountSimilarity(
+    market1.outcomes.length,
+    market2.outcomes.length
+  );
+
+  // Settlement source similarity
+  const settlementSimilarity = calculateSettlementSimilarity(
+    market1.settlementSource,
+    market2.settlementSource
+  );
+
+  // Weighted overall score
+  const overall = (
+    titleSimilarity * 0.4 +
+    dateSimilarity * 0.3 +
+    conditionSimilarity * 0.2 +
+    categorySimilarity * 0.05 +
+    settlementSimilarity * 0.05
+  );
+
+  return {
+    overall,
+    title: titleSimilarity,
+    date: dateSimilarity,
+    conditions: conditionSimilarity,
+    settlement: settlementSimilarity,
+  };
+}
+
+/**
+ * Calculate title similarity using token overlap
+ */
+function calculateTitleSimilarity(title1: string, title2: string): number {
+  // Normalize titles: lowercase, remove punctuation, split into tokens
+  const normalize = (title: string): string[] => {
+    return title
+      .toLowerCase()
+      .replace(/[^\w\s]/g, ' ')
+      .split(/\s+/)
+      .filter(token => token.length > 2) // Filter out short words
+      .filter(token => !['the', 'and', 'or', 'in', 'on', 'at', 'to', 'for', 'of', 'with'].includes(token));
+  };
+
+  const tokens1 = normalize(title1);
+  const tokens2 = normalize(title2);
+
+  if (tokens1.length === 0 || tokens2.length === 0) {
+    return 0;
+  }
+
+  // Calculate Jaccard similarity (intersection over union)
+  const intersection = tokens1.filter(token => tokens2.includes(token));
+  const union = [...new Set([...tokens1, ...tokens2])];
+
+  return intersection.length / union.length;
+}
+
+/**
+ * Calculate category similarity
+ */
+function calculateCategorySimilarity(category1: string, category2: string): number {
+  if (!category1 || !category2) return 0;
+
+  const cat1 = category1.toLowerCase().trim();
+  const cat2 = category2.toLowerCase().trim();
+
+  if (cat1 === cat2) return 1;
+
+  // Check for partial matches (e.g., "Politics" vs "Political")
+  if (cat1.includes(cat2) || cat2.includes(cat1)) return 0.8;
+
+  // Check for related categories
+  const categoryMappings: Record<string, string[]> = {
+    'politics': ['political', 'election', 'government'],
+    'economics': ['economic', 'finance', 'financial', 'fed', 'monetary'],
+    'sports': ['sport', 'athletic', 'baseball', 'football', 'basketball'],
+    'technology': ['tech', 'ai', 'crypto', 'cryptocurrency', 'bitcoin'],
+  };
+
+  for (const [mainCat, related] of Object.entries(categoryMappings)) {
+    if ((cat1 === mainCat && related.includes(cat2)) ||
+        (cat2 === mainCat && related.includes(cat1)) ||
+        (related.includes(cat1) && related.includes(cat2))) {
+      return 0.6;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Calculate date similarity with proximity decay
+ */
+function calculateDateSimilarity(date1: Date, date2: Date): number {
+  const diffDays = Math.abs(date1.getTime() - date2.getTime()) / (1000 * 60 * 60 * 24);
+  
+  if (diffDays === 0) return 1; // Exact match
+  if (diffDays <= 1) return 0.9; // Within 1 day
+  if (diffDays <= 7) return 0.7; // Within 1 week
+  if (diffDays <= 30) return 0.5; // Within 1 month
+  if (diffDays <= 90) return 0.2; // Within 3 months
+  
+  return 0; // Too far apart
+}
+
+/**
+ * Calculate condition count similarity
+ */
+function calculateConditionCountSimilarity(count1: number, count2: number): number {
+  if (count1 === count2) return 1;
+  
+  const diff = Math.abs(count1 - count2);
+  const maxCount = Math.max(count1, count2);
+  
+  return Math.max(0, 1 - (diff / maxCount));
+}
+
+/**
+ * Calculate settlement source similarity
+ */
+function calculateSettlementSimilarity(source1?: string, source2?: string): number {
+  if (!source1 || !source2) return 0.5; // Default when unknown
+
+  const s1 = source1.toLowerCase().trim();
+  const s2 = source2.toLowerCase().trim();
+
+  if (s1 === s2) return 1;
+
+  // Check for known equivalent sources
+  const equivalents = [
+    ['associated press', 'ap', 'ap news'],
+    ['reuters', 'reuters news'],
+    ['cnn', 'cnn news'],
+    ['federal reserve', 'fed', 'fomc'],
+    ['sec', 'securities and exchange commission'],
+  ];
+
+  for (const group of equivalents) {
+    if (group.includes(s1) && group.includes(s2)) {
+      return 1;
+    }
+  }
+
+  // Partial string matching
+  if (s1.includes(s2) || s2.includes(s1)) {
+    return 0.8;
+  }
+
+  return 0;
+}
+
+/**
+ * Find potential market matches using similarity scoring
+ */
+export function findPotentialMatches(
+  kalshiMarkets: CommonMarket[],
+  polymarketMarkets: CommonMarket[],
+  minSimilarity = 0.6
+): Array<{
+  kalshi: CommonMarket;
+  polymarket: CommonMarket;
+  similarity: SimilarityScore;
+}> {
+  const potentialMatches: Array<{
+    kalshi: CommonMarket;
+    polymarket: CommonMarket;
+    similarity: SimilarityScore;
+  }> = [];
+
+  for (const kalshiMarket of kalshiMarkets) {
+    for (const polymarketMarket of polymarketMarkets) {
+      const similarity = calculateSimilarity(kalshiMarket, polymarketMarket);
+      
+      if (similarity.overall >= minSimilarity) {
+        potentialMatches.push({
+          kalshi: kalshiMarket,
+          polymarket: polymarketMarket,
+          similarity,
+        });
+      }
+    }
+  }
+
+  // Sort by similarity score descending
+  return potentialMatches.sort((a, b) => b.similarity.overall - a.similarity.overall);
+}
+
+/**
+ * Suggest condition mappings between markets
+ */
+export function suggestConditionMappings(
+  kalshiMarket: CommonMarket,
+  polymarketMarket: CommonMarket
+): ConditionMapping[] {
+  const suggestions: ConditionMapping[] = [];
+
+  for (const kalshiCondition of kalshiMarket.outcomes) {
+    for (const polymarketCondition of polymarketMarket.outcomes) {
+      const similarity = calculateConditionSimilarity(
+        kalshiCondition.name,
+        polymarketCondition.name
+      );
+
+      if (similarity.score >= 0.7) {
+        suggestions.push({
+          id: `${kalshiCondition.id}-${polymarketCondition.id}`,
+          kalshiCondition: kalshiCondition.name,
+          polymarketCondition: polymarketCondition.name,
+          relationship: similarity.relationship,
+          confidence: similarity.score,
+          createdAt: new Date(),
+        });
+      }
+    }
+  }
+
+  return suggestions.sort((a, b) => (b.confidence || 0) - (a.confidence || 0));
+}
+
+/**
+ * Calculate similarity between individual conditions
+ */
+function calculateConditionSimilarity(
+  condition1: string,
+  condition2: string
+): { score: number; relationship: RelationshipType } {
+  const c1 = condition1.toLowerCase().trim();
+  const c2 = condition2.toLowerCase().trim();
+
+  // Exact match
+  if (c1 === c2) {
+    return { score: 1, relationship: 'same' };
+  }
+
+  // Check for obvious same conditions with different formatting
+  const normalizeCondition = (cond: string): string => {
+    return cond
+      .replace(/[^\w\s]/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+  };
+
+  const norm1 = normalizeCondition(c1);
+  const norm2 = normalizeCondition(c2);
+
+  if (norm1 === norm2) {
+    return { score: 0.95, relationship: 'same' };
+  }
+
+  // Check for opposites
+  const opposites = [
+    ['yes', 'no'],
+    ['true', 'false'],
+    ['pass', 'fail'],
+    ['win', 'lose'],
+    ['increase', 'decrease'],
+    ['above', 'below'],
+    ['over', 'under'],
+    ['higher', 'lower'],
+    ['up', 'down'],
+  ];
+
+  for (const [opp1, opp2] of opposites) {
+    if ((c1.includes(opp1) && c2.includes(opp2)) || 
+        (c1.includes(opp2) && c2.includes(opp1))) {
+      return { score: 0.9, relationship: 'opposites' };
+    }
+  }
+
+  // Check for containment (subset relationship)
+  if (c1.includes(c2) || c2.includes(c1)) {
+    return { score: 0.8, relationship: 'subset' };
+  }
+
+  // Token-based similarity for more complex matching
+  const tokens1 = norm1.split(' ').filter(t => t.length > 1);
+  const tokens2 = norm2.split(' ').filter(t => t.length > 1);
+
+  const commonTokens = tokens1.filter(token => tokens2.includes(token));
+  const tokenSimilarity = commonTokens.length / Math.max(tokens1.length, tokens2.length);
+
+  if (tokenSimilarity >= 0.7) {
+    return { score: tokenSimilarity, relationship: 'same' };
+  } else if (tokenSimilarity >= 0.5) {
+    return { score: tokenSimilarity, relationship: 'overlapping' };
+  } else if (tokenSimilarity >= 0.3) {
+    return { score: tokenSimilarity, relationship: 'complementary' };
+  }
+
+  return { score: 0, relationship: 'mutually-exclusive' };
+}
+
+/**
+ * Validate a market match for quality and consistency
+ */
+export function validateMarketMatch(
+  kalshiMarket: CommonMarket,
+  polymarketMarket: CommonMarket,
+  conditionMappings: ConditionMapping[]
+): { valid: boolean; issues: string[] } {
+  const issues: string[] = [];
+
+  // Check date consistency
+  const dateDiff = Math.abs(
+    kalshiMarket.closeTime.getTime() - polymarketMarket.closeTime.getTime()
+  ) / (1000 * 60 * 60 * 24);
+
+  if (dateDiff > 7) {
+    issues.push(`Close dates differ by ${Math.round(dateDiff)} days`);
+  }
+
+  // Check if we have any 'same' mappings for arbitrage potential
+  const sameMappings = conditionMappings.filter(m => m.relationship === 'same');
+  if (sameMappings.length === 0) {
+    issues.push('No "same" condition mappings found - no arbitrage potential');
+  }
+
+  // Check for conflicting mappings
+  const kalshiConditionUsage = new Map<string, number>();
+  const polymarketConditionUsage = new Map<string, number>();
+
+  conditionMappings.forEach(mapping => {
+    if (mapping.kalshiCondition) {
+      kalshiConditionUsage.set(
+        mapping.kalshiCondition,
+        (kalshiConditionUsage.get(mapping.kalshiCondition) || 0) + 1
+      );
+    }
+    if (mapping.polymarketCondition) {
+      polymarketConditionUsage.set(
+        mapping.polymarketCondition,
+        (polymarketConditionUsage.get(mapping.polymarketCondition) || 0) + 1
+      );
+    }
+  });
+
+  // Check for over-used conditions
+  kalshiConditionUsage.forEach((count, condition) => {
+    if (count > 1) {
+      issues.push(`Kalshi condition "${condition}" mapped multiple times`);
+    }
+  });
+
+  polymarketConditionUsage.forEach((count, condition) => {
+    if (count > 1) {
+      issues.push(`Polymarket condition "${condition}" mapped multiple times`);
+    }
+  });
+
+  // Check category compatibility
+  if (kalshiMarket.category !== polymarketMarket.category) {
+    const catSimilarity = calculateCategorySimilarity(
+      kalshiMarket.category,
+      polymarketMarket.category
+    );
+    if (catSimilarity < 0.6) {
+      issues.push(`Categories seem incompatible: ${kalshiMarket.category} vs ${polymarketMarket.category}`);
+    }
+  }
+
+  return {
+    valid: issues.length === 0,
+    issues,
+  };
+}
+
+/**
+ * Create a market match object
+ */
+export function createMarketMatch(
+  kalshiMarket: CommonMarket,
+  polymarketMarket: CommonMarket,
+  conditionMappings: ConditionMapping[] = [],
+  confidence?: number
+): MarketMatch {
+  const similarity = calculateSimilarity(kalshiMarket, polymarketMarket);
+  
+  return {
+    id: `${kalshiMarket.id}-${polymarketMarket.id}-${Date.now()}`,
+    kalshiMarketId: kalshiMarket.id,
+    polymarketMarketId: polymarketMarket.id,
+    createdAt: new Date(),
+    confidence: confidence || similarity.overall,
+    conditionMappings,
+    conditionsMatched: conditionMappings.length > 0,
+    totalVolume: (kalshiMarket.volume || 0) + (polymarketMarket.volume || 0),
+  };
+}
\ No newline at end of file
diff --git a/src/market-matcher-component.tsx b/src/market-matcher-component.tsx
index afa6569..33391eb 100644
--- a/src/market-matcher-component.tsx
+++ b/src/market-matcher-component.tsx
@@ -1,266 +1,131 @@
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import { Search, RefreshCw, AlertCircle, Link, Check, X, Edit2, CheckCircle, XCircle } from 'lucide-react';
+import { useMarketData } from './hooks/useLiveOrderbooks';
+import { 
+  getStore, 
+  subscribeToStore, 
+  addMarketMatch, 
+  updateMatchConditions 
+} from './state/matches-store';
+import { 
+  calculateSimilarity, 
+  suggestConditionMappings, 
+  createMarketMatch,
+  validateMarketMatch 
+} from './lib/matching';
+import { 
+  CommonMarket, 
+  MarketMatch, 
+  ConditionMapping, 
+  RelationshipType 
+} from './api/types';
 
 const MarketMatcher = () => {
   const [activeTab, setActiveTab] = useState('manual');
   const [filterVenue, setFilterVenue] = useState('all');
   const [searchTermKalshi, setSearchTermKalshi] = useState('');
   const [searchTermPoly, setSearchTermPoly] = useState('');
-  const [selectedMarkets, setSelectedMarkets] = useState({ kalshi: null, polymarket: null });
+  const [selectedMarkets, setSelectedMarkets] = useState<{ kalshi: CommonMarket | null; polymarket: CommonMarket | null }>({ kalshi: null, polymarket: null });
   const [showRulesComparison, setShowRulesComparison] = useState(false);
   const [showConditionMatcher, setShowConditionMatcher] = useState(false);
-  const [selectedMatch, setSelectedMatch] = useState(null);
+  const [selectedMatch, setSelectedMatch] = useState<MarketMatch | null>(null);
   const [isProcessing, setIsProcessing] = useState(false);
+  const [matchHistory, setMatchHistory] = useState<MarketMatch[]>([]);
 
-  // Mock data with multiple conditions
-  const [unmatchedKalshiMarkets] = useState([
-    {
-      id: 'ELECTION-2028-WINNER',
-      title: 'Presidential Election Winner 2028',
-      category: 'Politics',
-      volume: 6000000,
-      liquidity: 450000,
-      closeDate: '2028-11-05',
-      settlementSource: 'Associated Press',
-      rules: 'Market resolves to the candidate declared winner by the Associated Press',
-      conditions: [
-        { name: 'JD Vance', yesPrice: 0.28, noPrice: 0.72, volume: 501296 },
-        { name: 'Gavin Newsom', yesPrice: 0.13, noPrice: 0.87, volume: 363835 },
-        { name: 'Alexandria Ocasio-Cortez', yesPrice: 0.09, noPrice: 0.91, volume: 218268 },
-        { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93, volume: 139748 },
-        { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94, volume: 128925 },
-        { name: 'Andy Beshear', yesPrice: 0.05, noPrice: 0.95, volume: 292807 },
-        { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96, volume: 298604 }
-      ]
-    },
-    {
-      id: 'FED-SEPT-2025',
-      title: 'Fed decision in September?',
-      category: 'Economics',
-      volume: 450000,
-      liquidity: 120000,
-      closeDate: '2025-09-18',
-      settlementSource: 'Federal Reserve announcement',
-      rules: 'Resolves based on Federal Reserve rate decision at September FOMC meeting',
-      conditions: [
-        { name: '25 bps decrease', yesPrice: 0.80, noPrice: 0.20, volume: 150000 },
-        { name: 'No change', yesPrice: 0.15, noPrice: 0.85, volume: 180000 },
-        { name: '25+ bps increase', yesPrice: 0.01, noPrice: 0.99, volume: 50000 }
-      ]
-    },
-    {
-      id: 'TRUMP-MEETING-AUG',
-      title: 'Who will Trump meet with in August?',
-      category: 'Politics',
-      volume: 335000,
-      liquidity: 85000,
-      closeDate: '2025-08-31',
-      settlementSource: 'White House press pool',
-      rules: 'Resolves YES for each leader Trump meets with in August 2025',
-      conditions: [
-        { name: 'Vladimir Putin', yesPrice: 0.79, noPrice: 0.21, volume: 120000 },
-        { name: 'Volodymyr Zelenskyy', yesPrice: 0.53, noPrice: 0.47, volume: 98000 },
-        { name: 'Crown Prince Mohammed', yesPrice: 0.43, noPrice: 0.57, volume: 67000 }
-      ]
-    },
-    {
-      id: 'OPENAI-LIVESTREAM',
-      title: 'What will be said during OpenAI livestream on August 7?',
-      category: 'Technology',
-      volume: 240000,
-      liquidity: 65000,
-      closeDate: '2025-08-07',
-      settlementSource: 'OpenAI official livestream',
-      rules: 'Resolves YES for each topic mentioned during the livestream',
-      conditions: [
-        { name: 'GPT 15+', yesPrice: 0.93, noPrice: 0.07, volume: 110000 },
-        { name: 'OpenAI 5+', yesPrice: 0.75, noPrice: 0.25, volume: 85000 },
-        { name: 'Multimodal', yesPrice: 0.84, noPrice: 0.16, volume: 45000 }
-      ]
-    }
-  ]);
-
-  const [unmatchedPolymarketMarkets] = useState([
-    {
-      id: '0x2028election',
-      title: '2028 US Presidential Election',
-      category: 'Politics',
-      volume: 5200000,
-      liquidity: 380000,
-      closeDate: '2028-11-05',
-      settlementSource: 'AP News',
-      rules: 'Market resolves to the candidate declared winner by Associated Press',
-      conditions: [
-        { name: 'J.D. Vance', yesPrice: 0.27, noPrice: 0.73, volume: 480000 },
-        { name: 'Gavin Newsom', yesPrice: 0.14, noPrice: 0.86, volume: 340000 },
-        { name: 'AOC', yesPrice: 0.08, noPrice: 0.92, volume: 195000 },
-        { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93, volume: 125000 },
-        { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94, volume: 115000 },
-        { name: 'Andrew Beshear', yesPrice: 0.05, noPrice: 0.95, volume: 270000 },
-        { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96, volume: 280000 }
-      ]
-    },
-    {
-      id: '0xfedrate092025',
-      title: 'Federal Reserve Rate Decision September 2025',
-      category: 'Macro',
-      volume: 420000,
-      liquidity: 110000,
-      closeDate: '2025-09-18',
-      settlementSource: 'Fed official statement',
-      rules: 'Resolves based on the Federal Reserve rate decision',
-      conditions: [
-        { name: 'Rate decrease', yesPrice: 0.78, noPrice: 0.22, volume: 140000 },
-        { name: 'No change', yesPrice: 0.16, noPrice: 0.84, volume: 170000 },
-        { name: 'Rate increase', yesPrice: 0.02, noPrice: 0.98, volume: 45000 }
-      ]
-    },
-    {
-      id: '0xtrumpmeetings',
-      title: 'Trump August 2025 Meetings',
-      category: 'Politics',
-      volume: 310000,
-      liquidity: 78000,
-      closeDate: '2025-08-31',
-      settlementSource: 'Official White House',
-      rules: 'Resolves YES for confirmed meetings in August',
-      conditions: [
-        { name: 'Putin', yesPrice: 0.81, noPrice: 0.19, volume: 115000 },
-        { name: 'Zelensky', yesPrice: 0.51, noPrice: 0.49, volume: 92000 },
-        { name: 'MBS', yesPrice: 0.45, noPrice: 0.55, volume: 63000 }
-      ]
-    },
-    {
-      id: '0xopenaistream',
-      title: 'OpenAI Aug 7 Announcements',
-      category: 'Tech',
-      volume: 225000,
-      liquidity: 60000,
-      closeDate: '2025-08-07',
-      settlementSource: 'OpenAI stream',
-      rules: 'YES if topic is announced during stream',
-      conditions: [
-        { name: 'GPT-15 or higher', yesPrice: 0.92, noPrice: 0.08, volume: 105000 },
-        { name: 'OpenAI Five Plus', yesPrice: 0.76, noPrice: 0.24, volume: 80000 },
-        { name: 'Multimodal AI', yesPrice: 0.85, noPrice: 0.15, volume: 40000 }
-      ]
-    }
-  ]);
+  // Use live market data
+  const { kalshiMarkets, polymarketMarkets, loading, error } = useMarketData();
 
-  const [matchHistory, setMatchHistory] = useState([
-    {
-      id: 1,
-      kalshi: unmatchedKalshiMarkets[0],
-      polymarket: unmatchedPolymarketMarkets[0],
-      matchDate: '2025-08-05',
-      confidence: 0.96,
-      totalVolume: 11200000,
-      conditionsMatched: true,
-      conditionMappings: [
-        { kalshi: 'JD Vance', polymarket: 'J.D. Vance', matched: true },
-        { kalshi: 'Gavin Newsom', polymarket: 'Gavin Newsom', matched: true },
-        { kalshi: 'Alexandria Ocasio-Cortez', polymarket: 'AOC', matched: true },
-        { kalshi: 'Pete Buttigieg', polymarket: 'Pete Buttigieg', matched: true },
-        { kalshi: 'Marco Rubio', polymarket: 'Marco Rubio', matched: true },
-        { kalshi: 'Andy Beshear', polymarket: 'Andrew Beshear', matched: true },
-        { kalshi: 'Gretchen Whitmer', polymarket: 'Gretchen Whitmer', matched: true }
-      ]
-    },
-    {
-      id: 2,
-      kalshi: unmatchedKalshiMarkets[1],
-      polymarket: unmatchedPolymarketMarkets[1],
-      matchDate: '2025-08-04',
-      confidence: 0.94,
-      totalVolume: 870000,
-      conditionsMatched: false,
-      conditionMappings: [
-        { kalshi: '25 bps decrease', polymarket: 'Rate decrease', matched: true },
-        { kalshi: 'No change', polymarket: 'No change', matched: true },
-        { kalshi: '25+ bps increase', polymarket: 'Rate increase', matched: true }
-      ]
-    }
-  ]);
+  // Subscribe to match history from store
+  useEffect(() => {
+    const updateMatchHistory = () => {
+      const store = getStore();
+      setMatchHistory(store.matches);
+    };
 
-  // Auto-match suggestions
-  const [autoMatchSuggestions] = useState([
-    {
-      kalshi: { id: 'SPXCLOSE-25AUG15', title: 'Will the S&P close higher on Aug 15?' },
-      polymarket: { id: '0x1234...abcd', title: 'S&P 500 to close green on Aug 15 2025?' },
-      similarity: 0.89,
-      status: 'pending'
-    },
-    {
-      kalshi: { id: 'FEDHIKE-25SEP', title: 'Fed to raise rates in September?' },
-      polymarket: { id: '0x5678...efgh', title: 'Federal Reserve rate hike September 2025' },
-      similarity: 0.92,
-      status: 'pending'
+    updateMatchHistory();
+    const unsubscribe = subscribeToStore(updateMatchHistory);
+    return unsubscribe;
+  }, []);
+
+  // Auto-match suggestions based on live data
+  const [autoMatchSuggestions, setAutoMatchSuggestions] = useState<Array<{
+    kalshi: CommonMarket;
+    polymarket: CommonMarket;
+    similarity: number;
+    status: string;
+  }>>([]);
+
+  // Generate auto-match suggestions when markets update
+  useEffect(() => {
+    if (kalshiMarkets.length > 0 && polymarketMarkets.length > 0) {
+      // Find potential matches with similarity > 0.8
+      const suggestions: Array<{
+        kalshi: CommonMarket;
+        polymarket: CommonMarket;
+        similarity: number;
+        status: string;
+      }> = [];
+
+      kalshiMarkets.slice(0, 10).forEach(kalshiMarket => { // Limit for performance
+        polymarketMarkets.slice(0, 10).forEach(polymarketMarket => {
+          const similarity = calculateSimilarity(kalshiMarket, polymarketMarket);
+          if (similarity.overall > 0.8) {
+            suggestions.push({
+              kalshi: kalshiMarket,
+              polymarket: polymarketMarket,
+              similarity: similarity.overall,
+              status: 'pending'
+            });
+          }
+        });
+      });
+
+      // Sort by similarity and take top 5
+      suggestions.sort((a, b) => b.similarity - a.similarity);
+      setAutoMatchSuggestions(suggestions.slice(0, 5));
     }
-  ]);
-
-  // Filter markets based on search
-  const filteredKalshiMarkets = unmatchedKalshiMarkets.filter(market =>
-    market.title.toLowerCase().includes(searchTermKalshi.toLowerCase()) ||
-    market.id.toLowerCase().includes(searchTermKalshi.toLowerCase())
-  );
-
-  const filteredPolyMarkets = unmatchedPolymarketMarkets.filter(market =>
-    market.title.toLowerCase().includes(searchTermPoly.toLowerCase()) ||
-    market.id.toLowerCase().includes(searchTermPoly.toLowerCase())
-  );
+  }, [kalshiMarkets, polymarketMarkets]);
+
+  // Filter markets based on search and category
+  const filteredKalshiMarkets = kalshiMarkets.filter(market => {
+    const matchesSearch = market.title.toLowerCase().includes(searchTermKalshi.toLowerCase()) ||
+                         market.id.toLowerCase().includes(searchTermKalshi.toLowerCase());
+    const matchesCategory = filterVenue === 'all' || 
+                           market.category.toLowerCase().includes(filterVenue.toLowerCase());
+    return matchesSearch && matchesCategory;
+  });
+
+  const filteredPolyMarkets = polymarketMarkets.filter(market => {
+    const matchesSearch = market.title.toLowerCase().includes(searchTermPoly.toLowerCase()) ||
+                         market.id.toLowerCase().includes(searchTermPoly.toLowerCase());
+    const matchesCategory = filterVenue === 'all' || 
+                           market.category.toLowerCase().includes(filterVenue.toLowerCase());
+    return matchesSearch && matchesCategory;
+  });
 
   // Calculate similarity score
-  const calculateSimilarity = (market1, market2) => {
-    if (!market1 || !market2) return null;
-    
-    // Title similarity
-    const titleWords1 = market1.title.toLowerCase().split(' ');
-    const titleWords2 = market2.title.toLowerCase().split(' ');
-    const commonWords = titleWords1.filter(word => titleWords2.includes(word));
-    const titleSimilarity = commonWords.length / Math.max(titleWords1.length, titleWords2.length);
-    
-    // Date similarity
-    const dateSimilarity = market1.closeDate === market2.closeDate ? 1 : 0;
-    
-    // Condition count similarity
-    const conditionCountDiff = Math.abs(market1.conditions.length - market2.conditions.length);
-    const conditionSimilarity = 1 - (conditionCountDiff / Math.max(market1.conditions.length, market2.conditions.length));
-    
-    // Settlement source similarity
-    const settlementSimilarity = market1.settlementSource.toLowerCase().includes('ap') && 
-                                market2.settlementSource.toLowerCase().includes('ap') ? 1 : 
-                                market1.settlementSource.toLowerCase() === market2.settlementSource.toLowerCase() ? 1 : 0.5;
-    
-    return {
-      overall: (titleSimilarity * 0.4 + dateSimilarity * 0.3 + conditionSimilarity * 0.2 + settlementSimilarity * 0.1),
-      title: titleSimilarity,
-      date: dateSimilarity,
-      conditions: conditionSimilarity,
-      settlement: settlementSimilarity
-    };
-  };
-
-  const similarity = calculateSimilarity(selectedMarkets.kalshi, selectedMarkets.polymarket);
+  const similarity = selectedMarkets.kalshi && selectedMarkets.polymarket 
+    ? calculateSimilarity(selectedMarkets.kalshi, selectedMarkets.polymarket)
+    : null;
 
   const handleApproveMatch = () => {
     if (!selectedMarkets.kalshi || !selectedMarkets.polymarket) return;
     
     setIsProcessing(true);
     
-    // Simulate API call
+    // Create and save the match
     setTimeout(() => {
-      const newMatch = {
-        id: Date.now(),
-        kalshi: selectedMarkets.kalshi,
-        polymarket: selectedMarkets.polymarket,
-        matchDate: new Date().toISOString().split('T')[0],
-        confidence: similarity.overall,
-        totalVolume: selectedMarkets.kalshi.volume + selectedMarkets.polymarket.volume,
-        conditionsMatched: false,
-        conditionMappings: []
-      };
+      const newMatch = createMarketMatch(
+        selectedMarkets.kalshi!,
+        selectedMarkets.polymarket!,
+        [], // No condition mappings initially
+        similarity?.overall
+      );
       
-      setMatchHistory([newMatch, ...matchHistory]);
+      // Add to store
+      addMarketMatch(newMatch);
+      
+      // Reset selection
       setSelectedMarkets({ kalshi: null, polymarket: null });
       setIsProcessing(false);
       
@@ -270,14 +135,14 @@ const MarketMatcher = () => {
   };
 
   const ConditionMatcher = () => {
-    const [mappings, setMappings] = useState(
+    const [mappings, setMappings] = useState<ConditionMapping[]>(
       selectedMatch?.conditionMappings || []
     );
     const [selectedKalshi, setSelectedKalshi] = useState('');
     const [selectedPoly, setSelectedPoly] = useState('');
-    const [selectedRelationship, setSelectedRelationship] = useState('same');
+    const [selectedRelationship, setSelectedRelationship] = useState<RelationshipType>('same');
 
-    const relationshipTypes = [
+    const relationshipTypes: Array<{ value: RelationshipType; label: string; color: string }> = [
       { value: 'same', label: 'Same', color: 'text-green-400' },
       { value: 'subset', label: 'Subset', color: 'text-blue-400' },
       { value: 'mutually-exclusive', label: 'Mutually Exclusive', color: 'text-orange-400' },
@@ -286,13 +151,19 @@ const MarketMatcher = () => {
       { value: 'overlapping', label: 'Overlapping', color: 'text-yellow-400' }
     ];
 
+    // Get the actual market objects
+    const kalshiMarket = kalshiMarkets.find(m => m.id === selectedMatch?.kalshiMarketId);
+    const polymarketMarket = polymarketMarkets.find(m => m.id === selectedMatch?.polymarketMarketId);
+
     const addMapping = () => {
       if (selectedKalshi && selectedPoly) {
-        const newMapping = {
-          kalshi: selectedKalshi,
-          polymarket: selectedPoly,
+        const newMapping: ConditionMapping = {
+          id: `${selectedKalshi}-${selectedPoly}-${Date.now()}`,
+          kalshiCondition: selectedKalshi,
+          polymarketCondition: selectedPoly,
           relationship: selectedRelationship,
-          matched: true
+          confidence: 1.0, // Manual mappings get full confidence
+          createdAt: new Date(),
         };
         setMappings([...mappings, newMapping]);
         setSelectedKalshi('');
@@ -301,30 +172,28 @@ const MarketMatcher = () => {
       }
     };
 
-    const removeMapping = (index) => {
+    const removeMapping = (index: number) => {
       setMappings(mappings.filter((_, i) => i !== index));
     };
 
     const saveConditionMappings = () => {
-      setMatchHistory(matchHistory.map(match => 
-        match.id === selectedMatch.id
-          ? { ...match, conditionMappings: mappings, conditionsMatched: mappings.length > 0 }
-          : match
-      ));
+      if (selectedMatch) {
+        updateMatchConditions(selectedMatch.id, mappings);
+      }
       setShowConditionMatcher(false);
       setSelectedMatch(null);
     };
 
-    const getRelationshipColor = (relationship) => {
+    const getRelationshipColor = (relationship: RelationshipType) => {
       const rel = relationshipTypes.find(r => r.value === relationship);
       return rel ? rel.color : 'text-gray-400';
     };
 
     // Get unmapped conditions
-    const mappedKalshiConditions = mappings.map(m => m.kalshi);
-    const mappedPolyConditions = mappings.map(m => m.polymarket);
-    const unmappedKalshi = selectedMatch?.kalshi.conditions.filter(c => !mappedKalshiConditions.includes(c.name)) || [];
-    const unmappedPoly = selectedMatch?.polymarket.conditions.filter(c => !mappedPolyConditions.includes(c.name)) || [];
+    const mappedKalshiConditions = mappings.map(m => m.kalshiCondition).filter(Boolean);
+    const mappedPolyConditions = mappings.map(m => m.polymarketCondition).filter(Boolean);
+    const unmappedKalshi = kalshiMarket?.outcomes.filter(c => !mappedKalshiConditions.includes(c.name)) || [];
+    const unmappedPoly = polymarketMarket?.outcomes.filter(c => !mappedPolyConditions.includes(c.name)) || [];
 
     return (
       <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
@@ -339,7 +208,7 @@ const MarketMatcher = () => {
           <div className="mb-4">
             <div className="bg-gray-800 p-3 rounded">
               <div className="text-sm text-gray-400 mb-1">Matching conditions for:</div>
-              <div className="font-medium">{selectedMatch?.kalshi.title}</div>
+              <div className="font-medium">{kalshiMarket?.title}</div>
             </div>
           </div>
 
@@ -348,7 +217,7 @@ const MarketMatcher = () => {
             <div className="bg-gray-800 rounded-lg p-4">
               <h4 className="font-semibold text-blue-400 mb-3">Kalshi Conditions</h4>
               <div className="space-y-2">
-                {selectedMatch?.kalshi.conditions.map((condition, idx) => (
+                {kalshiMarket?.outcomes.map((condition, idx) => (
                   <div key={idx} className={`bg-gray-700 p-3 rounded ${mappedKalshiConditions.includes(condition.name) ? 'opacity-50' : ''}`}>
                     <div className="font-medium text-sm">{condition.name}</div>
                     <div className="flex items-center justify-between mt-1">
@@ -356,7 +225,7 @@ const MarketMatcher = () => {
                         Y: {(condition.yesPrice * 100).toFixed(0)}¢ / N: {(condition.noPrice * 100).toFixed(0)}¢
                       </div>
                       <div className="text-xs text-gray-500">
-                        Vol: ${(condition.volume / 1000).toFixed(0)}k
+                        Vol: ${((condition.volume || 0) / 1000).toFixed(0)}k
                       </div>
                     </div>
                   </div>
@@ -368,7 +237,7 @@ const MarketMatcher = () => {
             <div className="bg-gray-800 rounded-lg p-4">
               <h4 className="font-semibold text-purple-400 mb-3">Polymarket Conditions</h4>
               <div className="space-y-2">
-                {selectedMatch?.polymarket.conditions.map((condition, idx) => (
+                {polymarketMarket?.outcomes.map((condition, idx) => (
                   <div key={idx} className={`bg-gray-700 p-3 rounded ${mappedPolyConditions.includes(condition.name) ? 'opacity-50' : ''}`}>
                     <div className="font-medium text-sm">{condition.name}</div>
                     <div className="flex items-center justify-between mt-1">
@@ -376,7 +245,7 @@ const MarketMatcher = () => {
                         Y: {(condition.yesPrice * 100).toFixed(0)}¢ / N: {(condition.noPrice * 100).toFixed(0)}¢
                       </div>
                       <div className="text-xs text-gray-500">
-                        Vol: ${(condition.volume / 1000).toFixed(0)}k
+                        Vol: ${((condition.volume || 0) / 1000).toFixed(0)}k
                       </div>
                     </div>
                   </div>
@@ -454,7 +323,7 @@ const MarketMatcher = () => {
                     <div className="flex items-center space-x-4 flex-1">
                       <div className="flex-1">
                         <div className="text-xs text-blue-400">Kalshi</div>
-                        <div className="text-sm font-medium">{mapping.kalshi}</div>
+                        <div className="text-sm font-medium">{mapping.kalshiCondition}</div>
                       </div>
                       <div className="px-3">
                         <div className="text-xs text-gray-400 text-center">Relationship</div>
@@ -464,7 +333,7 @@ const MarketMatcher = () => {
                       </div>
                       <div className="flex-1">
                         <div className="text-xs text-purple-400">Polymarket</div>
-                        <div className="text-sm font-medium">{mapping.polymarket}</div>
+                        <div className="text-sm font-medium">{mapping.polymarketCondition}</div>
                       </div>
                     </div>
                     <button
@@ -520,15 +389,15 @@ const MarketMatcher = () => {
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Rules</div>
-                    <p className="text-sm text-gray-300">{selectedMarkets.kalshi.rules}</p>
+                    <p className="text-sm text-gray-300">{selectedMarkets.kalshi.rules || 'No rules specified'}</p>
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Settlement Source</div>
-                    <div className="text-sm text-gray-300">{selectedMarkets.kalshi.settlementSource}</div>
+                    <div className="text-sm text-gray-300">{selectedMarkets.kalshi.settlementSource || 'Not specified'}</div>
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Conditions</div>
-                    <div className="text-sm text-gray-300">{selectedMarkets.kalshi.conditions.length} outcomes</div>
+                    <div className="text-sm text-gray-300">{selectedMarkets.kalshi.outcomes.length} outcomes</div>
                   </div>
                 </div>
               </div>
@@ -542,15 +411,15 @@ const MarketMatcher = () => {
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Rules</div>
-                    <p className="text-sm text-gray-300">{selectedMarkets.polymarket.rules}</p>
+                    <p className="text-sm text-gray-300">{selectedMarkets.polymarket.rules || 'No rules specified'}</p>
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Settlement Source</div>
-                    <div className="text-sm text-gray-300">{selectedMarkets.polymarket.settlementSource}</div>
+                    <div className="text-sm text-gray-300">{selectedMarkets.polymarket.settlementSource || 'Not specified'}</div>
                   </div>
                   <div>
                     <div className="text-xs text-gray-500">Conditions</div>
-                    <div className="text-sm text-gray-300">{selectedMarkets.polymarket.conditions.length} outcomes</div>
+                    <div className="text-sm text-gray-300">{selectedMarkets.polymarket.outcomes.length} outcomes</div>
                   </div>
                 </div>
               </div>
@@ -563,7 +432,7 @@ const MarketMatcher = () => {
                 <div>
                   <div className="text-sm text-blue-400 mb-2">Kalshi Conditions:</div>
                   <div className="space-y-1">
-                    {selectedMarkets.kalshi.conditions.map((condition, idx) => (
+                    {selectedMarkets.kalshi.outcomes.map((condition, idx) => (
                       <div key={idx} className="text-xs text-gray-300">
                         • {condition.name} (Y: {(condition.yesPrice * 100).toFixed(0)}¢)
                       </div>
@@ -573,7 +442,7 @@ const MarketMatcher = () => {
                 <div>
                   <div className="text-sm text-purple-400 mb-2">Polymarket Conditions:</div>
                   <div className="space-y-1">
-                    {selectedMarkets.polymarket.conditions.map((condition, idx) => (
+                    {selectedMarkets.polymarket.outcomes.map((condition, idx) => (
                       <div key={idx} className="text-xs text-gray-300">
                         • {condition.name} (Y: {(condition.yesPrice * 100).toFixed(0)}¢)
                       </div>
@@ -640,6 +509,15 @@ const MarketMatcher = () => {
       </div>
 
       <div className="p-4">
+        {/* Error Display */}
+        {error && (
+          <div className="bg-red-900 bg-opacity-20 border border-red-600 rounded-lg p-3 mb-4">
+            <div className="text-red-300 text-sm">
+              <strong>Connection Error:</strong> {error}
+            </div>
+          </div>
+        )}
+
         {/* Tabs */}
         <div className="flex space-x-1 mb-4">
           <button
@@ -671,6 +549,14 @@ const MarketMatcher = () => {
         {/* Content */}
         {activeTab === 'manual' && (
           <div className="space-y-4">
+            {/* Loading State */}
+            {loading && (
+              <div className="bg-gray-900 rounded-lg p-4 text-center">
+                <RefreshCw className="w-6 h-6 animate-spin text-blue-400 mx-auto mb-2" />
+                <div className="text-gray-400">Loading markets...</div>
+              </div>
+            )}
+
             {/* Market Selection */}
             <div className="grid grid-cols-2 gap-4">
               {/* Kalshi Markets */}
@@ -689,33 +575,44 @@ const MarketMatcher = () => {
                   </div>
                 </div>
                 <div className="space-y-2 max-h-96 overflow-y-auto">
-                  {filteredKalshiMarkets.map(market => (
-                    <div
-                      key={market.id}
-                      onClick={() => setSelectedMarkets(prev => ({ ...prev, kalshi: market }))}
-                      className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
-                        selectedMarkets.kalshi?.id === market.id ? 'ring-2 ring-blue-500' : ''
-                      }`}
-                    >
-                      <div className="font-medium text-sm">{market.title}</div>
-                      <div className="mt-2">
-                        <div className="text-xs text-gray-500">
-                          {market.category} • ${(market.volume / 1000).toFixed(0)}k vol • {market.conditions.length} conditions
-                        </div>
-                        <div className="mt-1 flex flex-wrap gap-1">
-                          {market.conditions.slice(0, 3).map((condition, idx) => (
-                            <span key={idx} className="text-xs bg-gray-700 px-2 py-0.5 rounded">
-                              {condition.name}: {(condition.yesPrice * 100).toFixed(0)}¢
-                            </span>
-                          ))}
-                          {market.conditions.length > 3 && (
-                            <span className="text-xs text-gray-500">+{market.conditions.length - 3} more</span>
-                          )}
+                  {loading ? (
+                    <div className="text-center py-8 text-gray-500">
+                      <RefreshCw className="w-5 h-5 animate-spin mx-auto mb-2" />
+                      Loading Kalshi markets...
+                    </div>
+                  ) : filteredKalshiMarkets.length === 0 ? (
+                    <div className="text-center py-8 text-gray-500">
+                      No markets found
+                    </div>
+                  ) : (
+                    filteredKalshiMarkets.map(market => (
+                      <div
+                        key={market.id}
+                        onClick={() => setSelectedMarkets(prev => ({ ...prev, kalshi: market }))}
+                        className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
+                          selectedMarkets.kalshi?.id === market.id ? 'ring-2 ring-blue-500' : ''
+                        }`}
+                      >
+                        <div className="font-medium text-sm">{market.title}</div>
+                        <div className="mt-2">
+                          <div className="text-xs text-gray-500">
+                            {market.category} • ${((market.volume || 0) / 1000).toFixed(0)}k vol • {market.outcomes.length} conditions
+                          </div>
+                          <div className="mt-1 flex flex-wrap gap-1">
+                            {market.outcomes.slice(0, 3).map((condition, idx) => (
+                              <span key={idx} className="text-xs bg-gray-700 px-2 py-0.5 rounded">
+                                {condition.name}: {(condition.yesPrice * 100).toFixed(0)}¢
+                              </span>
+                            ))}
+                            {market.outcomes.length > 3 && (
+                              <span className="text-xs text-gray-500">+{market.outcomes.length - 3} more</span>
+                            )}
+                          </div>
                         </div>
+                        <div className="text-xs text-gray-600 mt-1">Closes {market.closeTime.toLocaleDateString()}</div>
                       </div>
-                      <div className="text-xs text-gray-600 mt-1">Closes {market.closeDate}</div>
-                    </div>
-                  ))}
+                    ))
+                  )}
                 </div>
               </div>
 
@@ -735,33 +632,44 @@ const MarketMatcher = () => {
                   </div>
                 </div>
                 <div className="space-y-2 max-h-96 overflow-y-auto">
-                  {filteredPolyMarkets.map(market => (
-                    <div
-                      key={market.id}
-                      onClick={() => setSelectedMarkets(prev => ({ ...prev, polymarket: market }))}
-                      className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
-                        selectedMarkets.polymarket?.id === market.id ? 'ring-2 ring-purple-500' : ''
-                      }`}
-                    >
-                      <div className="font-medium text-sm">{market.title}</div>
-                      <div className="mt-2">
-                        <div className="text-xs text-gray-500">
-                          {market.category} • ${(market.volume / 1000).toFixed(0)}k vol • {market.conditions.length} conditions
-                        </div>
-                        <div className="mt-1 flex flex-wrap gap-1">
-                          {market.conditions.slice(0, 3).map((condition, idx) => (
-                            <span key={idx} className="text-xs bg-gray-700 px-2 py-0.5 rounded">
-                              {condition.name}: {(condition.yesPrice * 100).toFixed(0)}¢
-                            </span>
-                          ))}
-                          {market.conditions.length > 3 && (
-                            <span className="text-xs text-gray-500">+{market.conditions.length - 3} more</span>
-                          )}
+                  {loading ? (
+                    <div className="text-center py-8 text-gray-500">
+                      <RefreshCw className="w-5 h-5 animate-spin mx-auto mb-2" />
+                      Loading Polymarket markets...
+                    </div>
+                  ) : filteredPolyMarkets.length === 0 ? (
+                    <div className="text-center py-8 text-gray-500">
+                      No markets found
+                    </div>
+                  ) : (
+                    filteredPolyMarkets.map(market => (
+                      <div
+                        key={market.id}
+                        onClick={() => setSelectedMarkets(prev => ({ ...prev, polymarket: market }))}
+                        className={`p-3 bg-gray-800 rounded cursor-pointer hover:bg-gray-700 transition-colors ${
+                          selectedMarkets.polymarket?.id === market.id ? 'ring-2 ring-purple-500' : ''
+                        }`}
+                      >
+                        <div className="font-medium text-sm">{market.title}</div>
+                        <div className="mt-2">
+                          <div className="text-xs text-gray-500">
+                            {market.category} • ${((market.volume || 0) / 1000).toFixed(0)}k vol • {market.outcomes.length} conditions
+                          </div>
+                          <div className="mt-1 flex flex-wrap gap-1">
+                            {market.outcomes.slice(0, 3).map((condition, idx) => (
+                              <span key={idx} className="text-xs bg-gray-700 px-2 py-0.5 rounded">
+                                {condition.name}: {(condition.yesPrice * 100).toFixed(0)}¢
+                              </span>
+                            ))}
+                            {market.outcomes.length > 3 && (
+                              <span className="text-xs text-gray-500">+{market.outcomes.length - 3} more</span>
+                            )}
+                          </div>
                         </div>
+                        <div className="text-xs text-gray-600 mt-1">Closes {market.closeTime.toLocaleDateString()}</div>
                       </div>
-                      <div className="text-xs text-gray-600 mt-1">Closes {market.closeDate}</div>
-                    </div>
-                  ))}
+                    ))
+                  )}
                 </div>
               </div>
             </div>
@@ -776,12 +684,12 @@ const MarketMatcher = () => {
                   <div className="bg-gray-800 p-3 rounded">
                     <div className="text-xs text-blue-400 mb-1">Kalshi Market</div>
                     <div className="text-sm font-medium">{selectedMarkets.kalshi.title}</div>
-                    <div className="text-xs text-gray-500 mt-1">{selectedMarkets.kalshi.conditions.length} conditions</div>
+                    <div className="text-xs text-gray-500 mt-1">{selectedMarkets.kalshi.outcomes.length} conditions</div>
                   </div>
                   <div className="bg-gray-800 p-3 rounded">
                     <div className="text-xs text-purple-400 mb-1">Polymarket Market</div>
                     <div className="text-sm font-medium">{selectedMarkets.polymarket.title}</div>
-                    <div className="text-xs text-gray-500 mt-1">{selectedMarkets.polymarket.conditions.length} conditions</div>
+                    <div className="text-xs text-gray-500 mt-1">{selectedMarkets.polymarket.outcomes.length} conditions</div>
                   </div>
                 </div>
                 
@@ -971,67 +879,73 @@ const MarketMatcher = () => {
                 </tr>
               </thead>
               <tbody>
-                {matchHistory.map(match => (
-                  <tr key={match.id} className="border-t border-gray-800 hover:bg-gray-800">
-                    <td className="p-3">
-                      <div className="text-sm font-medium">{match.kalshi.title}</div>
-                      <div className="text-xs text-gray-500">{match.kalshi.id}</div>
-                      <div className="text-xs text-gray-600 mt-1">{match.kalshi.conditions.length} conditions</div>
-                    </td>
-                    <td className="p-3">
-                      <div className="text-sm font-medium">{match.polymarket.title}</div>
-                      <div className="text-xs text-gray-500">{match.polymarket.id}</div>
-                      <div className="text-xs text-gray-600 mt-1">{match.polymarket.conditions.length} conditions</div>
-                    </td>
-                    <td className="p-3 text-sm">
-                      {match.matchDate}
-                    </td>
-                    <td className="p-3">
-                      <select
-                        className="bg-gray-700 border border-gray-600 rounded px-2 py-1 text-sm"
-                        defaultValue={match.kalshi.conditions.length > 1 ? 'multi' : 'single'}
-                      >
-                        <option value="single">Single</option>
-                        <option value="multi">Multi</option>
-                      </select>
-                    </td>
-                    <td className="p-3 text-sm">
-                      ${(match.totalVolume / 1000).toFixed(0)}k
-                    </td>
-                    <td className="p-3">
-                      <div className="flex items-center">
-                        {match.conditionsMatched ? (
-                          <>
-                            <CheckCircle className="w-4 h-4 text-green-400 mr-1" />
-                            <span className="text-sm text-green-400">Yes</span>
-                          </>
-                        ) : (
-                          <>
-                            <XCircle className="w-4 h-4 text-yellow-400 mr-1" />
-                            <span className="text-sm text-yellow-400">No</span>
-                          </>
-                        )}
-                      </div>
-                    </td>
-                    <td className="p-3">
-                      <div className="flex items-center space-x-2">
-                        <button 
-                          onClick={() => {
-                            setSelectedMatch(match);
-                            setShowConditionMatcher(true);
-                          }}
-                          className="text-blue-400 hover:text-blue-300"
-                          title="Edit condition mappings"
+                {matchHistory.map(match => {
+                  // Get market data from store
+                  const kalshiMarket = kalshiMarkets.find(m => m.id === match.kalshiMarketId);
+                  const polymarketMarket = polymarketMarkets.find(m => m.id === match.polymarketMarketId);
+                  
+                  return (
+                    <tr key={match.id} className="border-t border-gray-800 hover:bg-gray-800">
+                      <td className="p-3">
+                        <div className="text-sm font-medium">{kalshiMarket?.title || match.kalshiMarketId}</div>
+                        <div className="text-xs text-gray-500">{match.kalshiMarketId}</div>
+                        <div className="text-xs text-gray-600 mt-1">{kalshiMarket?.outcomes.length || 0} conditions</div>
+                      </td>
+                      <td className="p-3">
+                        <div className="text-sm font-medium">{polymarketMarket?.title || match.polymarketMarketId}</div>
+                        <div className="text-xs text-gray-500">{match.polymarketMarketId}</div>
+                        <div className="text-xs text-gray-600 mt-1">{polymarketMarket?.outcomes.length || 0} conditions</div>
+                      </td>
+                      <td className="p-3 text-sm">
+                        {match.createdAt.toLocaleDateString()}
+                      </td>
+                      <td className="p-3">
+                        <select
+                          className="bg-gray-700 border border-gray-600 rounded px-2 py-1 text-sm"
+                          defaultValue={(kalshiMarket?.outcomes.length || 0) > 1 ? 'multi' : 'single'}
                         >
-                          <Edit2 className="w-4 h-4" />
-                        </button>
-                        <button className="text-red-400 hover:text-red-300 text-sm">
-                          Unmatch
-                        </button>
-                      </div>
-                    </td>
-                  </tr>
-                ))}
+                          <option value="single">Single</option>
+                          <option value="multi">Multi</option>
+                        </select>
+                      </td>
+                      <td className="p-3 text-sm">
+                        ${((match.totalVolume || 0) / 1000).toFixed(0)}k
+                      </td>
+                      <td className="p-3">
+                        <div className="flex items-center">
+                          {match.conditionsMatched ? (
+                            <>
+                              <CheckCircle className="w-4 h-4 text-green-400 mr-1" />
+                              <span className="text-sm text-green-400">Yes</span>
+                            </>
+                          ) : (
+                            <>
+                              <XCircle className="w-4 h-4 text-yellow-400 mr-1" />
+                              <span className="text-sm text-yellow-400">No</span>
+                            </>
+                          )}
+                        </div>
+                      </td>
+                      <td className="p-3">
+                        <div className="flex items-center space-x-2">
+                          <button 
+                            onClick={() => {
+                              setSelectedMatch(match);
+                              setShowConditionMatcher(true);
+                            }}
+                            className="text-blue-400 hover:text-blue-300"
+                            title="Edit condition mappings"
+                          >
+                            <Edit2 className="w-4 h-4" />
+                          </button>
+                          <button className="text-red-400 hover:text-red-300 text-sm">
+                            Unmatch
+                          </button>
+                        </div>
+                      </td>
+                    </tr>
+                  );
+                })}
               </tbody>
             </table>
           </div>
diff --git a/src/matched-ecosystems-component.tsx b/src/matched-ecosystems-component.tsx
index c9a1f96..64b4746 100644
--- a/src/matched-ecosystems-component.tsx
+++ b/src/matched-ecosystems-component.tsx
@@ -1,493 +1,42 @@
 import React, { useState, useEffect } from 'react';
 import { Search, RefreshCw, ChevronDown, Edit2, CheckCircle, XCircle, X } from 'lucide-react';
+import { 
+  getStore, 
+  subscribeToStore, 
+  updateEcosystemConditions 
+} from './state/matches-store';
+import { 
+  Ecosystem, 
+  ConditionMapping, 
+  RelationshipType,
+  CommonMarket 
+} from './api/types';
 
 const MatchedEcosystems = () => {
-  const [selectedItems, setSelectedItems] = useState([]);
-  const [expandedRows, setExpandedRows] = useState([]);
+  const [selectedItems, setSelectedItems] = useState<string[]>([]);
+  const [expandedRows, setExpandedRows] = useState<string[]>([]);
   const [searchTerm, setSearchTerm] = useState('');
   const [showConditionMatcher, setShowConditionMatcher] = useState(false);
-  const [selectedEcosystem, setSelectedEcosystem] = useState(null);
+  const [selectedEcosystem, setSelectedEcosystem] = useState<Ecosystem | null>(null);
+  const [ecosystemData, setEcosystemData] = useState<Ecosystem[]>([]);
 
-  // Mock data for ecosystem matching
-  const [ecosystemData, setEcosystemData] = useState([
-    {
-      id: 1,
-      name: 'Fed Rate Decision - September 2025',
-      endTime: 'Sep 18, 2025',
-      daysUntilClose: 42,
-      exchanges: 4,
-      markets: 6,
-      conditions: 13,
-      updated: '2 min ago',
-      conditionsMatched: true,
-      conditionMappings: [
-        {
-          conditions: {
-            'Kalshi-Fed September Decision': '25 bps increase',
-            'Polymarket-Federal Reserve Rate Decision': 'Rate increase',
-            'Kalshi-Fed Hike by 50bps+': null,
-            'ProphetX-FOMC September Outcome': null,
-            'NoVig-Fed Rates Sep': 'Increase',
-            'Polymarket-Fed Terminal Rate >5.5%': null
-          },
-          relationship: 'same'
-        },
-        {
-          conditions: {
-            'Kalshi-Fed September Decision': 'No change',
-            'Polymarket-Federal Reserve Rate Decision': 'No change',
-            'Kalshi-Fed Hike by 50bps+': null,
-            'ProphetX-FOMC September Outcome': 'Neutral',
-            'NoVig-Fed Rates Sep': null,
-            'Polymarket-Fed Terminal Rate >5.5%': null
-          },
-          relationship: 'same'
-        }
-      ],
-      marketData: [
-        {
-          exchange: 'Kalshi',
-          market: 'Fed September Decision',
-          conditions: [
-            { name: '25 bps increase', yesPrice: 0.35, noPrice: 0.65 },
-            { name: 'No change', yesPrice: 0.45, noPrice: 0.55 },
-            { name: '25 bps decrease', yesPrice: 0.18, noPrice: 0.82 },
-            { name: '50+ bps increase', yesPrice: 0.02, noPrice: 0.98 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'Federal Reserve Rate Decision',
-          conditions: [
-            { name: 'Rate increase', yesPrice: 0.37, noPrice: 0.63 },
-            { name: 'No change', yesPrice: 0.44, noPrice: 0.56 },
-            { name: 'Rate decrease', yesPrice: 0.19, noPrice: 0.81 }
-          ]
-        },
-        {
-          exchange: 'Kalshi',
-          market: 'Fed Hike by 50bps+',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.02, noPrice: 0.98 },
-            { name: 'No', yesPrice: 0.98, noPrice: 0.02 }
-          ]
-        },
-        {
-          exchange: 'ProphetX',
-          market: 'FOMC September Outcome',
-          conditions: [
-            { name: 'Hawkish', yesPrice: 0.40, noPrice: 0.60 },
-            { name: 'Dovish', yesPrice: 0.35, noPrice: 0.65 },
-            { name: 'Neutral', yesPrice: 0.25, noPrice: 0.75 }
-          ]
-        },
-        {
-          exchange: 'NoVig',
-          market: 'Fed Rates Sep',
-          conditions: [
-            { name: 'Increase', yesPrice: 0.38, noPrice: 0.62 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'Fed Terminal Rate >5.5%',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.15, noPrice: 0.85 },
-            { name: 'No', yesPrice: 0.85, noPrice: 0.15 }
-          ]
-        }
-      ]
-    },
-    {
-      id: 2,
-      name: '2028 Presidential Election',
-      endTime: 'Nov 5, 2028',
-      daysUntilClose: 1185,
-      exchanges: 3,
-      markets: 5,
-      conditions: 21,
-      updated: '5 min ago',
-      conditionsMatched: false,
-      conditionMappings: [],
-      marketData: [
-        {
-          exchange: 'Kalshi',
-          market: 'Presidential Election Winner 2028',
-          conditions: [
-            { name: 'JD Vance', yesPrice: 0.28, noPrice: 0.72 },
-            { name: 'Gavin Newsom', yesPrice: 0.13, noPrice: 0.87 },
-            { name: 'Alexandria Ocasio-Cortez', yesPrice: 0.09, noPrice: 0.91 },
-            { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93 },
-            { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94 },
-            { name: 'Andy Beshear', yesPrice: 0.05, noPrice: 0.95 },
-            { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: '2028 US Presidential Election',
-          conditions: [
-            { name: 'J.D. Vance', yesPrice: 0.27, noPrice: 0.73 },
-            { name: 'Gavin Newsom', yesPrice: 0.14, noPrice: 0.86 },
-            { name: 'AOC', yesPrice: 0.08, noPrice: 0.92 },
-            { name: 'Pete Buttigieg', yesPrice: 0.07, noPrice: 0.93 },
-            { name: 'Marco Rubio', yesPrice: 0.06, noPrice: 0.94 },
-            { name: 'Andrew Beshear', yesPrice: 0.05, noPrice: 0.95 },
-            { name: 'Gretchen Whitmer', yesPrice: 0.04, noPrice: 0.96 }
-          ]
-        },
-        {
-          exchange: 'Kalshi',
-          market: 'Republican Nominee 2028',
-          conditions: [
-            { name: 'JD Vance', yesPrice: 0.52, noPrice: 0.48 },
-            { name: 'Marco Rubio', yesPrice: 0.15, noPrice: 0.85 },
-            { name: 'Other', yesPrice: 0.33, noPrice: 0.67 }
-          ]
-        },
-        {
-          exchange: 'Kalshi',
-          market: 'Democratic Nominee 2028',
-          conditions: [
-            { name: 'Gavin Newsom', yesPrice: 0.35, noPrice: 0.65 },
-            { name: 'Gretchen Whitmer', yesPrice: 0.18, noPrice: 0.82 },
-            { name: 'Other', yesPrice: 0.47, noPrice: 0.53 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'Party to Win 2028',
-          conditions: [
-            { name: 'Republican', yesPrice: 0.48, noPrice: 0.52 },
-            { name: 'Democrat', yesPrice: 0.52, noPrice: 0.48 }
-          ]
-        }
-      ]
-    },
-    {
-      id: 3,
-      name: 'Bitcoin Price EOY 2025',
-      endTime: 'Dec 31, 2025',
-      daysUntilClose: 145,
-      exchanges: 5,
-      markets: 8,
-      conditions: 15,
-      updated: '8 min ago',
-      conditionsMatched: true,
-      conditionMappings: [
-        {
-          conditions: {
-            'Kalshi-Bitcoin > $100k': 'Yes',
-            'Polymarket-BTC above $100,000 by EOY': 'Yes',
-            'Kalshi-Bitcoin > $150k': null,
-            'Polymarket-BTC Price Range EOY': '$100k-$150k',
-            'ProphetX-Bitcoin EOY Price': 'Above $100k',
-            'NoVig-BTC 100k EOY': 'Yes',
-            'Sporttrade-Bitcoin Year End': 'Over $100,000',
-            'Kalshi-Bitcoin ATH in 2025': null
-          },
-          relationship: 'same'
-        }
-      ],
-      marketData: [
-        {
-          exchange: 'Kalshi',
-          market: 'Bitcoin > $100k',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.40, noPrice: 0.60 },
-            { name: 'No', yesPrice: 0.60, noPrice: 0.40 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'BTC above $100,000 by EOY',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.38, noPrice: 0.62 },
-            { name: 'No', yesPrice: 0.62, noPrice: 0.38 }
-          ]
-        },
-        {
-          exchange: 'Kalshi',
-          market: 'Bitcoin > $150k',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.15, noPrice: 0.85 },
-            { name: 'No', yesPrice: 0.85, noPrice: 0.15 }
-          ]
-        },
-        {
-          exchange: 'Polymarket',
-          market: 'BTC Price Range EOY',
-          conditions: [
-            { name: '<$50k', yesPrice: 0.05, noPrice: 0.95 },
-            { name: '$50k-$100k', yesPrice: 0.57, noPrice: 0.43 },
-            { name: '$100k-$150k', yesPrice: 0.25, noPrice: 0.75 },
-            { name: '>$150k', yesPrice: 0.13, noPrice: 0.87 }
-          ]
-        },
-        {
-          exchange: 'ProphetX',
-          market: 'Bitcoin EOY Price',
-          conditions: [
-            { name: 'Above $100k', yesPrice: 0.39, noPrice: 0.61 }
-          ]
-        },
-        {
-          exchange: 'NoVig',
-          market: 'BTC 100k EOY',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.41, noPrice: 0.59 },
-            { name: 'No', yesPrice: 0.59, noPrice: 0.41 }
-          ]
-        },
-        {
-          exchange: 'Sporttrade',
-          market: 'Bitcoin Year End',
-          conditions: [
-            { name: 'Over $100,000', yesPrice: 0.37, noPrice: 0.63 }
-          ]
-        },
-        {
-          exchange: 'Kalshi',
-          market: 'Bitcoin ATH in 2025',
-          conditions: [
-            { name: 'Yes', yesPrice: 0.78, noPrice: 0.22 },
-            { name: 'No', yesPrice: 0.22, noPrice: 0.78 }
-          ]
-        }
-      ]
-    }
-  ]);
-
-  const EcosystemConditionMatcher = () => {
-    const [mappings, setMappings] = useState(
-      selectedEcosystem?.conditionMappings || []
-    );
-    const [selectedConditions, setSelectedConditions] = useState({});
-    const [selectedRelationship, setSelectedRelationship] = useState('same');
-
-    const relationshipTypes = [
-      { value: 'same', label: 'Same', color: 'text-green-400' },
-      { value: 'subset', label: 'Subset', color: 'text-blue-400' },
-      { value: 'mutually-exclusive', label: 'Mutually Exclusive', color: 'text-orange-400' },
-      { value: 'complementary', label: 'Complementary', color: 'text-purple-400' },
-      { value: 'opposites', label: 'Opposites', color: 'text-red-400' },
-      { value: 'overlapping', label: 'Overlapping', color: 'text-yellow-400' }
-    ];
-
-    // Initialize selected conditions for each market
-    useEffect(() => {
-      const initialConditions = {};
-      selectedEcosystem?.marketData.forEach(market => {
-        const key = `${market.exchange}-${market.market}`;
-        initialConditions[key] = '';
-      });
-      setSelectedConditions(initialConditions);
-    }, []);
-
-    const addMapping = () => {
-      // Check if at least one condition is selected
-      const hasSelection = Object.values(selectedConditions).some(val => val !== '');
-      if (!hasSelection) {
-        alert('Please select at least one condition');
-        return;
-      }
-
-      const newMapping = {
-        conditions: { ...selectedConditions },
-        relationship: selectedRelationship
-      };
-      
-      setMappings([...mappings, newMapping]);
-      
-      // Reset selections
-      const resetConditions = {};
-      Object.keys(selectedConditions).forEach(key => {
-        resetConditions[key] = '';
-      });
-      setSelectedConditions(resetConditions);
-    };
-
-    const removeMapping = (index) => {
-      setMappings(mappings.filter((_, i) => i !== index));
-    };
-
-    const saveConditionMappings = () => {
-      setEcosystemData(ecosystemData.map(ecosystem => 
-        ecosystem.id === selectedEcosystem.id
-          ? { ...ecosystem, conditionMappings: mappings, conditionsMatched: mappings.length > 0 }
-          : ecosystem
-      ));
-      setShowConditionMatcher(false);
-      setSelectedEcosystem(null);
+  // Subscribe to ecosystem data from store
+  useEffect(() => {
+    const updateEcosystemData = () => {
+      const store = getStore();
+      setEcosystemData(store.ecosystems);
     };
 
-    const getRelationshipColor = (relationship) => {
-      const rel = relationshipTypes.find(r => r.value === relationship);
-      return rel ? rel.color : 'text-gray-400';
-    };
-
-    return (
-      <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
-        <div className="bg-gray-900 rounded-lg p-6 max-w-7xl w-full max-h-[90vh] overflow-y-auto">
-          <div className="flex justify-between items-center mb-4">
-            <h3 className="text-lg font-bold text-white">Match Ecosystem Conditions</h3>
-            <button onClick={() => setShowConditionMatcher(false)} className="text-gray-400 hover:text-white">
-              <X className="w-5 h-5" />
-            </button>
-          </div>
-
-          <div className="mb-4">
-            <div className="bg-gray-800 p-3 rounded">
-              <div className="text-sm text-gray-400 mb-1">Matching conditions for:</div>
-              <div className="font-medium">{selectedEcosystem?.name}</div>
-              <div className="text-xs text-gray-500 mt-1">
-                {selectedEcosystem?.marketData.length} markets across {selectedEcosystem?.exchanges} exchanges
-              </div>
-            </div>
-          </div>
-
-          {/* Conditions Grid */}
-          <div className="mb-6 overflow-x-auto">
-            <div className="bg-gray-800 rounded-lg p-4">
-              <h4 className="font-semibold mb-3">Market Conditions</h4>
-              <div className="grid" style={{ gridTemplateColumns: `repeat(${selectedEcosystem?.marketData.length || 1}, minmax(200px, 1fr))`, gap: '1rem' }}>
-                {selectedEcosystem?.marketData.map((market, idx) => (
-                  <div key={idx} className="bg-gray-700 rounded p-3">
-                    <div className={`text-xs font-semibold mb-2 ${
-                      market.exchange === 'Kalshi' ? 'text-blue-400' : 
-                      market.exchange === 'Polymarket' ? 'text-purple-400' : 
-                      'text-gray-400'
-                    }`}>
-                      {market.exchange}
-                    </div>
-                    <div className="text-sm font-medium mb-2">{market.market}</div>
-                    <div className="space-y-1">
-                      {market.conditions.map((condition, condIdx) => (
-                        <div key={condIdx} className="text-xs bg-gray-800 p-2 rounded">
-                          <div>{condition.name}</div>
-                          <div className="text-gray-500 mt-1">
-                            Y: {(condition.yesPrice * 100).toFixed(0)}¢ / N: {(condition.noPrice * 100).toFixed(0)}¢
-                          </div>
-                        </div>
-                      ))}
-                    </div>
-                  </div>
-                ))}
-              </div>
-            </div>
-          </div>
-
-          {/* Mapping Interface */}
-          <div className="bg-gray-800 rounded-lg p-4 mb-4">
-            <h4 className="font-semibold mb-3">Add Condition Mapping</h4>
-            
-            {/* Relationship Selection */}
-            <div className="mb-4">
-              <label className="text-xs text-gray-400 mb-1 block">Relationship Type</label>
-              <select
-                value={selectedRelationship}
-                onChange={(e) => setSelectedRelationship(e.target.value)}
-                className="w-full bg-gray-700 border border-gray-600 rounded px-3 py-2 text-sm"
-              >
-                {relationshipTypes.map(rel => (
-                  <option key={rel.value} value={rel.value}>{rel.label}</option>
-                ))}
-              </select>
-            </div>
-
-            {/* Condition Dropdowns */}
-            <div className="grid" style={{ gridTemplateColumns: `repeat(${selectedEcosystem?.marketData.length || 1}, minmax(200px, 1fr))`, gap: '1rem' }}>
-              {selectedEcosystem?.marketData.map((market, idx) => {
-                const key = `${market.exchange}-${market.market}`;
-                return (
-                  <div key={idx}>
-                    <label className="text-xs text-gray-400 mb-1 block">
-                      {market.exchange} - {market.market}
-                    </label>
-                    <select
-                      value={selectedConditions[key] || ''}
-                      onChange={(e) => setSelectedConditions({
-                        ...selectedConditions,
-                        [key]: e.target.value
-                      })}
-                      className="w-full bg-gray-700 border border-gray-600 rounded px-3 py-2 text-sm"
-                    >
-                      <option value="">None</option>
-                      {market.conditions.map((condition, condIdx) => (
-                        <option key={condIdx} value={condition.name}>
-                          {condition.name} ({(condition.yesPrice * 100).toFixed(0)}¢)
-                        </option>
-                      ))}
-                    </select>
-                  </div>
-                );
-              })}
-            </div>
-            
-            <button
-              onClick={addMapping}
-              className="mt-4 px-4 py-2 bg-blue-600 hover:bg-blue-700 rounded text-sm"
-            >
-              Add Mapping
-            </button>
-          </div>
-
-          {/* Current Mappings */}
-          {mappings.length > 0 && (
-            <div className="bg-gray-800 rounded-lg p-4">
-              <h4 className="font-semibold mb-3">Current Mappings</h4>
-              <div className="space-y-3">
-                {mappings.map((mapping, idx) => (
-                  <div key={idx} className="bg-gray-700 p-3 rounded">
-                    <div className="flex items-center justify-between mb-2">
-                      <div className={`text-sm font-medium ${getRelationshipColor(mapping.relationship)}`}>
-                        {relationshipTypes.find(r => r.value === mapping.relationship)?.label} Relationship
-                      </div>
-                      <button
-                        onClick={() => removeMapping(idx)}
-                        className="text-red-400 hover:text-red-300"
-                      >
-                        <X className="w-4 h-4" />
-                      </button>
-                    </div>
-                    <div className="grid" style={{ gridTemplateColumns: `repeat(${Object.keys(mapping.conditions).length}, minmax(150px, 1fr))`, gap: '0.5rem' }}>
-                      {Object.entries(mapping.conditions).map(([market, condition], condIdx) => (
-                        <div key={condIdx} className="text-xs">
-                          <div className="text-gray-400">{market}</div>
-                          <div className="font-medium">{condition || '-'}</div>
-                        </div>
-                      ))}
-                    </div>
-                  </div>
-                ))}
-              </div>
-            </div>
-          )}
-
-          <div className="mt-6 flex justify-end space-x-2">
-            <button 
-              onClick={() => setShowConditionMatcher(false)}
-              className="px-4 py-2 bg-gray-700 hover:bg-gray-600 rounded text-sm"
-            >
-              Cancel
-            </button>
-            <button 
-              onClick={saveConditionMappings}
-              className="px-4 py-2 bg-green-600 hover:bg-green-700 rounded text-sm"
-            >
-              Save Mappings
-            </button>
-          </div>
-        </div>
-      </div>
-    );
-  };
+    updateEcosystemData();
+    const unsubscribe = subscribeToStore(updateEcosystemData);
+    return unsubscribe;
+  }, []);
 
   const filteredData = ecosystemData.filter(item =>
     item.name.toLowerCase().includes(searchTerm.toLowerCase())
   );
 
-  const toggleRowExpansion = (id) => {
+  const toggleRowExpansion = (id: string) => {
     setExpandedRows(prev => 
       prev.includes(id) 
         ? prev.filter(rowId => rowId !== id)
@@ -495,7 +44,7 @@ const MatchedEcosystems = () => {
     );
   };
 
-  const toggleSelection = (id) => {
+  const toggleSelection = (id: string) => {
     setSelectedItems(prev =>
       prev.includes(id)
         ? prev.filter(itemId => itemId !== id)
@@ -505,83 +54,89 @@ const MatchedEcosystems = () => {
 
   const handleApproveEcosystem = () => {
     if (selectedItems.length === 0) {
-      alert('Please select at least one market to create an ecosystem');
+      alert('Please select at least one ecosystem');
       return;
     }
-    alert(`Creating ecosystem with ${selectedItems.length} markets`);
+    alert(`Selected ${selectedItems.length} ecosystem${selectedItems.length > 1 ? 's' : ''}`);
     setSelectedItems([]);
   };
 
-  const ExpandedEcosystem = ({ item }) => (
+  const calculateDaysUntilClose = (ecosystem: Ecosystem): number => {
+    if (!ecosystem.earliestEndTime) return 0;
+    const now = new Date();
+    const diffTime = ecosystem.earliestEndTime.getTime() - now.getTime();
+    return Math.max(0, Math.ceil(diffTime / (1000 * 60 * 60 * 24)));
+  };
+
+  const formatTimeAgo = (date: Date): string => {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMin = Math.floor(diffMs / (1000 * 60));
+    
+    if (diffMin < 1) return 'Just now';
+    if (diffMin === 1) return '1 min ago';
+    if (diffMin < 60) return `${diffMin} min ago`;
+    
+    const diffHours = Math.floor(diffMin / 60);
+    if (diffHours === 1) return '1 hour ago';
+    if (diffHours < 24) return `${diffHours} hours ago`;
+    
+    const diffDays = Math.floor(diffHours / 24);
+    return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+  };
+
+  const ExpandedEcosystem = ({ item }: { item: Ecosystem }) => (
     <tr>
       <td colSpan="10" className="p-0">
         <div className="bg-gray-800 border-t border-gray-700">
           <div className="p-4">
             <div className="mb-3">
-              <h4 className="text-sm font-semibold text-gray-400">Market Conditions Across Exchanges</h4>
+              <h4 className="text-sm font-semibold text-gray-400">Market Overview</h4>
             </div>
-            <div className="overflow-x-auto">
-              <table className="w-full">
-                <thead>
-                  <tr className="text-xs text-gray-400 border-b border-gray-700">
-                    <th className="text-left pb-2 pr-4">Condition</th>
-                    {item.marketData.map((market, idx) => (
-                      <th key={idx} className="text-center pb-2 px-4" colSpan="2">
-                        <div className="font-semibold">{market.exchange}</div>
-                        <div className="text-xs font-normal">{market.market}</div>
-                      </th>
-                    ))}
-                  </tr>
-                  <tr className="text-xs text-gray-500 border-b border-gray-700">
-                    <th className="pb-2"></th>
-                    {item.marketData.map((_, idx) => (
-                      <React.Fragment key={idx}>
-                        <th className="text-center pb-2 px-2">Yes</th>
-                        <th className="text-center pb-2 px-2">No</th>
-                      </React.Fragment>
-                    ))}
-                  </tr>
-                </thead>
-                <tbody>
-                  {(() => {
-                    // Get all unique conditions
-                    const allConditions = new Set();
-                    item.marketData.forEach(market => {
-                      market.conditions.forEach(condition => {
-                        allConditions.add(condition.name);
-                      });
-                    });
-                    
-                    return Array.from(allConditions).map((conditionName, idx) => (
-                      <tr key={idx} className="text-sm border-t border-gray-700">
-                        <td className="py-2 pr-4 font-medium">{conditionName}</td>
-                        {item.marketData.map((market, marketIdx) => {
-                          const condition = market.conditions.find(c => c.name === conditionName);
-                          return (
-                            <React.Fragment key={marketIdx}>
-                              <td className="py-2 px-2 text-center">
-                                {condition ? (
-                                  <span className="text-green-400">{(condition.yesPrice * 100).toFixed(0)}¢</span>
-                                ) : (
-                                  <span className="text-gray-600">-</span>
-                                )}
-                              </td>
-                              <td className="py-2 px-2 text-center">
-                                {condition ? (
-                                  <span className="text-red-400">{(condition.noPrice * 100).toFixed(0)}¢</span>
-                                ) : (
-                                  <span className="text-gray-600">-</span>
-                                )}
-                              </td>
-                            </React.Fragment>
-                          );
-                        })}
-                      </tr>
-                    ));
-                  })()}
-                </tbody>
-              </table>
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {item.marketRefs.map((marketRef, idx) => (
+                <div key={idx} className="bg-gray-700 rounded p-3">
+                  <div className={`text-xs font-semibold mb-1 ${
+                    marketRef.platform === 'kalshi' ? 'text-blue-400' : 
+                    marketRef.platform === 'polymarket' ? 'text-purple-400' : 
+                    'text-gray-400'
+                  }`}>
+                    {marketRef.platform === 'kalshi' ? 'Kalshi' : 'Polymarket'}
+                  </div>
+                  <div className="text-sm font-medium mb-2">
+                    {marketRef.market?.title || marketRef.marketId}
+                  </div>
+                  {marketRef.market && (
+                    <div className="space-y-1">
+                      <div className="text-xs text-gray-400">
+                        {marketRef.market.outcomes.length} conditions
+                      </div>
+                      <div className="text-xs text-gray-500">
+                        Closes: {marketRef.market.closeTime.toLocaleDateString()}
+                      </div>
+                      {marketRef.market.outcomes.slice(0, 2).map((condition, condIdx) => (
+                        <div key={condIdx} className="text-xs bg-gray-800 p-1 rounded">
+                          {condition.name}: {(condition.yesPrice * 100).toFixed(0)}¢
+                        </div>
+                      ))}
+                      {marketRef.market.outcomes.length > 2 && (
+                        <div className="text-xs text-gray-500">
+                          +{marketRef.market.outcomes.length - 2} more conditions
+                        </div>
+                      )}
+                    </div>
+                  )}
+                </div>
+              ))}
             </div>
+            {item.conditionMappings.length > 0 && (
+              <div className="mt-4">
+                <h4 className="text-sm font-semibold text-gray-400 mb-2">Condition Mappings</h4>
+                <div className="text-xs text-gray-500">
+                  {item.conditionMappings.length} mapping{item.conditionMappings.length > 1 ? 's' : ''} configured
+                </div>
+              </div>
+            )}
           </div>
         </div>
       </td>
@@ -684,10 +239,10 @@ const MatchedEcosystems = () => {
                       <div className="font-medium text-sm">{item.name}</div>
                     </td>
                     <td className="p-3" onClick={() => toggleRowExpansion(item.id)}>
-                      <span className="text-sm">{item.endTime}</span>
+                      <span className="text-sm">{item.earliestEndTime?.toLocaleDateString() || 'Not set'}</span>
                     </td>
                     <td className="p-3" onClick={() => toggleRowExpansion(item.id)}>
-                      <span className="text-sm">{item.daysUntilClose} days</span>
+                      <span className="text-sm">{calculateDaysUntilClose(item)} days</span>
                     </td>
                     <td className="p-3" onClick={() => toggleRowExpansion(item.id)}>
                       <span className="text-sm font-medium">{item.exchanges}</span>
@@ -714,7 +269,7 @@ const MatchedEcosystems = () => {
                       </div>
                     </td>
                     <td className="p-3" onClick={() => toggleRowExpansion(item.id)}>
-                      <span className="text-xs text-gray-400">{item.updated}</span>
+                      <span className="text-xs text-gray-400">{formatTimeAgo(item.createdAt)}</span>
                     </td>
                     <td className="p-3">
                       <div className="flex items-center space-x-2">
@@ -745,7 +300,30 @@ const MatchedEcosystems = () => {
         </div>
       </div>
 
-      {showConditionMatcher && <EcosystemConditionMatcher />}
+      {showConditionMatcher && selectedEcosystem && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+          <div className="bg-gray-900 rounded-lg p-6 max-w-4xl w-full">
+            <div className="flex justify-between items-center mb-4">
+              <h3 className="text-lg font-bold text-white">Edit Ecosystem Conditions</h3>
+              <button onClick={() => setShowConditionMatcher(false)} className="text-gray-400 hover:text-white">
+                <X className="w-5 h-5" />
+              </button>
+            </div>
+            <div className="text-center py-8">
+              <div className="text-gray-400 mb-4">Condition mapping for "{selectedEcosystem.name}"</div>
+              <div className="text-sm text-gray-500">
+                This feature will allow editing condition mappings between markets in the ecosystem.
+              </div>
+              <button
+                onClick={() => setShowConditionMatcher(false)}
+                className="mt-4 px-4 py-2 bg-blue-600 hover:bg-blue-700 rounded text-sm"
+              >
+                Close
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </div>
   );
 };
diff --git a/src/state/matches-store.ts b/src/state/matches-store.ts
new file mode 100644
index 0000000..d9dce9c
--- /dev/null
+++ b/src/state/matches-store.ts
@@ -0,0 +1,406 @@
+// Central store for matched markets and ecosystems with localStorage persistence
+import {
+  MatchesStore,
+  CommonMarket,
+  MarketMatch,
+  Ecosystem,
+  ArbitrageOpportunity,
+  PollingConfig,
+  Platform
+} from '../api/types';
+
+// Default store state
+const defaultState: MatchesStore = {
+  markets: {
+    kalshi: [],
+    polymarket: [],
+    lastUpdated: new Date(),
+  },
+  matches: [],
+  ecosystems: [],
+  arbitrageOpportunities: [],
+  polling: {
+    kalshiInterval: 5000, // 5 seconds
+    polymarketInterval: 2500, // 2.5 seconds 
+    enabled: true,
+  },
+};
+
+// Storage keys
+const STORAGE_KEYS = {
+  MATCHES: 'arber2_matches',
+  ECOSYSTEMS: 'arber2_ecosystems',
+  POLLING_CONFIG: 'arber2_polling_config',
+  LAST_UPDATED: 'arber2_last_updated',
+} as const;
+
+/**
+ * Load persisted data from localStorage
+ */
+function loadFromStorage(): Partial<MatchesStore> {
+  try {
+    const stored: Partial<MatchesStore> = {};
+
+    // Load matches
+    const matchesData = localStorage.getItem(STORAGE_KEYS.MATCHES);
+    if (matchesData) {
+      const matches = JSON.parse(matchesData);
+      // Convert date strings back to Date objects
+      stored.matches = matches.map((match: any) => ({
+        ...match,
+        createdAt: new Date(match.createdAt),
+        conditionMappings: match.conditionMappings.map((mapping: any) => ({
+          ...mapping,
+          createdAt: new Date(mapping.createdAt),
+        })),
+      }));
+    }
+
+    // Load ecosystems
+    const ecosystemsData = localStorage.getItem(STORAGE_KEYS.ECOSYSTEMS);
+    if (ecosystemsData) {
+      const ecosystems = JSON.parse(ecosystemsData);
+      stored.ecosystems = ecosystems.map((ecosystem: any) => ({
+        ...ecosystem,
+        createdAt: new Date(ecosystem.createdAt),
+        earliestEndTime: ecosystem.earliestEndTime ? new Date(ecosystem.earliestEndTime) : undefined,
+        conditionMappings: ecosystem.conditionMappings.map((mapping: any) => ({
+          ...mapping,
+          createdAt: new Date(mapping.createdAt),
+        })),
+      }));
+    }
+
+    // Load polling config
+    const pollingData = localStorage.getItem(STORAGE_KEYS.POLLING_CONFIG);
+    if (pollingData) {
+      stored.polling = JSON.parse(pollingData);
+    }
+
+    // Load last updated timestamp
+    const lastUpdatedData = localStorage.getItem(STORAGE_KEYS.LAST_UPDATED);
+    if (lastUpdatedData) {
+      stored.markets = {
+        kalshi: [],
+        polymarket: [],
+        lastUpdated: new Date(lastUpdatedData),
+      };
+    }
+
+    return stored;
+  } catch (error) {
+    console.error('Error loading from localStorage:', error);
+    return {};
+  }
+}
+
+/**
+ * Save data to localStorage
+ */
+function saveToStorage(key: keyof typeof STORAGE_KEYS, data: any): void {
+  try {
+    localStorage.setItem(STORAGE_KEYS[key], JSON.stringify(data));
+  } catch (error) {
+    console.error(`Error saving ${key} to localStorage:`, error);
+  }
+}
+
+// Initialize store with persisted data
+let store: MatchesStore = {
+  ...defaultState,
+  ...loadFromStorage(),
+};
+
+// Subscribers for store updates
+type StoreSubscriber = (store: MatchesStore) => void;
+const subscribers = new Set<StoreSubscriber>();
+
+/**
+ * Subscribe to store updates
+ */
+export function subscribeToStore(callback: StoreSubscriber): () => void {
+  subscribers.add(callback);
+  return () => subscribers.delete(callback);
+}
+
+/**
+ * Notify all subscribers of store changes
+ */
+function notifySubscribers(): void {
+  subscribers.forEach(callback => callback(store));
+}
+
+/**
+ * Get current store state (read-only)
+ */
+export function getStore(): Readonly<MatchesStore> {
+  return store;
+}
+
+/**
+ * Update market data
+ */
+export function updateMarkets(kalshi: CommonMarket[], polymarket: CommonMarket[]): void {
+  store.markets = {
+    kalshi,
+    polymarket,
+    lastUpdated: new Date(),
+  };
+  
+  saveToStorage('LAST_UPDATED', store.markets.lastUpdated);
+  notifySubscribers();
+}
+
+/**
+ * Add a new market match
+ */
+export function addMarketMatch(match: MarketMatch): void {
+  // Check if match already exists
+  const existingIndex = store.matches.findIndex(m => 
+    m.kalshiMarketId === match.kalshiMarketId && 
+    m.polymarketMarketId === match.polymarketMarketId
+  );
+
+  if (existingIndex >= 0) {
+    // Update existing match
+    store.matches[existingIndex] = match;
+  } else {
+    // Add new match
+    store.matches.push(match);
+  }
+
+  saveToStorage('MATCHES', store.matches);
+  notifySubscribers();
+}
+
+/**
+ * Update condition mappings for a match
+ */
+export function updateMatchConditions(matchId: string, conditionMappings: any[]): void {
+  const matchIndex = store.matches.findIndex(m => m.id === matchId);
+  if (matchIndex >= 0) {
+    store.matches[matchIndex] = {
+      ...store.matches[matchIndex],
+      conditionMappings,
+      conditionsMatched: conditionMappings.length > 0,
+    };
+
+    saveToStorage('MATCHES', store.matches);
+    notifySubscribers();
+  }
+}
+
+/**
+ * Remove a market match
+ */
+export function removeMarketMatch(matchId: string): void {
+  store.matches = store.matches.filter(m => m.id !== matchId);
+  saveToStorage('MATCHES', store.matches);
+  notifySubscribers();
+}
+
+/**
+ * Add a new ecosystem
+ */
+export function addEcosystem(ecosystem: Ecosystem): void {
+  store.ecosystems.push(ecosystem);
+  saveToStorage('ECOSYSTEMS', store.ecosystems);
+  notifySubscribers();
+}
+
+/**
+ * Update ecosystem condition mappings
+ */
+export function updateEcosystemConditions(ecosystemId: string, conditionMappings: any[]): void {
+  const ecosystemIndex = store.ecosystems.findIndex(e => e.id === ecosystemId);
+  if (ecosystemIndex >= 0) {
+    store.ecosystems[ecosystemIndex] = {
+      ...store.ecosystems[ecosystemIndex],
+      conditionMappings,
+      conditionsMatched: conditionMappings.length > 0,
+    };
+
+    saveToStorage('ECOSYSTEMS', store.ecosystems);
+    notifySubscribers();
+  }
+}
+
+/**
+ * Remove an ecosystem
+ */
+export function removeEcosystem(ecosystemId: string): void {
+  store.ecosystems = store.ecosystems.filter(e => e.id !== ecosystemId);
+  saveToStorage('ECOSYSTEMS', store.ecosystems);
+  notifySubscribers();
+}
+
+/**
+ * Create a new ecosystem from selected markets
+ */
+export function createEcosystem(
+  name: string,
+  selectedMarkets: Array<{ market: CommonMarket; platform: Platform }>
+): Ecosystem {
+  // Calculate derived stats
+  const exchanges = new Set(selectedMarkets.map(m => m.platform)).size;
+  const markets = selectedMarkets.length;
+  const conditions = selectedMarkets.reduce((sum, m) => sum + m.market.outcomes.length, 0);
+  
+  // Find earliest end time
+  const endTimes = selectedMarkets.map(m => m.market.closeTime.getTime());
+  const earliestEndTime = endTimes.length > 0 ? new Date(Math.min(...endTimes)) : undefined;
+
+  const ecosystem: Ecosystem = {
+    id: `ecosystem-${Date.now()}`,
+    name,
+    createdAt: new Date(),
+    marketRefs: selectedMarkets.map(m => ({
+      platform: m.platform,
+      marketId: m.market.id,
+      market: m.market,
+    })),
+    conditionMappings: [],
+    conditionsMatched: false,
+    exchanges,
+    markets,
+    conditions,
+    earliestEndTime,
+  };
+
+  addEcosystem(ecosystem);
+  return ecosystem;
+}
+
+/**
+ * Update arbitrage opportunities
+ */
+export function updateArbitrageOpportunities(opportunities: ArbitrageOpportunity[]): void {
+  store.arbitrageOpportunities = opportunities;
+  notifySubscribers();
+}
+
+/**
+ * Update polling configuration
+ */
+export function updatePollingConfig(config: Partial<PollingConfig>): void {
+  store.polling = { ...store.polling, ...config };
+  saveToStorage('POLLING_CONFIG', store.polling);
+  notifySubscribers();
+}
+
+/**
+ * Get markets by platform
+ */
+export function getMarketsByPlatform(platform: Platform): CommonMarket[] {
+  return store.markets[platform] || [];
+}
+
+/**
+ * Get market by ID and platform
+ */
+export function getMarket(platform: Platform, marketId: string): CommonMarket | undefined {
+  return store.markets[platform].find(m => m.id === marketId);
+}
+
+/**
+ * Get all matched markets with condition mappings
+ */
+export function getMatchedMarketsWithConditions(): MarketMatch[] {
+  return store.matches.filter(match => match.conditionsMatched);
+}
+
+/**
+ * Get ecosystems with matched conditions
+ */
+export function getEcosystemsWithConditions(): Ecosystem[] {
+  return store.ecosystems.filter(ecosystem => ecosystem.conditionsMatched);
+}
+
+/**
+ * Clear all stored data (for testing/reset)
+ */
+export function clearStore(): void {
+  store = { ...defaultState };
+  
+  // Clear localStorage
+  Object.values(STORAGE_KEYS).forEach(key => {
+    localStorage.removeItem(key);
+  });
+  
+  notifySubscribers();
+}
+
+/**
+ * Export data for backup
+ */
+export function exportStoreData(): string {
+  const exportData = {
+    matches: store.matches,
+    ecosystems: store.ecosystems,
+    polling: store.polling,
+    exportedAt: new Date().toISOString(),
+  };
+  
+  return JSON.stringify(exportData, null, 2);
+}
+
+/**
+ * Import data from backup
+ */
+export function importStoreData(jsonData: string): boolean {
+  try {
+    const importData = JSON.parse(jsonData);
+    
+    if (importData.matches) {
+      store.matches = importData.matches.map((match: any) => ({
+        ...match,
+        createdAt: new Date(match.createdAt),
+        conditionMappings: match.conditionMappings.map((mapping: any) => ({
+          ...mapping,
+          createdAt: new Date(mapping.createdAt),
+        })),
+      }));
+      saveToStorage('MATCHES', store.matches);
+    }
+    
+    if (importData.ecosystems) {
+      store.ecosystems = importData.ecosystems.map((ecosystem: any) => ({
+        ...ecosystem,
+        createdAt: new Date(ecosystem.createdAt),
+        earliestEndTime: ecosystem.earliestEndTime ? new Date(ecosystem.earliestEndTime) : undefined,
+        conditionMappings: ecosystem.conditionMappings.map((mapping: any) => ({
+          ...mapping,
+          createdAt: new Date(mapping.createdAt),
+        })),
+      }));
+      saveToStorage('ECOSYSTEMS', store.ecosystems);
+    }
+    
+    if (importData.polling) {
+      store.polling = importData.polling;
+      saveToStorage('POLLING_CONFIG', store.polling);
+    }
+    
+    notifySubscribers();
+    return true;
+  } catch (error) {
+    console.error('Error importing store data:', error);
+    return false;
+  }
+}
+
+/**
+ * Get store statistics
+ */
+export function getStoreStats() {
+  return {
+    totalMatches: store.matches.length,
+    matchesWithConditions: store.matches.filter(m => m.conditionsMatched).length,
+    totalEcosystems: store.ecosystems.length,
+    ecosystemsWithConditions: store.ecosystems.filter(e => e.conditionsMatched).length,
+    totalArbitrageOpportunities: store.arbitrageOpportunities.length,
+    kalshiMarkets: store.markets.kalshi.length,
+    polymarketMarkets: store.markets.polymarket.length,
+    lastUpdated: store.markets.lastUpdated,
+  };
+}
\ No newline at end of file