{
  "error": {
    "code": 401,
    "message": "Unauthorized: Invalid API key"
  }
}

{
  "error": {
    "code": 403,
    "message": "Forbidden: API key not enabled for gRPC streaming"
  }
}

{
  "error": {
    "code": 403,
    "message": "API key not enabled for geyser:query service"
  }
}

{
  "error": {
    "code": 403,
    "message": "gRPC streaming requires Business tier or higher"
  }
}

{
  "error": {
    "code": 403,
    "message": "Mainnet access requires Professional tier"
  }
}

{
  "error": {
    "code": 403,
    "message": "Request from IP 123.45.67.89 not allowed"
  }
}

{
  "error": {
    "code": 429,
    "message": "Rate limit exceeded: 10 requests/second",
    "retryAfter": 1000
  }
}

async function makeRequestWithRetry(payload, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await axios.post(endpoint, payload, {
        headers: { 'X-API-Key': apiKey }
      });
      return response.data;
    } catch (error) {
      if (error.response?.status === 429) {
        const retryAfter = error.response.data.error.retryAfter || 1000;
        const backoff = retryAfter * Math.pow(2, i);
        console.log(`Rate limited. Retrying in ${backoff}ms...`);
        await new Promise(resolve => setTimeout(resolve, backoff));
      } else {
        throw error;
      }
    }
  }
  throw new Error('Max retries exceeded');
}

const response = await axios.post(endpoint, payload, {
  headers: { 'X-API-Key': apiKey }
});

console.log('Rate limit:', response.headers['x-ratelimit-limit']);
console.log('Remaining:', response.headers['x-ratelimit-remaining']);
console.log('Reset:', response.headers['x-ratelimit-reset']);

// Instead of 100 separate requests
for (let addr of addresses) {
  await getBalance(addr);  // Rate limited!
}

// Batch into groups
const chunks = chunkArray(addresses, 10);
for (let chunk of chunks) {
  await Promise.all(chunk.map(addr => getBalance(addr)));
  await sleep(100);  // Pace requests
}

// Instead of polling every second (60 req/min)
setInterval(async () => {
  const slot = await getSlot();  // Rate limited!
}, 1000);

// Use WebSocket subscription (free!)
const ws = new WebSocket('wss://nexus.fortiblox.com/geyser/ws?api-key=KEY');
ws.send(JSON.stringify({
  method: 'subscribe',
  params: ['slotUpdates']
}));

{
  "error": {
    "code": 500,
    "message": "Internal server error",
    "requestId": "req_abc123xyz"
  }
}

async function robustRequest(payload) {
  const maxRetries = 3;

  for (let i = 0; i < maxRetries; i++) {
    try {
      return await axios.post(endpoint, payload, {
        headers: { 'X-API-Key': apiKey }
      });
    } catch (error) {
      if (error.response?.status === 500 && i < maxRetries - 1) {
        console.log(`Server error. Retrying... (${i + 1}/${maxRetries})`);
        await sleep(Math.pow(2, i) * 1000);
      } else {
        throw error;
      }
    }
  }
}

{
  "error": {
    "code": 503,
    "message": "Service temporarily unavailable",
    "retryAfter": 30
  }
}

// Wrong - missing prefix
const apiKey = "e2372852b2fbfcfa89a9f2d77d71c80d";

// Wrong - truncated
const apiKey = "fbx_e2372852b2fbfcfa89a9f2d77d71";

// Wrong - has newline
const apiKey = "fbx_e2372852b2fbfcfa89a9f2d77d71c80d39f46298\n";

// Correct
const apiKey = "fbx_e2372852b2fbfcfa89a9f2d77d71c80d39f46298af8f0fdd24a75c17c7b508ee";

// Trim whitespace
const apiKey = process.env.FORTIBLOX_API_KEY.trim();

// Validate format
if (!apiKey.startsWith('fbx_')) {
  throw new Error('Invalid API key format');
}

