QUANTARA • QUANTUM-RESISTANT L1
RPC guide for Quantara Devnet-0
How to connect wallets, CLIs, and applications to Quantara Devnet-0 — including official endpoints, example clients, and production-minded best practices.
Docs • Integrations
RPC guide for Quantara Devnet-0
A practical overview of how to talk to Quantara via JSON-RPC: endpoints, connection patterns, and example snippets that are safe to reuse in your own tooling.
Quantara Devnet-0 exposes a Substrate-compatible JSON-RPC interface over HTTP and WebSocket. If you've built against Polkadot or Kusama before, everything here should feel familiar.
This guide focuses on read / write RPC usage for wallets, explorers, and app backends. For validator-specific flows (keys, sessions, staking), pair this with the Validator runbook and Devnet-0 launch checklist.
Devnet-0 is intentionally small and fast-moving. Endpoints may be rotated or throttled as we harden the network. Always check the Status page for the latest word on RPC health, maintenance windows, and deprecations.
Devnet-0 RPC snapshot
Last updated: 2025-11-23 22:00 UTC. For live endpoint status and any temporary caps or maintenance, always defer to the Status page.
1 • Endpoints
Official Devnet-0 RPC endpoints
Use these endpoints for early integrations, testing, and demos. For anything user-facing or production-adjacent, strongly consider running your own node.
1.1 — Public HTTP
- • Base URL: https://rpc.devnet-0.quantarablockchain.com/http
- • Best for one-off reads and backend calls.
- • Avoid heavy polling; prefer batched requests.
- • Expect light rate limits during busy windows.
1.2 — Public WebSocket
- • Base URL: wss://rpc.devnet-0.quantara.xyz
- • Use for subscriptions (new heads, storage).
- • Multiplex many logical requests on one socket.
- • Close idle connections instead of leaving them open.
1.3 — Running your own RPC node
- • Recommended for wallets, indexers, and infra providers.
- • Follow the Localnet & node guide for setup.
- • Expose HTTP/WS behind your own proxy and rate limits.
- • Mirror configs from the Devnet-0 release notes.
2 • Quick start
Using @polkadot/api with Quantara
Most JavaScript and TypeScript apps will use @polkadot/api. Here’s a minimal Devnet-0 client you can paste into your own codebase.
2.1 — Minimal TypeScript client
Install @polkadot/api and use the WebSocket endpoint:
import { ApiPromise, WsProvider } from "@polkadot/api";
async function main() {
const provider = new WsProvider("wss://rpc.devnet-0.quantara.xyz");
const api = await ApiPromise.create({ provider });
const [chain, nodeName, nodeVersion, header] = await Promise.all([
api.rpc.system.chain(),
api.rpc.system.name(),
api.rpc.system.version(),
api.rpc.chain.getHeader(),
]);
console.log(`Connected to ${chain} via ${nodeName} v${nodeVersion}`);
console.log("Best block:", header.number.toString());
}
main().catch((err) => {
console.error(err);
process.exit(1);
});2.2 — Browser / wallet integrations
- • For browser apps, prefer a backend proxy instead of talking directly to public RPC from untrusted clients.
- • When integrating browser wallets, treat Quantara Devnet-0 as a custom network with QTR / 12 / SS58=73.
- • See the Integration guide for full client configuration examples.
If your app needs long-lived subscriptions or high request volume, you should run your own RPC node or cluster rather than relying on shared public endpoints.
3 • Patterns
Request patterns, subscriptions & rate limits
Devnet-0 is a rehearsal for mainnet-scale traffic. Build good habits now so your app is ready when volume increases.
3.1 — Prefer subscriptions
- • Use WebSocket + subscriptions for live data.
- • Examples:
chain_subscribeNewHeadsorstate_subscribeStorage. - • Avoid polling head or balances every second over HTTP.
- • Unsubscribe when views are closed.
3.2 — Batching & caching
- • Batch related calls into a single JSON-RPC request.
- • Cache static data (metadata, constants, type info) at your edge.
- • Share one client / connection per process where safe.
- • For indexing, prefer dedicated indexers over hot RPC loops.
3.3 — Rate limits & fairness
- • Public RPCs may rate-limit abusive patterns.
- • 429 / 5xx errors are signals to back off and retry.
- • Long-running workloads should use a private endpoint.
- • If you're unsure about your usage profile, reach out before mainnet.
4 • Common calls
Common JSON-RPC methods on Quantara
A small set of methods will cover most Devnet-0 use cases. Use this as a mental map; full details live in the RPC docs and type metadata.
chain_getHeader
Get the latest block header or a specific hash.
{"method":"chain_getHeader","params":[],"id":1,"jsonrpc":"2.0"}system_health
High-level health info for a node: peers, sync, etc.
{"method":"system_health","params":[],"id":2,"jsonrpc":"2.0"}state_getStorage
Read raw storage keys (e.g., balances, system account info) at a given block.
{"method":"state_getStorage","params":["<storage-key>"],"id":3,"jsonrpc":"2.0"}payment_queryInfo
Estimate fees for a signed extrinsic before submitting.
{"method":"payment_queryInfo","params":["0x...signedExtrinsic"],"id":4,"jsonrpc":"2.0"}For a deeper catalog of pallets and runtime calls, pair this page with the Benchmarks & runtime guide and the runtime metadata exposed via the RPC itself.
5 • Troubleshooting
When RPC calls fail or behave strangely
Most issues fall into a few buckets: connectivity, version mismatches, or overloaded endpoints. Start with these checks before assuming a protocol bug.
5.1 — Quick checks
- • Confirm you're using the current RPC URL.
- • Check /status for ongoing incidents.
- • Compare behaviour against another node or region.
- • Verify your client (e.g., @polkadot/api) matches the runtime version — old metadata can cause subtle issues.
5.2 — Deeper debugging
- • Review the Troubleshooting and Known Issues docs for recurrent patterns.
- • Capture request / response samples and relevant logs.
- • Share concise reports (what changed, when, which endpoint) in the builder / validator channels.
- • If you suspect a protocol bug, include block hashes and runtime versions.
Next steps
From Devnet-0 experiments to production integrations
Once your app can reliably talk to Devnet-0, you’re one step away from public testnet and mainnet integrations.
For end-to-end examples that combine RPC, wallets, and the Devnet-0 faucet, read the Wallet & Faucet runbook and Integration guide.
If you're building something serious on Quantara, let us know. The more we understand your RPC patterns now, the better we can design Devnet-0, public testnet, and mainnet infrastructure around real-world workloads.