The read layer for Solana

Elgon is a decentralized, geo-distributed read-RPC for Solana. Every response ships with verifiable freshness and a signed proof-of-serve receipt, so your app and your agents can trust the data they read — not just the node that served it.

Quickstart

Send your first request in under a minute. Elgon speaks standard Solana JSON-RPC over HTTPS.

curl https://rpc.elgonrpc.xyz \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ELGON_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getBalance",
       "params":["FrqXyz…owner"]}'

{
  "jsonrpc": "2.0",
  "result": { "context": { "slot": 301774112 }, "value": 194837520 },
  "freshness": { "servedAtSlot": 301774112, "lagSlots": 0 },
  "receipt": "elg1:9f2c…a71b"        // signed proof-of-serve
}

Authentication

Every request is authenticated with an API key passed as a bearer token. Create keys and set access tiers in your dashboard.

Authorization: Bearer $ELGON_API_KEY

Endpoints

Regional edges are selected automatically; you always call the same hostname.

RPC methods

Elgon supports the full Solana read surface. A few of the most-used:

Verifiable freshness

Each response includes a freshness object: the slot the data was served at and how many slots it lags head. Reject stale reads by asserting a max lag:

const r = await elgon.getAccountInfo(pubkey, { maxLagSlots: 2 });
if (r.freshness.lagSlots > 2) throw new Error("stale read");

Proof-of-serve receipts

Every response is signed by the serving node. The receipt lets any party verify — offline — that the payload is authentic and was served at the claimed slot. Operators bond stake; a bad receipt is slashable.

import { verifyReceipt } from "elgon-rpc-sdk";
const ok = await verifyReceipt(response.receipt, response.result);
// ok === true → data is authentic & fresh

Networks & chains

Elgon serves Solana mainnet-betadevnet today, with more SVM networks rolling out. Select a network per-key or per-request with the X-Elgon-Network header.

SDKs

Use the official SDK, or any Solana client (web3.js, Kit) pointed at the Elgon endpoint.

npm i elgon-rpc-sdk

import { Elgon } from "elgon-rpc-sdk";
const elgon = new Elgon({ apiKey: process.env.ELGON_API_KEY });
const bal = await elgon.getBalance("FrqXyz…owner");

import { Connection } from "@solana/web3.js";
const conn = new Connection("https://rpc.elgonrpc.xyz", {
  httpHeaders: { Authorization: `Bearer ${process.env.ELGON_API_KEY}` }
});

Webhooks

Subscribe to account and program changes; Elgon pushes signed events to your endpoint, each carrying its own proof-of-serve receipt so you can trust the payload without re-querying.

Wallet recipes

Common flows — portfolio balances, token holdings, activity history — are available as batched, cache-friendly recipes that fan out reads across the mesh and return in a single round-trip.

Agents & MPP

Autonomous agents are read-heavy: they watch state before acting, at high volume, and need answers they can verify. Elgon is the read layer for agents — validators are the write layer. Machine-payable (MPP / x402) access lets agents pay per verified read.

Rate limits & tiers

FAQ

Is Elgon compatible with my existing Solana code?

Yes — it implements the standard JSON-RPC. Change the endpoint URL and add your API key; everything else stays the same.

What makes a read “verifiable”?

Each response is signed and stamped with the slot it was served at. You can verify locally that the data is authentic and current, instead of trusting a single node.

What happens if a node serves bad data?

Operators bond stake to serve. An invalid proof-of-serve receipt is slashable, aligning incentives toward honest, fresh reads.