Performance & Scaling

Copy

• Copy for LLM

  Copy page as Markdown for LLMs
• View as Markdown

  Open this page as Markdown
• Open in ChatGPT

  Get insights from ChatGPT
• Open in Claude

  Get insights from Claude

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 73
X-RateLimit-Reset: 1609459200

async function queryWithRetry(query, variables, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await client.request(query, variables);
    } catch (error) {
      if (error.response?.status === 429) {
        const delay = Math.min(1000 * Math.pow(2, i), 60000); // Cap at 60s
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
  throw new Error('Rate limit exceeded after retries');
}

let remainingQuota = 100;

async function trackRateLimit(query, variables) {
  const response = await fetch('https://graph.kadindexer.io', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ query, variables })
  });
  
  remainingQuota = parseInt(response.headers.get('X-RateLimit-Remaining'));
  
  if (remainingQuota < 10) {
    console.warn('Approaching rate limit:', remainingQuota);
  }
  
  return response.json();
}

import NodeCache from 'node-cache';

// Separate caches for different TTLs
const permanentCache = new NodeCache({ stdTTL: 0 }); // Never expires
const balanceCache = new NodeCache({ stdTTL: 300 }); // 5 minutes
const recentCache = new NodeCache({ stdTTL: 60 });   // 1 minute

async function getBlock(height, chainId) {
  const key = `block_${chainId}_${height}`;
  
  // Check if finalized (height < currentHeight - 20)
  const currentHeight = await getCurrentChainHeight(chainId);
  const isFinalized = height < (currentHeight - 20);
  
  if (isFinalized) {
    const cached = permanentCache.get(key);
    if (cached) return cached;
  }
  
  const result = await client.request(blockQuery, { height, chainId });
  
  if (isFinalized) {
    permanentCache.set(key, result);
  } else {
    recentCache.set(key, result);
  }
  
  return result;
}

async function getAccountBalance(accountName, chainId) {
  const key = `balance_${accountName}_${chainId}`;
  
  const cached = balanceCache.get(key);
  if (cached) return cached;
  
  const result = await client.request(balanceQuery, { accountName, chainId });
  balanceCache.set(key, result);
  
  return result;
}

import { GraphQLClient } from 'graphql-request';

const client = new GraphQLClient('https://graph.kadindexer.io', {
  headers: {
    'Cache-Control': 'max-age=300', // 5 minutes
  }
});

import { GraphQLClient } from 'graphql-request';

// Create one client, reuse for all queries
const client = new GraphQLClient('https://graph.kadindexer.io', {
  keepalive: true,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// Export for reuse across your app
export async function queryKadindexer(query, variables) {
  return client.request(query, variables);
}

import { createClient } from 'graphql-ws';

class SubscriptionManager {
  constructor() {
    this.client = createClient({
      url: 'wss://graph.kadindexer.io/graphql',
      keepAlive: 10000,
      retryAttempts: 5
    });
    this.activeSubscriptions = new Map();
  }
  
  subscribe(query, variables, onData) {
    const key = `${query}_${JSON.stringify(variables)}`;
    
    // Reuse existing subscription
    if (this.activeSubscriptions.has(key)) {
      return this.activeSubscriptions.get(key);
    }
    
    const unsubscribe = this.client.subscribe(
      { query, variables },
      {
        next: onData,
        error: (err) => console.error('Subscription error:', err),
        complete: () => this.activeSubscriptions.delete(key)
      }
    );
    
    this.activeSubscriptions.set(key, unsubscribe);
    return unsubscribe;
  }
  
  cleanup() {
    this.activeSubscriptions.forEach(unsub => unsub());
    this.activeSubscriptions.clear();
    this.client.dispose();
  }
}

// Usage
const manager = new SubscriptionManager();

manager.subscribe(
  newBlocksQuery,
  { chainIds: ['0', '1'], quantity: 20 },
  (data) => console.log('New blocks:', data)
);

const metrics = {
  requestsPerMinute: 0,
  avgResponseTime: 0,
  errorRate: 0,
  cacheHitRate: 0,
  complexityUsage: 0
};

// Track request metrics
async function monitoredRequest(query, variables) {
  const start = Date.now();
  metrics.requestsPerMinute++;
  
  try {
    const result = await client.request(query, variables);
    const duration = Date.now() - start;
    
    // Moving average
    metrics.avgResponseTime = 
      (metrics.avgResponseTime * 0.9) + (duration * 0.1);
    
    return result;
  } catch (error) {
    metrics.errorRate++;
    throw error;
  }
}

// Example: Alert when approaching rate limit
function checkMetrics() {
  if (remainingQuota < (rateLimit * 0.2)) {
    alertTeam('Approaching rate limit: ' + remainingQuota);
  }
  
  if (metrics.avgResponseTime > 1000) {
    alertTeam('High response times: ' + metrics.avgResponseTime + 'ms');
  }
  
  if (metrics.errorRate > 0.01) {
    alertTeam('High error rate: ' + (metrics.errorRate * 100) + '%');
  }
}

setInterval(checkMetrics, 60000); // Check every minute

async function initializeApp() {
  const networkInfo = await client.request(`
    query {
      networkInfo {
        networkId
        numberOfChains
        nodeChains
        coinsInCirculation
      }
      graphConfiguration {
        version
        minimumBlockHeight
      }
    }
  `);
  
  permanentCache.set('network_info', networkInfo);
}

// ❌ Sequential (slow, uses more rate limit)
for (const chainId of ['0', '1', '2']) {
  await getChainActivity(chainId);
}

// ✅ Batched (fast, single request)
const result = await client.request(`
  query {
    c0: transactions(chainId: "0", first: 10) { ... }
    c1: transactions(chainId: "1", first: 10) { ... }
    c2: transactions(chainId: "2", first: 10) { ... }
  }
`);

async function loadAccountDashboard(accountName) {
  // 1. Fast: Show balance immediately
  const summary = await client.request(`
    query {
      fungibleAccount(accountName: "${accountName}") {
        totalBalance
      }
    }
  `);
  
  renderBalance(summary);
  
  // 2. Background: Load transaction history
  const history = await client.request(`
    query {
      fungibleAccount(accountName: "${accountName}") {
        transactions(first: 20) {
          edges {
            node {
              hash
              cmd { meta { creationTime sender } }
            }
          }
        }
      }
    }
  `);
  
  renderHistory(history);
}

import debounce from 'lodash/debounce';

const searchTransactions = debounce(async (searchTerm) => {
  const result = await client.request(query, { 
    accountName: searchTerm 
  });
  updateUI(result);
}, 500); // Wait 500ms after user stops typing

complexity = base_value × (first × nested_first × ...)

query {
  blocks(first: 50) {              # 50
    edges {
      node {
        transactions(first: 20) {  # 50 × 20 = 1,000
          edges {
            node {
              result {
                ... on TransactionResult {
                  events(first: 10) { # 1,000 × 10 = 10,000 (exceeds free tier!)
                    edges { node { parameters } }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

# Query 1: Get blocks
query { blocks(first: 50) { edges { node { hash height } } } }

# Query 2: Get transactions for specific block
query { 
  block(hash: "ABC123") { 
    transactions(first: 50) { ... } 
  } 
}

# Instead of first: 100
query {
  blocks(first: 20) {
    edges {
      node {
        transactions(first: 20) { ... }
      }
    }
  }
}