What is Quantum Matrix Chain?

Quantum Matrix Chain (QMC) is a standalone Layer 1 blockchain built by WeAD. It is quantum-resistant today: every wallet, vote, and header is signed with Dilithium (NIST ML-DSA-44, FIPS 204). It is quantum-measured, not quantum-powered: every new block carries a GUE bind and a C_s / K(t) spectral extract that validators recompute, and the live extract runs on a labelled quantum-sim backend. No block is produced on quantum hardware today; hardware_poq is false on every live block and stays so until a measured hardware epoch exists. Randomness is ANU QRNG when the pool has bytes and a labelled CSPRNG otherwise — the API says which.

Property	Value
Token	QWD (Quantum WeAD)
Decimals	6
Total Supply	8,100,000,000 QWD
Block Time	~30 seconds
Consensus	ceil(2n/3) Dilithium validator votes + spectral bind (GUE + C_s/K(t)) — 4 WeAD validators, quorum 3
Signatures	Dilithium (ML-DSA-44, FIPS 204)
Chain ID	7771 (mainnet) / 7772 (testnet)
Base Fee	0.001 QWD
Minimum Stake	10,000 QWD

Why We're Building This

Here's the uncomfortable truth most of Web3 is ignoring: quantum computers are an existential threat to every blockchain in existence today.

The Quantum Threat to Crypto

Two quantum algorithms, both already proven in theory and being scaled in hardware, can dismantle the cryptographic foundations that every major blockchain depends on:

Shor's Algorithm — Breaks wallet security

Every blockchain wallet — Bitcoin, Ethereum, Solana, and other legacy chains — uses elliptic curve cryptography (ECDSA/EdDSA) to generate private keys from public keys. The security assumption is simple: deriving a private key from a public key is mathematically infeasible for classical computers.

Shor's algorithm destroys that assumption. A sufficiently powerful quantum computer running Shor's algorithm can derive your private key directly from your public key. Every wallet that has ever broadcast a transaction has exposed its public key on-chain. That means every active wallet on every major blockchain is a target — not hypothetically, but mathematically.

Impact: Any wallet with an exposed public key can be drained. All EVM signatures become forgeable. The entire trust model of Web3 collapses.

Grover's Algorithm — Breaks mining and hash security

Proof of Work blockchains like Bitcoin rely on SHA-256 hashing to secure mining. The assumption is that finding valid hashes requires brute-force computation, and no shortcut exists.

Grover's algorithm provides that shortcut. It offers a quadratic speedup on brute-force search, effectively cutting SHA-256's security from 256 bits to 128 bits. A quantum-equipped miner could find valid blocks exponentially faster than classical miners, dominating hash rate and opening the door to 51% attacks — the ability to rewrite transaction history, double-spend, and censor blocks.

Impact: Proof of Work consensus becomes compromised. Mining centralises around whoever has quantum hardware first.

The Timeline Is Closer Than You Think

Event	Date
NIST finalises post-quantum cryptography standards (FIPS 203/204/205)	August 2024
Industry projections for cryptographically relevant quantum computers (CRQCs)	2027 — 2033
Australia's ASD mandates post-quantum migration	By 2030
NIST prohibits classical cryptography (RSA, ECDSA, DSA)	By 2035

The window between "quantum computers can break crypto" and "everyone has migrated to quantum-safe crypto" is where catastrophic losses happen. Billions of dollars in wallets, smart contracts, and bridges will be vulnerable during that gap.

What QMC Does Differently

The Matrix Quantum Chain doesn't patch the problem — it was built from the ground up to be immune to it:

Lattice-based signatures replace ECDSA — Every QMC wallet uses post-quantum cryptography approved by NIST. Shor's algorithm cannot derive private keys from these signatures. Not today, not ever.
Votes, not a hash race — Blocks finalise on ceil(2n/3) Dilithium validator votes. There is no mining, so Grover's algorithm has nothing to speed up. The proposer seed is ANU QRNG when the pool is live and a labelled CSPRNG otherwise; the API never stamps quantum: true on CSPRNG.
A spectral bind on every block — Each block carries a GUE bind and a C_s / K(t) extract that every validator recomputes from the seed. Today that extract runs on a labelled quantum-sim backend. It is a recomputable statistical commitment, not a claim that a QPU produced the block. Hardware PoQ epochs are defined and off until a measured hardware backend exists.

