Protocol Architecture

Built for a world where
quantum exists.

NIST finalized four post-quantum cryptography standards in 2024. QNTM is built on them. Not on a roadmap item. Not on a fork that adds PQC as an afterthought. The protocol starts here.

Algorithm Stack

Every standard listed here is NIST-final (FIPS ratified 2024). No pre-standard schemes.

Standard	Original Name	Type	Used For	Sig Size	Status
FIPS 204	ML-DSA (CRYSTALS-Dilithium)	Lattice	Validator keys	~3,293 B	Active
FIPS 206	FN-DSA (FALCON-512)	NTRU Lattice	Transaction signatures	~666 B	Active
FIPS 203	ML-KEM (CRYSTALS-Kyber)	Lattice (KEM)	Node TLS / key exchange	N/A	Active
FIPS 205	SLH-DSA (SPHINCS+)	Hash-based	Optional hybrid fallback	7–50 KB	Optional

Classical ECDSA (Bitcoin, Ethereum): 64 bytes. Broken by Shor's algorithm. FN-DSA is 10x larger. ML-DSA is 51x larger. This is the correct trade.

Architecture

DeFi Applications

Native DEX, lending protocol, stablecoin. EVM smart contracts. Solidity/Vyper unmodified.

EVM Runtime (Ethermint)

Full Ethereum Virtual Machine. Every opcode. Same ABI. Same tooling. No rewrites.

Cosmos SDK State Machine

Modular state machine: bank, staking, governance, IBC. Instant finality.

CometBFT Consensus (ML-DSA validator keys)

BFT consensus with ML-DSA (FIPS 204) replacing Ed25519. Every validator key is PQC from genesis.

Validator Nodes (bare metal, dedicated)

21 validators minimum. 8-core CPU, 32 GB RAM, 1 TB NVMe, 1 Gbps uptime per node.

IBC: Free Connectivity From Day One

Inter-Blockchain Communication is built into the Cosmos SDK. QNTM inherits it from genesis. Every chain in the Cosmos ecosystem is reachable via IBC on day one. That includes Osmosis (the largest DEX in the Cosmos ecosystem), where QNTM can be listed immediately after mainnet launch without a centralized exchange negotiation.

Osmosis DEX

Day-one listing via IBC. No negotiation required.

Cosmos Hub

ATOM/QNTM bridge from launch.

Any IBC Chain

Over 100 IBC-connected chains reachable.

Why Migration Does Not Work

Ethereum's Hegotia upgrade is the most ambitious migration attempt in blockchain history. It requires replacing ECDSA across millions of existing wallets, billions of dollars in smart contracts, and hundreds of millions of lines of dependent code. The coordination problem is enormous. The timeline is already delayed.

Bitcoin has no credible migration plan. BIP proposals for PQC exist. Getting consensus across the Bitcoin network for a signature algorithm change is a multi-decade coordination problem with no clear resolution mechanism. The UTXO set containing vulnerable P2PK outputs cannot be unilaterally migrated.

Migrations carry the weight of every past decision. QNTM carries none of that weight. The protocol starts with NIST-final algorithms and builds forward.

SDKs

Native SDKs for Go and TypeScript ship at testnet launch. Both expose the same wallet and transaction primitives. The TypeScript SDK runs in the browser and Node.js via WASM-compiled ML-DSA. The Go SDK wraps liboqs directly.

Go SDK

import qntm "github.com/qntmchain/qntm-protocol/sdk/go"

// Generate a post-quantum wallet
wallet, err := qntm.NewWallet()
privKey := wallet.PrivateKey()   // ML-DSA-65 private key
address := wallet.Address()      // qntm1... bech32 address

// Sign and broadcast a transaction
tx := qntm.NewTransferTx(from, to, amount)
signed, err := tx.Sign(privKey)
hash, err := client.Broadcast(ctx, signed)

TypeScript SDK

import { Wallet, Client } from '@qntmchain/sdk';

// Generate a post-quantum wallet (WASM ML-DSA in browser + Node.js)
const wallet = await Wallet.generate();
const address = wallet.address;  // qntm1...

// Deploy or call a contract (ethers.js compatible)
const provider = new Client('https://testnet.qntmchain.ai/rpc');
const contract = new Contract(abi, address, wallet.connect(provider));
await contract.myMethod(args);

Soon

Go 1.22+

Available at testnet launch

Soon

TypeScript / WASM

Browser + Node.js

Planned

Rust SDK

Coming post-mainnet

EVM Smart Contract Deployment

Existing Solidity tooling works unchanged. Point your config at the QNTM RPC endpoint and deploy. No rewrites. No new compiler. No new language.

hardhat.config.js

// hardhat.config.js — no changes to your Solidity code required
module.exports = {
  networks: {
    qntmTestnet: {
      url: 'https://testnet.qntmchain.ai/rpc',
      chainId: 8765,
      accounts: [process.env.PRIVATE_KEY],
    },
    qntmMainnet: {
      url: 'https://rpc.qntmchain.ai',
      chainId: 8766,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

foundry.toml

# foundry.toml
[rpc_endpoints]
qntm_testnet = "https://testnet.qntmchain.ai/rpc"

# Deploy
# forge script Deploy --rpc-url qntm_testnet --broadcast

Same Solidity

Any contract that runs on Ethereum runs on QNTM. No rewrites. No new language.

Same Tooling

Hardhat, Foundry, Remix, Truffle. All work as-is.

PQC Precompiles

New: call ML-DSA and ML-KEM from Solidity via precompiles at 0x100 and 0x101.

Read the full protocol specification in the open-source repository.

Protocol Specification Security Posture

Built for a world where quantum exists.