if (apiKey.length < 64) {
  throw new Error('API key too short');
}

// Missing X-API-Key header
const response = await axios.post('https://nexus.fortiblox.com/rpc', {
  jsonrpc: '2.0',
  method: 'getHealth'
});

// Include X-API-Key header
const response = await axios.post('https://nexus.fortiblox.com/rpc', {
  jsonrpc: '2.0',
  method: 'getHealth'
}, {
  headers: {
    'X-API-Key': process.env.FORTIBLOX_API_KEY,
    'Content-Type': 'application/json'
  }
});

// Authorization header
const response = await axios.post('https://nexus.fortiblox.com/rpc', {
  jsonrpc: '2.0',
  method: 'getHealth'
}, {
  headers: {
    'Authorization': `Bearer ${process.env.FORTIBLOX_API_KEY}`,
    'Content-Type': 'application/json'
  }
});

curl -v -X POST https://nexus.fortiblox.com/rpc \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "getHealth"}'

X-RateLimit-Limit: 50          # Max requests per second
X-RateLimit-Remaining: 45      # Requests left in current window
X-RateLimit-Reset: 1678901234  # Unix timestamp when limit resets
X-Credits-Used: 1              # Credits consumed by this request
X-Credits-Remaining: 9999999   # Credits left this month

const response = await axios.post(endpoint, payload, {
  headers: { 'X-API-Key': apiKey }
});

const rateLimit = {
  limit: response.headers['x-ratelimit-limit'],
  remaining: response.headers['x-ratelimit-remaining'],
  reset: new Date(response.headers['x-ratelimit-reset'] * 1000),
  creditsUsed: response.headers['x-credits-used'],
  creditsRemaining: response.headers['x-credits-remaining']
};

console.log('Rate limit status:', rateLimit);

// Warn if running low
if (rateLimit.remaining < 5) {
  console.warn('Approaching rate limit! Slowing down...');
}

class RateLimiter {
  constructor(maxPerSecond) {
    this.maxPerSecond = maxPerSecond;
    this.requests = [];
  }

  async throttle() {
    const now = Date.now();

    // Remove requests older than 1 second
    this.requests = this.requests.filter(time => now - time < 1000);

    // Wait if at limit
    if (this.requests.length >= this.maxPerSecond) {
      const oldestRequest = Math.min(...this.requests);
      const waitTime = 1000 - (now - oldestRequest);
      await new Promise(resolve => setTimeout(resolve, waitTime));
    }

    this.requests.push(Date.now());
  }
}

const limiter = new RateLimiter(10);  // 10 req/sec for Free tier

async function makeRequest(payload) {
  await limiter.throttle();
  return axios.post(endpoint, payload, {
    headers: { 'X-API-Key': apiKey }
  });
}

const PQueue = require('p-queue');

const queue = new PQueue({
  intervalCap: 10,  // Max 10 requests
  interval: 1000    // Per 1 second
});

async function queuedRequest(payload) {
  return queue.add(() =>
    axios.post(endpoint, payload, {
      headers: { 'X-API-Key': apiKey }
    })
  );
}

const cache = new Map();

async function cachedGetBalance(address) {
  const cacheKey = `balance:${address}`;

  // Check cache
  if (cache.has(cacheKey)) {
    const { data, timestamp } = cache.get(cacheKey);
    if (Date.now() - timestamp < 5000) {  // 5 second TTL
      return data;
    }
  }

  // Fetch fresh data
  const response = await axios.post(endpoint, {
    jsonrpc: '2.0',
    id: 1,
    method: 'getBalance',
    params: [address]
  }, {
    headers: { 'X-API-Key': apiKey }
  });

  // Update cache
  cache.set(cacheKey, {
    data: response.data,
    timestamp: Date.now()
  });

  return response.data;
}

// Scenario: DEX monitoring app
// - Poll 10 token prices every 5 seconds
// - Check transaction status 100 times/hour
// - Stream real-time trades via WebSocket