Most blockchains will need to hard-fork to survive the quantum era. QMC signs with Dilithium from genesis. What it does not claim: three continents, a partner operator, or hardware behind live blocks.

Architecture

QMC uses three layers of quantum technology:

Dilithium Signatures — Every wallet and transaction is signed using lattice-based cryptography (NIST ML-DSA standard). Immune to Shor's algorithm.
Quantum Random Number Generation — The proposer seed comes from ANU's quantum vacuum QRNG when the pool has bytes. When ANU is rate-limited the seed comes from a CSPRNG and the block is labelled quantum: false, source: csprng-fallback. Check /api/qchain/status → qrng for the live state.
Spectral bind — New blocks carry a GUE bind and a C_s / K(t) extract. Live extract is labelled quantum-sim. Wukong is not stamped on sim. Hardware PoQ is off until a measured hardware epoch exists.

The chain also features:

WebSocket P2P networking for decentralized block/transaction propagation
A stack-based smart contract VM with the QWD-20 token standard
A lock-and-mint bridge to Soneium
An encrypted browser wallet with dApp injection (window.qmc)

Networks

Network	Chain ID	P2P Port	RPC Endpoint	Faucet
Mainnet	7771	9900	`https://wead.live/rpc`	1,000 QWD / hour
Testnet	7772	9901	`https://wead.live/rpc-testnet`	10,000 QWD from the testnet minter pool

Mainnet is chain 7771. Testnet is a separate process (chain 7772, P2P 9901, RPC /rpc-testnet). REST: /api/qchain-testnet/status.

Threat model (honest)

Shor — Dilithium (ML-DSA-44) on QMC keys. This is the protection.
Grover — hashed addresses / SHA-256. Not a special QMC feature.
QRNG — ANU when the pool has bytes (quantum: true). Otherwise CSPRNG and we do not call it quantum.
Soneium wrap — ECC. Liquidity, not the security root.
Operators — 2-of-3 Dilithium votes. Remote validators can vote over P2P ws://wead.live:9900. P2P handshake is Dilithium. A second WeAD host votes over P2P. Not an external partner org. Not three continents.
Riemann GUE — Live GUE bind required on new blocks. Dilithium still signs. Paper /qmc-white-paper.
QSM header — New blocks carry a 4×4 epoch matrix (tx roots, validator set, spectral commitment, previous digest). Header Dilithium is one ML-DSA-44 over that digest. Votes still sign the block hash. FIPS 204 parameter set is unchanged. Domain-separation strings are not published here.
Statistical windows — Public KS / Σ² / K(t) table a verifier can rerun. Bind stays M=32. Extract stays n=6 (not Haar). Full QPE is not on the 30s path.
Hardware epochs — Two epoch types: sim and hardware. Sim cannot mint hardware rewards. quantum-sim is never hardware PoQ. Wukong is not stamped on sim extract. ANU empty ⇒ quantum: false.

Riemann spectral filter (Phase I testbed)

The Montgomery–Odlyzko law says unfolded Riemann zeros track GUE spacings. QMC’s new layer uses the Wigner surmise

P(s) ≈ (32/π²) s² exp(−4s²/π)

as a spectral receipt on the Signature Matrix and related labs. New blocks must carry a matching GUE bind or they are rejected. Dilithium votes still sign (2of3_dilithium_votes). Paper: /qmc-white-paper.

GET /api/quantum/spectral/status — model + honesty flags
POST /api/quantum/spectral/gue — body {"mode":"gue"|"poisson"|"zeta"|"seed"|"values","n":48,"seed":"...","values":[...]}

Spectral extraction operator (Phase I)

