Quantara • Devnet-0
Devnet-0 is liveView global status

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-0RPC / JSON-RPCQTR • 12 decimals • SS58=73

Devnet-0 RPC snapshot

NetworkDevnet-0
Token / Decimals / SS58QTR / 12 / 73
HTTP RPChttps://rpc.devnet-0.quantarablockchain.com/http
WS RPCwss://rpc.devnet-0.quantara.xyz
Explorerhttps://explorer.devnet-0.quantara.xyz

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_subscribeNewHeads or state_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.