// Price polling
// 10 tokens × 12 polls/minute × 60 minutes × 24 hours = 172,800 requests/day
// 1 credit each = 172,800 credits/day

// Transaction checks
// 100 checks/hour × 24 hours = 2,400 requests/day
// 3 credits each = 7,200 credits/day

// WebSocket streaming
// Unlimited messages = 0 credits

// Total: 180,000 credits/day × 30 days = 5.4 million credits/month
// Recommended: Developer tier (10M credits/month)

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Invalid params: Account not found"
  },
  "id": 1
}

// Wrong - includes extra characters
const address = "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK\n";

// Correct - clean base58 string
const address = "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK";

// Check if account exists first
const response = await axios.post(endpoint, {
  jsonrpc: '2.0',
  id: 1,
  method: 'getAccountInfo',
  params: [address]
}, {
  headers: { 'X-API-Key': apiKey }
});

if (response.data.result.value === null) {
  console.log('Account does not exist');
} else {
  console.log('Account data:', response.data.result.value);
}

// Make sure you're on the right network
const endpoint = 'https://nexus.fortiblox.com/rpc';  // Mainnet
// vs
const endpoint = 'https://nexus.fortiblox.com/devnet/rpc';  // Devnet

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Invalid params: expected array of length 2, got 1"
  },
  "id": 1
}

// Wrong - missing commitment parameter
{
  method: 'getBalance',
  params: ['DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK']
}

// Correct - include configuration object
{
  method: 'getBalance',
  params: [
    'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
    { commitment: 'confirmed' }
  ]
}

// Wrong - slot as string
{
  method: 'getBlock',
  params: ['12345']
}

// Correct - slot as number
{
  method: 'getBlock',
  params: [12345]
}

// Wrong - invalid commitment
{
  method: 'getBalance',
  params: [address, { commitment: 'immediate' }]  // 'immediate' removed
}

// Correct - use valid commitment
{
  method: 'getBalance',
  params: [address, { commitment: 'confirmed' }]  // 'confirmed' or 'finalized'
}

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32602,
    "message": "Transaction not found"
  },
  "id": 1
}

// Send transaction
const signature = await sendTransaction(transaction);

// Wrong - query immediately
const tx = await getTransaction(signature);  // May not exist yet!

// Correct - wait for confirmation
await confirmTransaction(signature);
const tx = await getTransaction(signature);

// Free/Developer tiers may not have full history
// Professional tier: Unlimited history

// Check transaction age
const signature = '5w8Z...';
try {
  const tx = await getTransaction(signature);
} catch (error) {
  if (error.message.includes('not found')) {
    console.log('Transaction may be too old or pruned');
  }
}

// Wrong - truncated signature
const sig = "5w8ZHp";

// Correct - full base58 signature (87-88 chars)
const sig = "5w8ZHpn7VNpN8FwGcPqKq4KZv6b2CqKjW2BvmKw3fFqm8e9VnN6FwGcPqKq4KZv6b2CqKjW2BvmKw";

// Processed - Node has processed the transaction
// - Fastest (< 1 second)
// - Can be rolled back
// - Use for: Real-time UI updates

// Confirmed - Supermajority of cluster confirmed
// - Balanced (2-3 seconds)
// - Unlikely to roll back
// - Use for: Most applications (recommended)

// Finalized - Block is finalized
// - Slowest (10-15 seconds)
// - Cannot be rolled back
// - Use for: Critical transactions, compliance

// Trading app - use confirmed
const balance = await getBalance(address, { commitment: 'confirmed' });

// Financial audit - use finalized
const balance = await getBalance(address, { commitment: 'finalized' });

// Real-time dashboard - use processed
const balance = await getBalance(address, { commitment: 'processed' });

// Wrong - only gets first page
const response = await axios.get(
  'https://nexus.fortiblox.com/geyser/transactions?limit=100',
  { headers: { 'X-API-Key': apiKey } }
);
// Only returns 100 transactions!