Full QPE is not the consensus gadget. New blocks carry a C_s / K(t) extract bind and a GUE bind. Validators recompute the bind. The live receipt is labelled quantum-sim and is not hardware PoQ. Circuit family, seed-derivation constants, and Dilithium domain-separation strings are not published here. They unlock when independent verifiers are chosen.

GET /api/quantum/spectral/verifiers — node-pack switch (OFF until verifiers are chosen)
GET /api/quantum/spectral/protocol — deep spec (403 while switch is OFF)
POST /api/quantum/spectral/extract — labelled sim lab, not node source
GET /api/quantum/spectral/windows — public ε table (KS, Σ², K(t)); not gated on the switch
GET /api/quantum/spectral/windows/rerun?seed=… — rerun one seed against that table

Rotate C_s if a named classical algorithm under a published cost produces a passing K(t).

Statistical windows (Phase E)

Phase E is live. The spectral battery is a public table a verifier can rerun without the node pack. Bind size stays M=32. Extract stays n=6 — that is not Haar, and the extract GUE verdict stays informational. Full QPE is not on the 30-second path.

KS — Wigner vs Poisson at M=32. Published ε: ks_gue < 0.22 and ks_gue + 0.02 < ks_poisson. This is a statistic. Bind match is consensus; an unlucky KS does not skip a height.
Number variance Σ² — L=1,2,3. GUE is logarithmic; Poisson is Σ²(L)=L. Published as a window, not a skip rule.
K(t) ramp — K(t) = |Tr(U^t)|² / N with N = 2^n = 64, t=1..12 on the live C_s brickwork, contrasted with a diagonal-phase (circular Poisson) fake. Reference values with this normalisation: Haar CUE ⟨K(t)⟩ = min(t, N)/N (0.0156 at t=1, ramp to 1 at t=N); i.i.d. diagonal phases ⟨K(t)⟩ = 1 for all t. Published table means are 16–32 draw samples, so the diagonal column scatters around 1 and the C_s column sits below the Haar line — that is finite-sample spread and a non-Haar family, not a normalisation bug.

Reading the numbers. Wigner surmise (β=2) CDF used for KS: F(s) = erf(2s/√π) − (4s/π)·e^{−4s²/π}, mean spacing 1. Poisson: 1 − e^{−s}. Spacings are circular on 2ⁿ=64 eigenphases and unfolded to mean 1 before KS. Σ²(1) for exact GUE is ≈0.34 (sine kernel) / 0.44 (large-L asymptote); the live GUE median ≈0.39 is M=32 with sample-edge unfolding. Poisson gives Σ²(L)=L. Audited 2 Sep 2026.

Named classical family: 1D MPS / tensor-train contraction of the C_s brickwork. Cost X = χ* = 64, plus the exact dense 2³ⁿ baseline (cost ~ n · depth · χ³). At live n=6 a laptop wins. That is written on purpose.

C_s rotation rule: if a named algorithm under cost X produces a passing K(t) after the family is no longer a classically-trivial toy, publish cs-kt-vN+1. Historical seals keep their model id and still verify. Current family cs-kt-v1 is not rotated — rotating the toy does not change the honesty story.

Public windows. Table: GET /api/quantum/spectral/windows. Rerun: GET /api/quantum/spectral/windows/rerun?seed=…. Node pack stays OFF.

Loading public windows…

Hardware vs sim epochs (Phase F)

Phase F is live. New blocks carry epoch_type=sim. The measured labelled backend is quantum-sim — exact numpy C_s extract, with a public false-reject table against Poisson and a depolarizing noise model. That model is not Wukong and not a rented QPU. hardware_poq is true only on a measured hardware epoch. None is measured. Rented QPU time is not WeAD-only.

GET /api/quantum/spectral/epochs — epoch types, backend registry, false-reject table
GET /api/qchain/rewards/hardware — allowed=false on sim; POST is 403
GET /api/qchain/status — spectral_epochs honesty + QRNG quantum: false when ANU is empty

A GHZ histogram that once came from Origin Quantum is not a spectral hardware PoQ. New blocks do not stamp wukong on a quantum-sim extract.

