Quantova is a sovereign post quantum Layer 1 built from scratch. It shares no code, no wire format, no address, no unit, and no trust assumption with any other chain, and it is post quantum from the metal up rather than a classical chain with a post quantum signature added on top.

The one of one is that every layer is post quantum on NIST standardized schemes alone, with no classical escape hatch anywhere. Classical public key cryptography is not deprecated and not merely unused, it is unrepresentable, because the wire formats, the opcodes, the type system, and every interface are shaped so a classical artifact has no valid encoding. There is no elliptic curve anywhere in the stack, no ECDSA, no secp256k1, no Ed25519, no X25519, no RSA, no Diffie Hellman, no pairings, and no BLS, and none can be built. Quantova is post quantum end to end, and nothing that secures the chain is vulnerable to Shor's algorithm.

The stack is at the testnet and pre audit stage. The chain runs, native transfers and staking and governance are live, and contract execution is metered under a compute budget. The cryptography is a from scratch reference implementation validated against the official NIST test vectors and not yet independently audited, and external audits of the cryptography, the virtual machine, the language, and the consensus are planned before the public testnet and required before mainnet. This page does not claim the stack is audited, production secure, hardened, unhackable, quantum proof, or fully trustless.

Cryptography, Q-Crypto. Q-Crypto is the only cryptography in the organization and the floor every other layer stands on. It is a from scratch reference implementation of the NIST post quantum standards written against the published FIPS documents, ML-DSA-65 from FIPS 204 for signatures, ML-KEM-768 from FIPS 203 for key encapsulation, SLH-DSA from FIPS 205 as the conservative hash based signature, and SHA-3 and SHAKE from FIPS 202 for hashing, with ChaCha20-Poly1305 from RFC 8439 as a transport only channel cipher and never a consensus or account primitive. Every scheme is checked against the official NIST known answer tests, and no elliptic curve, pairing, or classical public key primitive lives anywhere in the tree.

Consensus, QORUS. QORUS is the consensus of Quantova, a committee based byzantine fault tolerant protocol that reaches sub second deterministic finality and produces one aggregated certificate rather than a list of votes, so consensus never consumes block space. A budget bounded sortition committee is sampled each round from the stake ranked active set, a leader proposes a block, the committee attests with ML-DSA-65, and a supermajority of more than two thirds finalizes the block for good. Because the committee is bounded by a budget rather than growing with the validator set, the work to finalize a block stays flat as the network grows, and every validator re executes every block so one honest re executor protects validity.

The virtual machine, the QVM. The QVM is the execution layer, a deterministic register machine that runs a compiled container, the machine's own unit of code. It is not the Ethereum virtual machine and not a wasm virtual machine. It has sixteen general registers of 64 bit words, a bounded operand and call stack, and a linear scratch memory sized to hold a full post quantum key, signature, or proof. Arithmetic is checked so an overflow faults rather than wraps, and on any fault the machine rolls back and records nothing. The post quantum operations are first class instructions, so a container verifies an ML-DSA or SLH-DSA signature, hashes over SHA-3, checks a Merkle path, or verifies a random output without rolling its own cryptography, and there is no instruction that verifies a classical signature.

The language, Quanta. Quanta is the smart contract language. A contract is written in a source file with the extension qs and compiles to a QVM container, and the compiler is the sole path from source to bytecode. Its defining property is that whole classes of exploit are compile errors rather than runtime hazards, so a program that could carry one does not produce a container. Reentrancy has no expression, unchecked overflow is rejected at the type level, forged authority cannot be assembled because authority comes only from a real machine verification, infinite mint is refused by a conservation analysis, dropped and double spent value are ruled out by linearity, and a competitive order that is not sealed does not compile. The lexer also refuses foreign identifiers such as function, require, mapping, uint256, and ecrecover outright, so source shaped like another chain's language does not even tokenize.

The token standards, QAsset and QCollectible. QAsset is the fungible token standard and QCollectible is the collectible standard, both written directly in the Quanta primitives so their guarantees are proven by the compiler rather than hand rolled. QAsset gives a regulated issuer the controls the law requires under a guardian quorum with a threshold, freeze and unfreeze of a named account, an evidence bound clawback, quorum gated mint and burn, and an emergency pause, each gated by the quorum and each emitting a permanent event. These standards are named QAsset and QCollectible and are never called QRC20 or QRC721.

Identity and money. Identity has three layers. A name in the Quantova Name Service is the human readable top, ending in the suffix q, and it resolves forward to a Q1 address while an address resolves back to its primary name. The Q1 address is the on chain identifier, a Bech32m encoding of a 256 bit payload under the human readable part q, where the payload is the SHA3-256 hash of the scheme identifier and the full post quantum public key, so the address binds a real key at full width and there is one width and no shorter tier. A secret export uses the part Q2, so a string that reads Q2 is always a secret, while a block hash, a transaction hash, and a state root read qbk1, qtx1, and qst1. The asset is QTOV. It pays fees, validators stake it, and it is the unit of the treasury. Its base unit is the Quon, and one QTOV is one million Quon. The testnet asset is TQTOV.

The wire and the gateway. The transaction encoding is the stack's own canonical codec in which every value has exactly one valid form, and it is neither RLP nor SCALE. The peer transport is a post quantum authenticated channel that exchanges ML-DSA identities, encapsulates an ephemeral ML-KEM key, and derives ChaCha20-Poly1305 record keys over a SHAKE256 schedule, with no classical key exchange even on a development network. Clients reach a node through the access gateway, a plain HTTP endpoint where every method is an HTTP POST to a path under /v1 carrying a flat JSON body, among them node_info, head, get_account, submit_transaction, get_block, supply, get_container, get_storage, and get_events. There is no eth_ method anywhere and it is not Ethereum JSON-RPC.

The SDK, the QCore family. A client derives a post quantum key, builds a transaction, signs it, and speaks the gateway wire, and the QCore family does all four in one place. QCore.rs is a single Rust core, QCore.js is that same core compiled to WebAssembly and published on npm as @qunatovainc/qcore, and QCore.py is that same core built as a native extension. All three derive the same Q1 address from the same seed and sign the same transaction body to the same bytes, because they are the one core rather than three copies of it.

The bridge. The bridge moves value between Quantova and a foreign chain, and the whole of it lives off chain inside the Q Oracle and its Airlock. The oracle watches the foreign chains, runs all of their verification, and translates the result into a post quantum attestation, so no foreign signature, key, or header ever reaches the virtual machine or the consensus. The chain parses only a post quantum attestation and a proof, every bridged asset is second class by protocol law and never valid as validator stake, and every corridor carries a visible trust grade. The bridge is trust minimized and it is never trustless.

New to Quantova, read the api repository for the gateway methods, install the QCore SDK for the language you build in, and read Quantova-Specs for the normative detail. The crypto policy in Quantova-Specs is the supreme law of the stack, so start there for anything cryptographic.