// Correct - paginate through all results
async function getAllTransactions(filter) {
  let allTxs = [];
  let cursor = null;

  do {
    const url = cursor
      ? `https://nexus.fortiblox.com/geyser/transactions?limit=100&cursor=${cursor}`
      : `https://nexus.fortiblox.com/geyser/transactions?limit=100`;

    const response = await axios.get(url, {
      headers: { 'X-API-Key': apiKey }
    });

    allTxs = allTxs.concat(response.data.data);
    cursor = response.data.pagination?.nextCursor;
  } while (cursor);

  return allTxs;
}

// Wrong - using page numbers
const page2 = await fetch(`/geyser/transactions?page=2`);

// Correct - using cursor from previous response
const page1 = await fetch(`/geyser/transactions?limit=100`);
const nextCursor = page1.pagination.nextCursor;
const page2 = await fetch(`/geyser/transactions?limit=100&cursor=${nextCursor}`);

// Wrong - too fast
async function getAllPages() {
  let cursor = null;
  do {
    const response = await fetch(url + cursor);
    cursor = response.pagination.nextCursor;
  } while (cursor);  // Rate limited!
}

// Correct - add delays
async function getAllPages() {
  let cursor = null;
  do {
    const response = await fetch(url + cursor);
    cursor = response.pagination.nextCursor;
    await sleep(100);  // Respect rate limits
  } while (cursor);
}

// Recent transactions may not be indexed
const response = await axios.get(
  'https://nexus.fortiblox.com/geyser/transactions',
  { headers: { 'X-API-Key': apiKey } }
);

// Data typically available within 1-2 seconds
// If missing, wait and retry

// Wrong - no results because filters too narrow
const txs = await getTransactions({
  before: '2024-01-01',
  after: '2024-01-01',  // Same date
  type: 'transfer',
  minAmount: 1000000
});

// Correct - loosen filters
const txs = await getTransactions({
  after: '2024-01-01',
  type: 'transfer'
});

// Check API documentation for correct field names
// Fields are case-sensitive!

// Wrong
filter: { transaction_type: 'transfer' }

// Correct
filter: { type: 'transfer' }

// Slow - queries entire database
const txs = await getTransactions();

// Fast - narrows search space
const txs = await getTransactions({
  account: 'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK',
  after: '2024-01-01',
  limit: 100
});

// Slow - returns 10,000 rows
const txs = await getTransactions({ limit: 10000 });

// Fast - returns 100 rows
const txs = await getTransactions({ limit: 100 });

// Fast - indexed fields
const txs = await getTransactions({
  account: 'ADDRESS',      // Indexed
  slot: 12345,             // Indexed
  signature: 'SIGNATURE'   // Indexed
});

// Slow - unindexed fields
const txs = await getTransactions({
  memo: 'hello',           // Not indexed
  customField: 'value'     // Not indexed
});

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 60 });  // 60 second TTL

async function getCachedTransactions(account) {
  const cacheKey = `txs:${account}`;

  // Check cache
  let txs = cache.get(cacheKey);
  if (txs) return txs;

  // Fetch from API
  txs = await getTransactions({ account });

  // Store in cache
  cache.set(cacheKey, txs);

  return txs;
}

// Wrong - SQL syntax doesn't work
filter: { amount: '>= 1000' }

// Correct - use JSON operators
filter: { amount: { $gte: 1000 } }

// Wrong - invalid format
filter: { timestamp: '01/15/2024' }

// Correct - ISO 8601
filter: { timestamp: '2024-01-15T00:00:00Z' }

// Also correct - Unix timestamp
filter: { timestamp: 1705276800 }

// AND operation
filter: {
  type: 'transfer',
  amount: { $gte: 1000 },
  status: 'confirmed'
}

// OR operation
filter: {
  $or: [
    { type: 'transfer' },
    { type: 'swap' }
  ]
}

// NOT operation
filter: {
  type: { $ne: 'unknown' }
}