False-reject table columns are different tests: ks_pass_rate is the KS window on the noisy spectrum; reject_vs_sim is an L2 distance of the K(t) ramp against the cached clean-sim means. Read them separately. Since 2 Sep 2026 epoch_type is required on every block at height ≥ 485034 — a proof without it is rejected, not treated as legacy.

Operator set (Phase G)

The live consensus set is four WeAD validators. A second WeAD host votes over P2P ws://wead.live:9900. That is not an external partner org and not three continents. One seat is reserved for an operator who is not a WeAD host. It is empty. Applications are recorded; they do not become validators.

GET /api/qchain/operators — named WeAD addresses, empty non-WeAD seat, switch badge
POST /api/qchain/operators/apply — record interest (org / contact). Never activates a validator
Mini wallet is Startale — not a QMC consensus operator
Company paper stays at /white-paper. QMC paper is /qmc-white-paper

Loading operator honesty…

Node pack switch stays OFF until independent verifiers are named. Status: GET /api/quantum/spectral/verifiers.

QSM header bind (Phase C)

Phase C is live. The epoch is encoded as a 4×4 matrix of tx roots, the validator set, the spectral commitment, and the previous digest. Header verify is one ML-DSA-44 (FIPS 204) over that matrix digest. Quorum votes still sign the block hash. This does not retune Dilithium noise and is not an SVP “optimization.” Domain-separation strings stay out of this page.

Encoder v2 (2 Sep 2026 audit). The v1 validator row joined addresses with a comma and encoded height 0 as empty. v2 length-prefixes every field, so two different validator sets can never share a row and height 0 is distinct. Blocks carry their own v; v1 seals (heights 484940 → the switch) still verify with the v1 encoder, new blocks seal with v2. Matrix limbs are uint64 — a JavaScript verifier must use BigInt, not Number. See /api/qchain/status → qsm_header.version.

GET /api/qchain/status — qsm_header honesty block (alg, FIPS, latest digest)
GET /api/qchain/block/latest — quantum_proof.qsm_header on new blocks

Run a node

Public genesis (no secrets): GET https://wead.live/api/qchain/genesis

Node pack switch is OFF. Reference curves are public; node software and keys are not. A runnable node pack is issued only after independent verifiers are chosen. Status: GET /api/quantum/spectral/verifiers.

Mainnet P2P bootstrap (no origin IPs): ws://wead.live:9900. Testnet: ws://wead.live:9901.

Wallets

QMC wallets use Dilithium (post-quantum) key pairs. Each wallet has:

Address — your account identifier (safe to share)
Public Key — used to verify your signatures
Secret Key — used to sign transactions (generated and stored only in your browser — never sent to any server)

Create via Web Wallet (Recommended)

Go to /qmc-wallet, set a password, and click Create New Wallet. Your Dilithium keys are generated in your browser, AES-256-GCM encrypted, and stored locally. Your secret key never leaves your device.

Create via API (Deprecated)

POST /api/qchain/wallet/create Response: { "address": "57bdc478650195830c4dde0b8bf41844cea6e089", "public_key": "base64..." } // secret_key is no longer returned for security

Use client-side generation with @noble/post-quantum ml_dsa44 or the QMC Web Wallet. The API no longer returns secret keys.

Create via the Web Wallet

// Browser: open https://wead.live/qmc-wallet (window.qmc) // JSON-RPC: const res = await fetch("https://wead.live/rpc", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "qwd_chainId", params: [] }) });

Transactions

QMC supports several transaction types:

Type	Purpose
`transfer`	Send QWD to another address
`mint`	Faucet / system mint
`stake`	Lock QWD to become a validator
`unstake`	Begin withdrawing staked QWD
`deploy_contract`	Deploy a QWD-20 token or custom contract
`call_contract`	Call a contract function
`bridge_lock`	Lock QWD for bridging to Soneium
`bridge_release`	Release QWD from bridge

Build → Sign → Send Flow

