Developer Portal

From zero to deployed
in 5 minutes.

QNTM is EVM-compatible. Your existing Solidity toolchain works as-is. The only thing that changes is the network is quantum-safe.

Testnet Network Config

Add this network to MetaMask or any EVM-compatible wallet. Chain ID 8765 does not conflict with any mainnet chain.

Network Name: QNTM Testnet

RPC URL: https://testnet.qntmchain.ai/rpc

Chain ID: 8765

Currency: QNTM

Explorer: https://testnet.qntmchain.ai/explorer

Faucet: https://testnet.qntmchain.ai/faucet

Get Testnet Tokens

Quickstart Paths

Pick your stack. All paths end at a deployed contract.

Path A

Smart Contract Developer (Solidity)

Install nothing new. Configure Hardhat or Foundry with the QNTM network. Request testnet tokens. Deploy with your existing scripts.

1 Configure Hardhat

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],
    },
  },
};

// Deploy
// npx hardhat run scripts/deploy.js --network qntmTestnet

2 Or configure Foundry

foundry.toml

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

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

3 Request testnet tokens and deploy

# Get tokens from the faucet

curl -X POST https://testnet.qntmchain.ai/faucet/drip \

-d '{"address":"0xYOUR_ADDRESS"}'

# Then deploy your contract

npx hardhat run scripts/deploy.js --network qntmTestnet

Path B

Go SDK

Native Go client with ML-DSA-65 wallet generation, balance queries, and transaction signing. Built on liboqs.

1 Install the SDK

go get github.com/qntmchain/qntm-protocol/sdk/go

2 Generate a wallet and check balance

main.go

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

// Generate a post-quantum wallet (ML-DSA-65)
wallet, err := qntm.NewWallet()
if err != nil { log.Fatal(err) }

address := wallet.Address()   // qntm1abc... bech32
privKey := wallet.PrivateKey() // ML-DSA-65 private key bytes

// Connect and check balance
client := qntm.NewClient("https://testnet.qntmchain.ai/rpc")
balance, err := client.Balance(ctx, address)

3 Send a transaction

tx := qntm.NewTransferTx(wallet.Address(), recipient, amount)
signed, err := tx.Sign(privKey)
hash, err := client.Broadcast(ctx, signed)
fmt.Println("tx:", hash) // block explorer link

Path C

TypeScript / Browser

ML-DSA compiled to WASM. Runs in browsers and Node.js. Compatible with ethers.js contract ABI. React hooks available.

1 Install the SDK

npm install @qntmchain/sdk

2 Generate a wallet and connect to provider

index.ts

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

// Generate post-quantum wallet (WASM ML-DSA — browser + Node.js)
const wallet = await Wallet.generate();
console.log(wallet.address); // qntm1abc...

// Connect to testnet
const client = new Client('https://testnet.qntmchain.ai/rpc');
const balance = await client.getBalance(wallet.address);

3 Sign and send a transaction

// Transfer tokens
const tx = await client.transfer(wallet, recipient, amount);
console.log('tx hash:', tx.hash);

// Or interact with a Solidity contract (ethers.js compatible ABI)
const contract = new Contract(abi, contractAddress, wallet.connect(client));
await contract.myMethod(args);

PQC Precompiles Reference

Call post-quantum cryptography directly from Solidity. These are protocol-native precompiles, not external contracts.

Address	Function	Input	Output	Gas
0x100	ML-DSA-65 Verify	(bytes pubkey, bytes message, bytes signature)	bool	~50,000
0x101	ML-KEM-768 Encapsulate	(bytes pubkey)	(bytes ciphertext, bytes sharedSecret)	~30,000
0x101	ML-KEM-768 Decapsulate	(bytes privkey, bytes ciphertext)	bytes sharedSecret	~30,000

QNTMPrecompiles.sol

// QNTM PQC Precompile Interface
interface IMLDSAVerify {
    function verify(
        bytes calldata publicKey,
        bytes calldata message,
        bytes calldata signature
    ) external view returns (bool);
}

// Usage: verify a post-quantum signature from within any Solidity contract
IMLDSAVerify constant MLDSA = IMLDSAVerify(0x0000000000000000000000000000000000000100);
bool valid = MLDSA.verify(pubKey, msgHash, sig);

Resources

Everything you need to go deeper.

Node Setup Guide

Guide

Run a validator or full node on the QNTM testnet. Hardware requirements, config, monitoring.

Go SDK Reference

GitHub

Full API reference for the Go SDK. Wallet generation, transactions, contract calls, PQC primitives.

TypeScript SDK Reference

GitHub

Full API reference for the TypeScript SDK. Browser and Node.js. ethers.js compatible.

Protocol Specification

GitHub

Full technical spec: consensus, PQC algorithm selection, EVM integration, IBC, genesis config.

BTC Quantum Checker

Tool

Check any Bitcoin address for quantum vulnerability. See what QNTM solves in practice.

Discord

Community

Ask questions, get help, connect with other QNTM developers. We are active.

Questions?

Our AI assistant Q can walk you through it. Ask about testnet setup, SDK usage, PQC precompiles, or anything else.

From zero to deployed in 5 minutes.

Testnet Network Config

Quickstart Paths

Smart Contract Developer (Solidity)

Go SDK

TypeScript / Browser

PQC Precompiles Reference

Resources

Node Setup Guide

Go SDK Reference

TypeScript SDK Reference

Protocol Specification

BTC Quantum Checker

Discord

From zero to deployed
in 5 minutes.