// Wrong - HTTP instead of WebSocket
const ws = new WebSocket('https://nexus.fortiblox.com/geyser/ws');

// Correct - Use wss:// protocol
const ws = new WebSocket('wss://nexus.fortiblox.com/geyser/ws');

# Test WebSocket connectivity
wscat -c wss://nexus.fortiblox.com/geyser/ws?api-key=YOUR_KEY

# If this fails, check:
# - Firewall allows port 443
# - Proxy supports WebSocket
# - Corporate network not blocking

// Check how many connections you have open
// Free/Developer: Max 5 connections
// Business/Professional: Max 250 connections

// Close unused connections
ws.close();

class ReconnectingWebSocket {
  constructor(url, options = {}) {
    this.url = url;
    this.reconnectDelay = 1000;
    this.maxReconnectDelay = 30000;
    this.connect();
  }

  connect() {
    this.ws = new WebSocket(this.url);

    this.ws.on('open', () => {
      console.log('Connected');
      this.reconnectDelay = 1000;  // Reset delay
    });

    this.ws.on('close', () => {
      console.log(`Reconnecting in ${this.reconnectDelay}ms...`);
      setTimeout(() => this.connect(), this.reconnectDelay);

      // Exponential backoff
      this.reconnectDelay = Math.min(
        this.reconnectDelay * 2,
        this.maxReconnectDelay
      );
    });

    this.ws.on('error', (error) => {
      console.error('WebSocket error:', error);
    });
  }
}

// Correct for browsers
const ws = new WebSocket(
  `wss://nexus.fortiblox.com/geyser/ws?api-key=${apiKey}`
);

// Correct for Node.js
const WebSocket = require('ws');
const ws = new WebSocket('wss://nexus.fortiblox.com/geyser/ws', {
  headers: {
    'X-API-Key': apiKey
  }
});

// Key must have 'geyser:stream' scope
// Verify in dashboard:
// https://nexus.fortiblox.com/api-keys

// Wrong - invalid JSON
ws.send('subscribe to slotUpdates');

// Correct - valid JSON-RPC
ws.send(JSON.stringify({
  jsonrpc: '2.0',
  id: 1,
  method: 'subscribe',
  params: ['slotUpdates']
}));

// Wrong - send before ready
const ws = new WebSocket(url);
ws.send(subscribeMsg);  // Error! Not connected yet

// Correct - wait for open event
const ws = new WebSocket(url);
ws.on('open', () => {
  ws.send(JSON.stringify({
    method: 'subscribe',
    params: ['slotUpdates']
  }));
});

ws.on('message', (data) => {
  const msg = JSON.parse(data);

  // Handle subscription confirmation
  if (msg.id === 1 && msg.result) {
    console.log('Subscribed with ID:', msg.result);
    subscriptionId = msg.result;
  }

  // Handle subscription updates
  if (msg.method === 'notification') {
    console.log('Update:', msg.params);
  }
});

// Each subscription counts toward connection limits
// Free: 5 subscriptions per connection
// Business: 250 subscriptions per connection

// Use filters to reduce subscription count
ws.send(JSON.stringify({
  method: 'subscribe',
  params: [{
    channel: 'accountUpdates',
    filters: {
      accounts: ['ADDRESS1', 'ADDRESS2', 'ADDRESS3']  // One sub for multiple accounts
    }
  }]
}));

// Wrong - treating message as string
ws.on('message', (data) => {
  console.log(data);  // [Object object]
  console.log(data.method);  // undefined
});

// Correct - parse JSON
ws.on('message', (data) => {
  const message = JSON.parse(data);
  console.log(message.method);  // 'notification'
});

ws.on('message', (data) => {
  const message = JSON.parse(data);

  // Subscription confirmation
  if (message.id && message.result) {
    console.log('Subscription confirmed:', message.result);
  }

  // Subscription update
  else if (message.method === 'notification') {
    console.log('Update:', message.params);
  }

  // Error
  else if (message.error) {
    console.error('Error:', message.error);
  }
});