# 1. Build transaction (server computes tx_id, nonce, gas) POST /api/qchain/tx/build { "sender": "57bdc478650195830c4dde0b8bf41844cea6e089", "recipient": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "value": 100, "tx_type": "transfer" } # 2. Sign locally in your browser (secret key never leaves your device) const signature = QMCCrypto.signLocally(tx.tx_id, mySecretKey); # 3. Send signed transaction POST /api/qchain/tx/send { "tx_id": "...", "sender": "...", "recipient": "...", "value": 100, "signature": "base64...", "public_key": "base64...", "tx_type": "transfer" }

Signing is done client-side using Dilithium (ML-DSA-44). The deprecated /api/qchain/tx/sign endpoint still works but sends your key over the wire — avoid it.

Every transaction includes a fee (base: 0.001 QWD + gas). Fees go to the block producer.

Staking

Stake at least 10,000 QWD to become a validator and participate in block production.

Stake

POST /api/qchain/stake { "address": "57bdc478650195830c4dde0b8bf41844cea6e089", "amount": 10000 }

Unstake

POST /api/qchain/unstake { "address": "57bdc478650195830c4dde0b8bf41844cea6e089", "cooldown_blocks": 100 }

Claim (after cooldown)

POST /api/qchain/stake/claim { "address": "57bdc478650195830c4dde0b8bf41844cea6e089" }

Check Validators

GET /api/qchain/validators Response: { "validators": [{ "address": "57bdc478650195830c4dde0b8bf41844cea6e089", "stake": 10000, "is_active": true }] }

QWD-20 Token Standard

QWD-20 is the native token standard for QMC (similar to ERC-20 on Ethereum). Any project can deploy their own token.

Deploy a Token

Send a deploy_contract transaction with this JSON in the data field:

{ "standard": "qwd20", "args": { "name": "My Token", "symbol": "MTK", "total_supply": 1000000 } }

Supported Contract Calls

Method	Parameters	Description
`balance_of`	`address`	Get token balance of an address
`transfer`	`to`, `amount`	Send tokens to another address
`approve`	`spender`, `amount`	Allow another address to spend your tokens
`allowance`	`owner`, `spender`	Check approved spending amount
`transfer_from`	`from`, `to`, `amount`	Spend tokens on behalf of another (with approval)
`metadata`	—	Get token name, symbol, supply, decimals

Calling a Contract

POST /api/qchain/tx/build { "sender": "57bdc478650195830c4dde0b8bf41844cea6e089", "recipient": "contract_address_here", "value": 0, "tx_type": "call_contract", "data": "{\"method\":\"transfer\",\"args\":{\"to\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"amount\":500}}" }

Cross-Chain Bridge

QMC lock-and-mint is live on Soneium (chain 1868) only. The first production lock minted 1 wrapped QWD. Wrapped QWD on Soneium is ECC liquidity, not the security root and not a post-quantum token. Base and BNB Chain stay in the table, switched off, until those teams collaborate.

Supported Chains

Chain	Key	Mainnet Chain ID	Status
Soneium	`soneium`	1868	Live
Base	`base`	8453	Off — later
BNB Chain	`bnb`	56	Off — later

How It Works

Lock — You lock QWD on QMC by sending a bridge_lock transaction with a target chain and EVM recipient address.
Relay — A relayer watches for lock events and mints wrapped QWD on the selected target chain.
Return — not live. The rail is one-way today (QMC → Soneium). Burning wrapped QWD on Soneium does not yet credit native QWD. A Soneium Locked event is booked at GET /api/qchain/bridge/returns as pending_manual; nothing is credited automatically. bridge_release is relayer-only and can only refund a lock that never minted.

One-way rail. Do not bridge QWD you need back on QMC soon. Wrapped QWD is ECC liquidity on Soneium, not a post-quantum token.

Bridge Lock

POST /api/qchain/tx/build { "sender": "57bdc478650195830c4dde0b8bf41844cea6e089", "recipient": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "value": 100, "tx_type": "bridge_lock", "data": "{\"to_chain\":\"soneium\",\"evm_recipient\":\"0xYourEvmAddress...\"}" }

First lock (2 Sep 2026)

