Get Positions

Unrealized PnL = Position Size × ((Mark Price - Entry Price) / Entry Price)

Unrealized PnL = Position Size × ((Entry Price - Mark Price) / Entry Price)

async function getOpenPositionSummary(walletAddress) {
  const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
  const data = await response.json();
  
  const openPositions = data.openPositions;
  const totalUnrealizedPnl = openPositions.reduce((sum, pos) => 
    sum + parseFloat(pos.unrealizedPnl), 0
  );
  
  const totalMarginUsed = openPositions.reduce((sum, pos) => 
    sum + parseFloat(pos.margin), 0
  );
  
  return {
    count: openPositions.length,
    totalUnrealizedPnl,
    totalMarginUsed,
    avgLeverage: openPositions.length > 0 ? 
      openPositions.reduce((sum, pos) => sum + pos.leverage, 0) / openPositions.length : 0
  };
}

async function checkLiquidationRisk(walletAddress) {
  const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
  const data = await response.json();
  
  const riskyPositions = data.openPositions.filter(pos => {
    const currentPrice = parseFloat(pos.markPrice);
    const liquidationPrice = parseFloat(pos.liquidationPrice);
    
    if (pos.side === 'long') {
      return (currentPrice - liquidationPrice) / currentPrice < 0.1; // Less than 10% buffer
    } else {
      return (liquidationPrice - currentPrice) / currentPrice < 0.1; // Less than 10% buffer
    }
  });
  
  return riskyPositions.map(pos => ({
    positionId: pos.positionId,
    symbol: pos.symbol,
    side: pos.side,
    liquidationDistance: calculateLiquidationDistance(pos),
    urgency: assessUrgency(pos)
  }));
}

async function calculatePositionPerformance(walletAddress) {
  const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
  const data = await response.json();
  
  const allClosedPositions = [...data.closedPositions, ...data.settledPositions];
  
  if (allClosedPositions.length === 0) {
    return { message: "No closed positions to analyze" };
  }
  
  const winners = allClosedPositions.filter(pos => calculateRealizedPnl(pos) > 0);
  const losers = allClosedPositions.filter(pos => calculateRealizedPnl(pos) < 0);
  
  const totalPnl = allClosedPositions.reduce((sum, pos) => 
    sum + calculateRealizedPnl(pos), 0
  );
  
  return {
    totalTrades: allClosedPositions.length,
    winners: winners.length,
    losers: losers.length,
    winRate: (winners.length / allClosedPositions.length * 100).toFixed(2) + '%',
    totalPnl: totalPnl.toFixed(2),
    avgWin: winners.length > 0 ? 
      (winners.reduce((sum, pos) => sum + calculateRealizedPnl(pos), 0) / winners.length).toFixed(2) : '0',
    avgLoss: losers.length > 0 ? 
      (losers.reduce((sum, pos) => sum + calculateRealizedPnl(pos), 0) / losers.length).toFixed(2) : '0'
  };
}

async function getPositionsByMarket(walletAddress, symbol = null) {
  const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
  const data = await response.json();
  
  const filterBySymbol = (positions) => 
    symbol ? positions.filter(pos => pos.symbol === symbol) : positions;
  
  return {
    open: filterBySymbol(data.openPositions),
    closed: filterBySymbol(data.closedPositions),
    settled: filterBySymbol(data.settledPositions)
  };
}

// Usage examples:
// getAllPositions = await getPositionsByMarket(wallet);
// btcPositions = await getPositionsByMarket(wallet, 'BTC-USD');
// ethPositions = await getPositionsByMarket(wallet, 'ETH-USD');

class PositionMonitor {
  constructor(walletAddress, updateInterval = 10000) {
    this.walletAddress = walletAddress;
    this.updateInterval = updateInterval;
    this.positions = null;
    this.callbacks = [];
  }
  
  async start() {
    await this.updatePositions();
    this.timer = setInterval(() => this.updatePositions(), this.updateInterval);
  }
  
  stop() {
    if (this.timer) clearInterval(this.timer);
  }
  
  async updatePositions() {
    try {
      const response = await fetch(`https://api.strike.markets/positions/${this.walletAddress}`);
      const newPositions = await response.json();
      
      if (this.positions) {
        this.detectChanges(this.positions, newPositions);
      }
      
      this.positions = newPositions;
      this.notifyCallbacks(newPositions);
    } catch (error) {
      console.error('Failed to update positions:', error);
    }
  }
  
  onUpdate(callback) {
    this.callbacks.push(callback);
  }
  
  notifyCallbacks(positions) {
    this.callbacks.forEach(cb => cb(positions));
  }
  
  detectChanges(oldPositions, newPositions) {
    // Compare position counts and PnL changes
    const oldOpenCount = oldPositions.openPositions.length;
    const newOpenCount = newPositions.openPositions.length;
    
    if (oldOpenCount !== newOpenCount) {
      console.log('Position count changed:', oldOpenCount, '->', newOpenCount);
    }
    
    // Check for significant PnL changes
    newPositions.openPositions.forEach(newPos => {
      const oldPos = oldPositions.openPositions.find(p => p.positionId === newPos.positionId);
      if (oldPos) {
        const pnlChange = Math.abs(parseFloat(newPos.unrealizedPnl) - parseFloat(oldPos.unrealizedPnl));
        if (pnlChange > 10) { // Alert on 10+ USD PnL changes
          console.log(`Significant PnL change for position ${newPos.positionId}: ${pnlChange}`);
        }
      }
    });
  }
}

function PositionsDashboard({ walletAddress }) {
  const [positions, setPositions] = useState(null);
  const [loading, setLoading] = useState(true);
  const [selectedTab, setSelectedTab] = useState('open');
  
  useEffect(() => {
    async function loadPositions() {
      try {
        const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
        const data = await response.json();
        setPositions(data);
      } catch (error) {
        console.error('Failed to load positions:', error);
      } finally {
        setLoading(false);
      }
    }
    
    loadPositions();
    
    // Set up periodic updates for open positions
    const interval = setInterval(loadPositions, 15000);
    return () => clearInterval(interval);
  }, [walletAddress]);
  
  if (loading) return <div>Loading positions...</div>;
  if (!positions) return <div>Failed to load positions</div>;
  
  const tabData = {
    open: positions.openPositions,
    closed: positions.closedPositions,
    settled: positions.settledPositions
  };
  
  return (
    <div>
      <div className="tab-navigation">
        {Object.keys(tabData).map(tab => (
          <button 
            key={tab}
            className={selectedTab === tab ? 'active' : ''}
            onClick={() => setSelectedTab(tab)}
          >
            {tab.charAt(0).toUpperCase() + tab.slice(1)} ({tabData[tab].length})
          </button>
        ))}
      </div>
      
      <div className="position-list">
        {tabData[selectedTab].map(position => (
          <PositionCard key={position.positionId} position={position} />
        ))}
      </div>
    </div>
  );
}

class PositionCache {
  constructor(ttl = 10000) { // 10 second TTL for open positions
    this.cache = new Map();
    this.ttl = ttl;
  }
  
  getCacheKey(walletAddress) {
    return `positions_${walletAddress}`;
  }
  
  async getPositions(walletAddress) {
    const key = this.getCacheKey(walletAddress);
    const cached = this.cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.data;
    }
    
    const response = await fetch(`https://api.strike.markets/positions/${walletAddress}`);
    const data = await response.json();
    
    this.cache.set(key, {
      data,
      timestamp: Date.now()
    });
    
    return data;
  }
  
  invalidate(walletAddress) {
    const key = this.getCacheKey(walletAddress);
    this.cache.delete(key);
  }
}