function handleMessage(data) {
  try {
    const message = JSON.parse(data);

    // Validate structure
    if (!message.jsonrpc || message.jsonrpc !== '2.0') {
      console.warn('Invalid JSON-RPC message');
      return;
    }

    // Handle different types
    if (message.method === 'notification') {
      handleNotification(message.params);
    } else if (message.error) {
      handleError(message.error);
    } else if (message.result !== undefined) {
      handleResult(message.result);
    }
  } catch (error) {
    console.error('Failed to parse message:', error);
  }
}

curl -X POST https://nexus.fortiblox.com/rpc \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getHealth"
  }'

curl -v -X POST https://nexus.fortiblox.com/rpc \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSlot"
  }'

curl -X POST https://nexus.fortiblox.com/rpc \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlock",
    "params": [123456]
  }' \
  -o response.json

curl -w "\nTime: %{time_total}s\n" \
  -X POST https://nexus.fortiblox.com/rpc \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getHealth"
  }'

curl -H "X-API-Key: YOUR_KEY" \
  "https://nexus.fortiblox.com/geyser/transactions?limit=10"

# Install wscat
npm install -g wscat

# Connect to WebSocket
wscat -c "wss://nexus.fortiblox.com/geyser/ws?api-key=YOUR_KEY"

# Send subscription
> {"jsonrpc":"2.0","id":1,"method":"subscribe","params":["slotUpdates"]}

# Receive messages
< {"jsonrpc":"2.0","result":123,"id":1}
< {"jsonrpc":"2.0","method":"notification","params":{"subscription":123,"result":{"slot":123456}}}

const axios = require('axios');

