Maximum Total Exposure = Sum of all position sizes

Standard Account:
- Max Total Exposure: $5M
- Max Correlation Risk: $2M per sector

Institutional Account:
- Max Total Exposure: $500M
- Max Correlation Risk: $100M per sector

Valid Price Range = Mark Price × (1 ± Max Deviation)

Example (BTC at $50,000):
- Minimum Valid: $47,500 (-5%)
- Maximum Valid: $52,500 (+5%)

Burst Window: 10 seconds
Burst Capacity: 5× sustained rate

Example (Standard tier orders):
- Sustained: 10/sec
- Burst: 50 orders in 10 sec window
- Recovery: Linear (10 orders/sec)

Effective Leverage = min(Requested Leverage, Max for Position Size)

Example:
- Requested: 50x
- Position Size: $2M
- Effective: 10x (capped by size)

import { DEX } from '@luxfi/trading'

const dex = await DEX({ rpcUrl: 'https://api.lux.network/rpc' })

// Get account limits
const limits = await dex.getAccountLimits()

console.log('Position Limits:')
console.log(`  Max Position: $${limits.maxPosition}`)
console.log(`  Current Usage: $${limits.currentExposure}`)
console.log(`  Available: $${limits.availableExposure}`)

console.log('Rate Limits:')
console.log(`  Orders/sec: ${limits.orderRate.limit}`)
console.log(`  Current: ${limits.orderRate.current}`)
console.log(`  Resets: ${limits.orderRate.resetTime}`)

console.log('Leverage:')
console.log(`  Max Available: ${limits.maxLeverage}x`)

// Check if order would be accepted
const validation = await dex.validateOrder({
  symbol: 'BTC-USD',
  side: 'buy',
  type: 'limit',
  price: '50000',
  quantity: '10',
  leverage: 20
})

if (!validation.valid) {
  console.log('Order would be rejected:')
  validation.errors.forEach(err => {
    console.log(`  - ${err.code}: ${err.message}`)
  })
}

// Request limit increase
const request = await dex.requestLimitIncrease({
  type: 'position',
  currentLimit: '1000000',
  requestedLimit: '5000000',
  reason: 'Scaling trading operations',
  documents: ['balance_proof.pdf']
})

console.log(`Request ID: ${request.id}`)
console.log(`Status: ${request.status}`)
console.log(`ETA: ${request.estimatedReviewTime}`)

try {
  await dex.placeOrder(orderParams)
} catch (error) {
  if (error.code === 'RATE_LIMIT') {
    // Wait and retry with exponential backoff
    await sleep(error.retryAfter * 1000)
    return dex.placeOrder(orderParams)
  }
  if (error.code === 'POSITION_LIMIT') {
    // Reduce position or wait for existing to close
    console.log(`Max position: ${error.limit}`)
    console.log(`Requested: ${error.requested}`)
  }
  throw error
}