1 QWD locked on QMC and minted on Soneium via 0xeE6dF64BBa8DCC6E5B5b526832C133C3f0F14306 to token 0x017E69300B0Bc1eaba5eec346798E05b168DCD58. Blockscout: mint tx. Epoch digest witness: epoch tx. Status: GET /api/qchain/bridge/locks · GET /api/qchain/bridge/epoch.

Ask for Soneium

WeAD is asking Soneium for an ecosystem listing (QMC as Dilithium sister L1), recognition of wrapped QWD on their token lists, and a second relayer operator besides WeAD hosts. Until that exists, the rail is live and honest: one WeAD relayer, ECC wrap, Dilithium root on 7771.

Bridge APIs

Endpoint	Method	Description
`/api/qchain/bridge/chains`	GET	List supported target chains
`/api/qchain/bridge/locks`	GET	List recent bridge locks
`/api/qchain/bridge/epoch`	GET	Latest QSM digest witnessed on Soneium (ECC, not PQ)
`/api/qchain/bridge/releases`	GET	List recent bridge releases (refunds of un-minted locks)
`/api/qchain/bridge/returns`	GET	Soneium Locked events booked for manual handling (return path not live)
`/api/qchain/bridge/status`	GET	Relayer + rail status
`/api/qchain/bridge/release`	POST	Relayer-only. Public callers get `403`.

REST API Reference

Base URL: https://wead.live

Endpoint	Method	Description
`/api/qchain/status`	GET	Chain status (height, supply, validators, P2P, spectral windows pointer)
`/api/quantum/spectral/windows`	GET	Public KS / Σ² / K(t) ε table (not node source)
`/api/quantum/spectral/windows/rerun?seed=…`	GET	Rerun one seed against the published windows
`/api/quantum/spectral/epochs`	GET	Sim vs hardware epoch registry + false-reject table
`/api/qchain/rewards/hardware`	GET	Hardware-reward gate (denied on sim)
`/api/qchain/blocks`	GET	Recent blocks (query: `?limit=10`)
`/api/qchain/block/<height>`	GET	Block by height
`/api/qchain/tx/<tx_id>`	GET	Transaction by ID
`/api/qchain/address/<addr>`	GET	Account details
`/api/qchain/validators`	GET	Active validator list
`/api/qchain/operators`	GET	Named WeAD operator set + empty non-WeAD seat
`/api/qchain/operators/apply`	POST	Record a non-WeAD operator ask (does not activate)
`/api/qchain/mempool`	GET	Pending transactions
`/api/qchain/wallet/create`	POST	Create a new wallet
`/api/qchain/wallet/balance`	POST	Check wallet balance
`/api/qchain/tx/build`	POST	Build an unsigned transaction
`/api/qchain/tx/sign`	POST	~~Sign a transaction~~ (deprecated — use client-side signing)
`/api/qchain/tx/send`	POST	Send a signed transaction
`/api/qchain/faucet`	POST	Request free QWD
`/api/qchain/stake`	POST	Stake QWD
`/api/qchain/unstake`	POST	Begin unstaking
`/api/qchain/stake/claim`	POST	Claim unstaked QWD
`/api/qchain/bridge/chains`	GET	List supported bridge target chains
`/api/qchain/bridge/locks?chain=soneium`	GET	List recent locks (optional chain filter)
`/api/qchain/contracts/<addr>/metadata`	GET	Contract metadata
`/api/qchain/contracts/<addr>/balance/<who>`	GET	Token balance
`/api/qchain/block/latest`	GET	Latest block with full quantum proof
`/api/qchain/genesis`	GET	Genesis block, chain id, bootstrap node (signatures stripped)
`/api/qchain/faucet/status`	GET	Faucet pool, daily cap, spent
`/api/qchain/node-pack`	GET	Voter-only pack metadata (public). Spectral protocol pack stays switch-gated.
`/api/qchain/bridge/epoch`	GET	QSM digest witnessed on Soneium
`/api/qchain/storage/info` · `/storage/snapshots`	GET	Block archive status

Addresses are 40 hex characters (e.g. 57bdc478650195830c4dde0b8bf41844cea6e089). There is no qwd1… bech32 format; older examples that showed one were wrong.