async function debugRequest() {
  try {
    const response = await axios.post(
      'https://nexus.fortiblox.com/rpc',
      {
        jsonrpc: '2.0',
        id: 1,
        method: 'getHealth'
      },
      {
        headers: {
          'X-API-Key': process.env.FORTIBLOX_API_KEY,
          'Content-Type': 'application/json'
        },
        validateStatus: () => true  // Don't throw on error status
      }
    );

    console.log('Status:', response.status);
    console.log('Headers:', response.headers);
    console.log('Data:', response.data);

    // Check rate limit
    console.log('\nRate Limit Info:');
    console.log('  Limit:', response.headers['x-ratelimit-limit']);
    console.log('  Remaining:', response.headers['x-ratelimit-remaining']);
    console.log('  Reset:', new Date(response.headers['x-ratelimit-reset'] * 1000));

    // Check credits
    console.log('\nCredit Info:');
    console.log('  Used:', response.headers['x-credits-used']);
    console.log('  Remaining:', response.headers['x-credits-remaining']);

    // Check request ID
    console.log('\nRequest ID:', response.headers['x-request-id']);

  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

import requests
import os

def debug_request():
    response = requests.post(
        'https://nexus.fortiblox.com/rpc',
        json={
            'jsonrpc': '2.0',
            'id': 1,
            'method': 'getHealth'
        },
        headers={
            'X-API-Key': os.getenv('FORTIBLOX_API_KEY'),
            'Content-Type': 'application/json'
        }
    )

    print(f"Status: {response.status_code}")
    print(f"Headers: {dict(response.headers)}")
    print(f"Data: {response.json()}")

    # Check rate limit
    print("\nRate Limit Info:")
    print(f"  Limit: {response.headers.get('x-ratelimit-limit')}")
    print(f"  Remaining: {response.headers.get('x-ratelimit-remaining')}")
    print(f"  Reset: {response.headers.get('x-ratelimit-reset')}")

    # Check credits
    print("\nCredit Info:")
    print(f"  Used: {response.headers.get('x-credits-used')}")
    print(f"  Remaining: {response.headers.get('x-credits-remaining')}")

    # Check request ID
    print(f"\nRequest ID: {response.headers.get('x-request-id')}")

try {
  const response = await axios.post(endpoint, payload, {
    headers: { 'X-API-Key': apiKey }
  });

  // Success - log request ID
  const requestId = response.headers['x-request-id'];
  console.log('Request ID:', requestId);

} catch (error) {
  // Error - capture request ID from error response
  const requestId = error.response?.headers['x-request-id'];
  console.error('Request failed. Request ID:', requestId);
  console.error('Error:', error.response?.data);
}

function logError(error, context) {
  const requestId = error.response?.headers['x-request-id'];
  const errorInfo = {
    timestamp: new Date().toISOString(),
    requestId: requestId,
    endpoint: error.config?.url,
    method: error.config?.method,
    status: error.response?.status,
    error: error.response?.data,
    context: context
  };

  console.error('Error details:', JSON.stringify(errorInfo, null, 2));

  // Send to error tracking service
  // Sentry, Datadog, etc.
}

Subject: [Request ID: req_abc123] 500 Error on getTransaction

Hi FortiBlox Support,

I'm experiencing 500 errors when calling getTransaction:

Request ID: req_abc123xyz
Timestamp: 2024-01-15 14:30:00 UTC
API Key: fbx_e23728... (Developer tier)
Endpoint: POST https://nexus.fortiblox.com/rpc

Request:
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransaction",
  "params": ["5w8ZHp..."]
}

Response:
{
  "error": {
    "code": 500,
    "message": "Internal server error"
  }
}

This happens consistently for this transaction signature.
Other signatures work fine.

Can you help investigate?

Thanks,
[Your name]

async function measureLatency(method, params) {
  const start = Date.now();

  try {
    const response = await axios.post(endpoint, {
      jsonrpc: '2.0',
      id: 1,
      method: method,
      params: params
    }, {
      headers: { 'X-API-Key': apiKey }
    });

    const latency = Date.now() - start;
    console.log(`${method}: ${latency}ms`);

    return response.data;
  } catch (error) {
    const latency = Date.now() - start;
    console.error(`${method} failed after ${latency}ms:`, error.message);
    throw error;
  }
}

// Test different endpoints
await measureLatency('getHealth', []);
await measureLatency('getSlot', []);
await measureLatency('getBalance', ['ADDRESS']);

# Ping FortiBlox servers
ping nexus.fortiblox.com

# Measure HTTP latency
curl -w "\nTime: %{time_total}s\n" https://nexus.fortiblox.com/rpc

// getHealth should be < 100ms
// getSlot should be < 200ms
// getBalance should be < 300ms
// getBlock should be < 500ms

const benchmarks = {
  getHealth: 100,
  getSlot: 200,
  getBalance: 300,
  getBlock: 500
};

async function benchmark(method, params) {
  const latency = await measureLatency(method, params);
  const baseline = benchmarks[method];

  if (latency > baseline * 2) {
    console.warn(`${method} is ${latency}ms (expected < ${baseline}ms)`);
  }
}

const axios = require('axios');
const http = require('http');
const https = require('https');

const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 10,
  maxFreeSockets: 5,
  timeout: 60000
});

const client = axios.create({
  httpsAgent: agent,
  headers: { 'X-API-Key': apiKey }
});

// Reuse connections
await client.post(endpoint, payload);
await client.post(endpoint, payload);  // Reuses connection

const response = await axios.post(endpoint, payload, {
  headers: {
    'X-API-Key': apiKey,
    'Accept-Encoding': 'gzip, deflate'
  }
});

// Slow - returns full transaction
const tx = await getTransaction(signature);

// Fast - returns only signature status
const status = await getSignatureStatus(signature);

// Slow - 100 separate requests
for (let addr of addresses) {
  const balance = await getBalance(addr);
}

// Fast - 1 batch request
const balances = await getMultipleAccounts(addresses);

// Wrong - 5 second timeout
const response = await axios.post(endpoint, payload, {
  timeout: 5000
});

