HyperCore Info Endpoint

curl -X POST 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info' \
  -H 'Content-Type: application/json' \
  -d '{"type":"meta"}'

{
  "type": "ENDPOINT_TYPE",
  "param1": "value1",
  "param2": "value2"
}

curl -X POST 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info' \
  -H 'Content-Type: application/json' \
  -d '{"type":"meta"}'

curl -X POST 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info' \
  -H 'Content-Type: application/json' \
  -d '{
    "type": "clearinghouseState",
    "user": "0x63E8c7C149556D5f34F833419A287bb9Ef81487f"
  }'

{
  "error": "Error message description",
  "code": "ERROR_CODE"
}

async function queryEndpoint(payload, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(
        'https://api-hyperliquid-mainnet-info.n.dwellir.com/info',
        {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify(payload)
        }
      );

      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      return await response.json();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
    }
  }
}

// Cache meta data for 1 hour
const metaCache = new Map();
const META_TTL = 3600000; // 1 hour in ms

async function getMeta() {
  const cached = metaCache.get('meta');
  if (cached && Date.now() - cached.timestamp < META_TTL) {
    return cached.data;
  }

  const data = await queryEndpoint({ type: 'meta' });
  metaCache.set('meta', { data, timestamp: Date.now() });
  return data;
}

const response = await fetch(url, options);
const remaining = response.headers.get('X-RateLimit-Remaining');
const reset = response.headers.get('X-RateLimit-Reset');

if (parseInt(remaining) < 10) {
  console.warn('Approaching rate limit');
}

const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 10000); // 10s timeout

try {
  const response = await fetch(url, {
    ...options,
    signal: controller.signal
  });
  return await response.json();
} finally {
  clearTimeout(timeout);
}

import requests
from typing import Dict, Any

ENDPOINT = 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info'

def query_info_endpoint(endpoint_type: str, params: Dict[str, Any] = None) -> Dict:
    """Query the HyperCore Info Endpoint"""
    payload = {"type": endpoint_type}
    if params:
        payload.update(params)

    headers = {
        'Content-Type': 'application/json',
    }

    response = requests.post(ENDPOINT, json=payload, headers=headers, timeout=10)
    response.raise_for_status()
    return response.json()

# Get metadata
meta = query_info_endpoint('meta')
print(f"Available pairs: {len(meta['universe'])}")

# Get user account state
user_state = query_info_endpoint(
    'clearinghouseState',
    {'user': '0x63E8c7C149556D5f34F833419A287bb9Ef81487f'}
)
print(f"Account value: {user_state['marginSummary']['accountValue']}")

const ENDPOINT = 'https://api-hyperliquid-mainnet-info.n.dwellir.com/info';

interface InfoRequest {
  type: string;
  [key: string]: any;
}

async function queryInfoEndpoint<T>(request: InfoRequest): Promise<T> {
  const response = await fetch(ENDPOINT, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(request)
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
  }

  return await response.json();
}

// Get metadata
const meta = await queryInfoEndpoint({ type: 'meta' });
console.log(`Available pairs: ${meta.universe.length}`);

// Get user state
const userState = await queryInfoEndpoint({
  type: 'clearinghouseState',
  user: '0x63E8c7C149556D5f34F833419A287bb9Ef81487f'
});
console.log(`Account value: ${userState.marginSummary.accountValue}`);