JSON-RPC Reference

Endpoint: POST https://wead.live/rpc

Standard JSON-RPC 2.0 format. Compatible with any JSON-RPC client.

{ "jsonrpc": "2.0", "id": 1, "method": "qwd_blockNumber", "params": [] }

Method	Params	Description
`qwd_chainId`	—	Returns chain ID
`qwd_blockNumber`	—	Returns current block height
`qwd_getBlockByNumber`	`[height]`	Block details by height
`qwd_getBlockByHash`	`[hash]`	Block details by hash
`qwd_getTransactionByHash`	`[tx_id]`	Transaction details
`qwd_getBalance`	`[address]`	Account balance
`qwd_getTransactionCount`	`[address]`	Account nonce
`qwd_sendRawTransaction`	`[tx_object]`	Submit signed transaction
`qwd_call`	`[contract, {"caller": addr, "data": json}]`	Read-only QWD-20 call. Errors return JSON-RPC `-32602` on HTTP 200.
`qwd_estimateGas`	`[tx_object]`	Estimate gas cost
`qwd_getCode`	`[contract]`	Contract bytecode
`qwd_getLogs`	`[filter]`	Contract event logs
`qwd_getValidators`	—	Active validators
`qwd_getStake`	`[address]`	Stake details for address
`net_version`	—	Network version
`net_peerCount`	—	Connected peer count

Example: Get Balance via cURL

curl -X POST https://wead.live/rpc \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"qwd_getBalance","params":["57bdc478650195830c4dde0b8bf41844cea6e089"]}'

Testnet Access

The Matrix Quantum Chain testnet is hosted and operated by WeAD. Two different packs: the voter pack (/api/qchain/node-pack.tgz — run a Dilithium voter, no wallets, no spectral internals) is public; the spectral protocol pack (circuit family, seed constants, domain labels) is switch-gated and OFF until independent verifiers are chosen. Status: GET /api/quantum/spectral/verifiers.

Get Started

Visit wead.live/quantum-blockchain to explore the live mainnet explorer
Use the testnet endpoints below — they are a separate process (chain 7772). /rpc and /api/qchain/* are mainnet 7771.
Testnet QWD is free via the testnet faucet. Mainnet faucet is 1,000 QWD per address per hour, daily-capped.

Testnet RPC Endpoint

https://wead.live/rpc-testnet # JSON-RPC, chain 7772 https://wead.live/api/qchain-testnet/status # REST

Chain Details

Property	Testnet	Mainnet
Chain ID	`7772`	`7771`
JSON-RPC	`/rpc-testnet`	`/rpc`
REST	`/api/qchain-testnet/*`	`/api/qchain/*`
P2P	`ws://wead.live:9901`	`ws://wead.live:9900`
Block Interval	~30 seconds
Consensus	ceil(2n/3) Dilithium votes · mainnet has four WeAD validators (quorum 3) · not three continents
Signatures	Dilithium ML-DSA-44 (FIPS 204)
Quantum Backend	Live extract is `quantum-sim`. Wukong is not stamped on sim. `hardware_poq=false`.

Faucet (Get Testnet QWD)

curl -X POST https://wead.live/api/qchain-testnet/faucet \ -H "Content-Type: application/json" \ -d '{"address": "57bdc478650195830c4dde0b8bf41844cea6e089"}' # 40 hex chars

Validator Program

Mainnet 7771 is live with four WeAD validators. A non-WeAD seat is reserved and empty. Record interest with POST /api/qchain/operators/apply or dev@wead.live. Applications do not become validators. Node software stays switch-gated.

Network Configuration

Key chain parameters for developers integrating with the Matrix Quantum Chain:

Parameter	Value	Description
Chain ID (Mainnet)	`7771`	For mainnet transactions
Chain ID (Testnet)	`7772`	For testnet transactions
Block Interval	30s	Target time between blocks
Max TX per Block	100	Transaction throughput limit
Minimum Stake	10,000 QWD	Minimum to become a validator
Base Fee	0.001 QWD	Minimum transaction fee

QMC Documentation