// Correct - 30 second timeout
const response = await axios.post(endpoint, payload, {
  timeout: 30000
});

// These calls can take 10+ seconds:
// - getBlock (full block)
// - getProgramAccounts (large program)
// - getTokenLargestAccounts

// Use longer timeout
const response = await axios.post(endpoint, {
  jsonrpc: '2.0',
  id: 1,
  method: 'getBlock',
  params: [slot]
}, {
  timeout: 60000,  // 60 seconds
  headers: { 'X-API-Key': apiKey }
});

// Test connectivity
const dns = require('dns').promises;

async function checkConnectivity() {
  try {
    // Resolve DNS
    const addresses = await dns.resolve('nexus.fortiblox.com');
    console.log('DNS resolved:', addresses);

    // Test connection
    const response = await axios.get('https://nexus.fortiblox.com', {
      timeout: 5000
    });
    console.log('Connection OK');

  } catch (error) {
    console.error('Connectivity issue:', error.message);
  }
}

async function requestWithTimeout(payload, timeout = 30000) {
  const maxRetries = 3;

  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await axios.post(endpoint, payload, {
        timeout: timeout,
        headers: { 'X-API-Key': apiKey }
      });
      return response.data;

    } catch (error) {
      if (error.code === 'ETIMEDOUT' && i < maxRetries - 1) {
        console.log(`Timeout. Retrying... (${i + 1}/${maxRetries})`);
        await sleep(1000 * (i + 1));
      } else {
        throw error;
      }
    }
  }
}

function timeoutPromise(ms, promise) {
  return Promise.race([
    promise,
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error('Timeout')), ms)
    )
  ]);
}

// Use it
try {
  const result = await timeoutPromise(5000, makeRequest());
} catch (error) {
  console.error('Request timed out after 5 seconds');
}

// Bad - polling every second (60 req/min)
setInterval(async () => {
  const slot = await getSlot();
  updateUI(slot);
}, 1000);

// Good - WebSocket subscription (0 credits!)
const ws = new WebSocket('wss://nexus.fortiblox.com/geyser/ws?api-key=KEY');
ws.send(JSON.stringify({
  method: 'subscribe',
  params: ['slotUpdates']
}));
ws.on('message', (data) => {
  const msg = JSON.parse(data);
  if (msg.method === 'notification') {
    updateUI(msg.params.result.slot);
  }
});

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 10 });  // 10 second cache

async function getCachedSlot() {
  let slot = cache.get('current-slot');

  if (!slot) {
    slot = await getSlot();
    cache.set('current-slot', slot);
  }

  return slot;
}

// Bad - 3 separate requests
const balance = await getBalance(addr);
const tokenBalance = await getTokenAccountBalance(tokenAddr);
const nfts = await getNFTsByOwner(addr);

// Good - parallel requests
const [balance, tokenBalance, nfts] = await Promise.all([
  getBalance(addr),
  getTokenAccountBalance(tokenAddr),
  getNFTsByOwner(addr)
]);

// Processed - fastest, least secure
const slot = await getSlot({ commitment: 'processed' });

// Confirmed - balanced (recommended)
const balance = await getBalance(addr, { commitment: 'confirmed' });

// Finalized - slowest, most secure
const tx = await getTransaction(sig, { commitment: 'finalized' });

// Track slow endpoints
const metrics = {
  totalRequests: 0,
  totalLatency: 0,
  slowRequests: []
};

async function monitoredRequest(method, params) {
  const start = Date.now();
  metrics.totalRequests++;

  try {
    const result = await makeRequest(method, params);
    const latency = Date.now() - start;
    metrics.totalLatency += latency;

    // Log slow requests
    if (latency > 1000) {
      metrics.slowRequests.push({ method, latency, timestamp: new Date() });
    }

    return result;
  } catch (error) {
    throw error;
  }
}

// View metrics
console.log('Average latency:', metrics.totalLatency / metrics.totalRequests);
console.log('Slow requests:', metrics.slowRequests);