Skip to content
/ Qanto Public

Layer-0 blockchain featuring a DAG with hybrid consensus, governed by its SAGA AI for dynamic network optimization and unprecedented scalability.

License

MIT license
3 stars 0 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

trvorth/Qanto

BranchesTags

Repository files navigation

Status CI License Docs

Qanto Banner

Repository for the official Rust implementation of the Qanto Protocol

Author: trvorth (trvorth@qanto.org)

Visit qanto.org | Follow [X] (https://x.com/QantoLayer0) | Join Discord

About Qanto

Topics: blockchain, ai, layer-0, rust, post-quantum-cryptography, high-throughput, decentralized-finance.

Qanto is a modern Layer-0 blockchain designed for extreme performance, decentralization, and security. Its evolved architecture utilizes a Hybrid Proof-of-Work and Delegated Proof-of-Stake (PoW+DPoS) consensus model. This innovative approach uses PoW for permissionless leader election, ensuring the network remains open and secure, while DPoS is used for high-speed block production, enabling massive transaction throughput.

Key innovations include an AI-driven governance system (SAGA), post-quantum security using lattice-based cryptography (inspired by CRYSTALS-Dilithium), and a sophisticated, self-regulating difficulty adjustment algorithm.

As a foundational protocol, Qanto facilitates interoperability across its ecosystem, capable of hosting Layer-1-like chains and enabling Layer-2 scaling solutions such as rollups. As a foundational protocol, Qanto is engineered to be a standalone, production-grade system capable of supporting a high-throughput environment, the open-source (MIT) project welcomes community contributions to help build a future-proof, decentralized ecosystem.

For a comprehensive academic and technical overview, please refer to the official Qanto Whitepaper (Updated August 2025).

Performance Benchmarks 📈

The following benchmarks were conducted on an Apple M-series CPU and an integrated GPU, demonstrating the performance of the core components with latest optimizations.

Benchmark Time Throughput (approx.) Notes
CPU Hashrate (1k Hashes) ~281 µs ~3.55 MHash/s Measures the performance of the qanhash algorithm on a single CPU core.
GPU Hashrate (1 Batch) ~3.67 ms ~17.85 MHash/s Measures the performance of 65,536 hashes on an integrated GPU.
Execution Layer (16,000 txs) ~79.7 ms ~200,580 TPS Time to process a full block payload (signature verification & Merkle root).
Hyperscale Execution (1.6M txs) ~62.8 ms ~25,447,000 TPS Peak raw throughput of the sharded execution model.
Post-Quantum Signatures ~1.2 ms ~833 sigs/sec CRYSTALS-Dilithium signature verification performance.
Cross-Chain Verification ~15 ms ~66 proofs/sec Light client proof verification across supported chains.
AI Governance (SAGA) ~5 ms ~200 decisions/sec Neural network-based governance decision processing with real-time analytics.
Infinite Strata VDF ~100 ms ~10 proofs/sec Verifiable Delay Function proof generation and verification.
Analytics Dashboard ~2 ms ~500 updates/sec Real-time network monitoring with AI insights and security analytics.
Memory Pool Processing ~0.5 ms ~2000 txs/sec Priority-based transaction queuing with advanced validation.

These results validate the high-throughput design of the Qanto protocol, with transaction processing speed comfortably exceeding the 10,000,000 TPS target while maintaining quantum-resistant security and comprehensive real-time monitoring.

Latest Enhancements (August 2025) 🚀

Production-Ready Features

  • ✅ Post-Quantum Cryptography: Complete CRYSTALS-Dilithium, Kyber KEM, and SPHINCS+ implementation with HSM integration, key rotation, and quantum-resistant key management
  • ✅ Cross-Chain Interoperability: Enhanced IBC-style protocols with light client verification, atomic swaps, trustless bridges, and persistent client state mapping
  • ✅ Infinite Strata Mining: Advanced VDF proof system with quantum-resistant key management, Merkle tree validation, and comprehensive zero-knowledge proof integration
  • ✅ AI Governance (SAGA): Production-grade neural networks with real-time analytics dashboard, predictive economic modeling, and adaptive security classification
  • ✅ Analytics Dashboard: Real-time network monitoring with AI insights, security analytics, environmental metrics, and comprehensive performance tracking
  • ✅ Performance Optimization: Hyperscale execution achieving 25M+ TPS with parallel processing, memory optimization, and efficient data structures targeting 32 BPS
  • ✅ Memory Pool Enhancement: Priority-based queuing with advanced transaction validation, resource management, and optimized fee estimation
  • ✅ Code Quality Assurance: Comprehensive CI/CD pipeline with automated testing, linting, security auditing, and workspace validation
  • ✅ Production Deployment: Cloud infrastructure with automated deployment, monitoring, and block explorer integration

Advanced AI Integration

  • Neural Network Architecture: 6-layer deep learning system with adaptive learning rates, regularization, and production-grade model training
  • Security Classification: Real-time threat detection with anomaly scoring, pattern recognition, and automated incident response
  • Predictive Analytics: Economic modeling with market premium calculation, resource allocation optimization, and AI model performance tracking
  • Adaptive Control: PID controllers for dynamic parameter tuning, self-scaling management, and network congestion optimization
  • Cognitive Analytics: Multi-modal AI engine for governance decisions, network optimization, and comprehensive dashboard analytics
  • Real-time Monitoring: Live network health metrics, validator performance tracking, and environmental impact assessment

Security Enhancements

  • Quantum-Resistant Suite: Future-proof cryptographic implementations with hardware security module support
  • Multi-Layer Consensus: Enhanced PoW+DPoS with AI-driven governance and Byzantine fault tolerance
  • Cross-Chain Security: Trustless bridge protocols with cryptographic proof verification and light client validation
  • Memory Safety: Rust-based implementation with zero-copy optimizations and secure memory management
  • Threat Monitoring: Real-time security analytics with automated incident response and threat classification

Developer Experience

  • Comprehensive Testing: Automated quality assurance pipeline with performance benchmarking
  • Modular Architecture: Clean separation of concerns with feature-gated compilation
  • Real-time Monitoring: Built-in analytics dashboard with network health metrics and AI performance tracking
  • Enhanced Documentation: Updated technical specifications with comprehensive API documentation and deployment guides

Architecture Overview

Structure

The Qanto repository is a Cargo workspace containing several key components:

Core Source (/src):

  • node.rs: Main node orchestration and service management with enhanced performance monitoring
  • config.rs: Configuration loading and validation with advanced parameter tuning
  • qantodag.rs: DAG ledger with dynamic sharding, post-quantum security, and hyperscale execution
  • consensus.rs: Multi-layered consensus (PoW, DPoS, PoSe) with AI-driven governance integration
  • p2p.rs: libp2p-based networking layer with cross-chain communication protocols
  • miner.rs: Proof-of-Work puzzle solving with GPU optimization and ASIC resistance
  • transaction.rs: Transaction creation and validation with optimized serialization and parallel processing
  • wallet.rs: Encrypted wallet management with post-quantum cryptographic security
  • saga.rs: AI governance and adaptive security pallet with production-grade neural networks
  • analytics_dashboard.rs: Real-time network analytics with AI insights, performance metrics, security analytics, and comprehensive dashboard functionality
  • hame.rs: Hybrid Autonomous Meta-Economy protocol with predictive economic modeling
  • omega.rs: Core identity and reflex protocol with quantum-resistant authentication
  • x_phyrus.rs: Military-grade pre-boot security suite with hardware security module integration
  • zk.rs: Zero-knowledge proof circuit definitions with UTXO privacy (feature-gated)
  • infinite_strata_node.rs: Cloud-adaptive mining with VDF proofs and quantum-resistant key management
  • interoperability.rs: Cross-chain bridge protocols with IBC-style communication and light client verification
  • post_quantum_crypto.rs: Complete post-quantum suite (CRYSTALS-Dilithium, Kyber KEM, SPHINCS+) with HSM support
  • mempool.rs: Optimized transaction pool with priority queuing and advanced validation algorithms
  • advanced_features.rs: Advanced features and experimental modules
  • decentralization.rs: Decentralization strategies and mechanisms
  • emission.rs: Token emission and distribution logic
  • graphql_server.rs: GraphQL API server implementation
  • integration.rs: Integration tests and utilities
  • keygen.rs: Key generation and management utilities
  • lib.rs: Main library file for the core source
  • metrics.rs: Performance metrics and monitoring
  • mining_celebration.rs: Logic for mining celebration events
  • mining_kernel.cl: OpenCL kernel for mining operations
  • omega_enhanced.rs: Enhanced Omega protocol implementation
  • performance_optimizations.rs: Performance optimization techniques
  • performance_validation.rs: Performance validation and benchmarking
  • privacy.rs: Privacy-enhancing features
  • qanto_ai_metrics.rs: AI-related metrics and analytics
  • qanto_compat.rs: Compatibility layers and utilities
  • qanto_native_crypto.rs: Native cryptographic implementations
  • qanto_net.rs: Network-related utilities
  • qanto_p2p.rs: P2P networking utilities
  • qanto_serde.rs: Serialization and deserialization utilities
  • qanto_storage.rs: Data storage and persistence
  • qantodag_testnet.rs: DAG ledger for testnet operations
  • types.rs: Common data types and structures
  • websocket_server.rs: WebSocket API server implementation
  • worker.js: Web Worker script for background tasks
  • zkp.rs: Zero-knowledge proof utilities
  • bin/: Executable binaries for node and wallet

Blockchain Core (myblockchain/):

  • lib.rs: Consolidated runtime with P2P, DPoS, mining, and execution modules
  • qanhash.rs: Core PoW algorithm with CPU/GPU implementations
  • kernel.cl: OpenCL GPU kernel for parallel hashing
  • qanhash32x.rs: Post-quantum cryptographic kernel

Additional Components:

  • /src/bin: Node and wallet executables
  • /docs: Project documentation and whitepaper
  • /helm: Kubernetes Helm charts for deployment (api, boot-node, website)
  • /tools: Development and utility tools
  • /tests: Comprehensive test suites
  • config.toml.example: Example configuration file

Table of Contents

  1. Architecture Overview
  2. Quick Start
  3. Installation
  4. Configuration
  5. API Documentation
  6. Cross-Chain Interoperability
  7. Security Features
  8. Performance Benchmarks
  9. Development
  10. Testing
  11. Deployment
  12. Contributing
  13. License

Quick Start

Prerequisites

  • Rust: 1.75+ with Cargo
  • System: Linux/macOS/Windows
  • Memory: 8-16GB+ RAM recommended
  • Storage: 50GB+ SSD for full node
  • Network: Stable internet connection

Installation

From Source (Recommended)

# Clone and build
git clone https://github.com/qanto-org/qanto.git
cd qanto
cargo build --release

# Run comprehensive quality assurance
cargo build
cargo clippy
cargo audit
cargo fmt
cargo fmt -p qanto -- --check
cargo clippy --workspace -- -D warnings

# Run tests and start node with infinite-strata features
cargo test --release
cargo run --release --features infinite-strata --bin qanto -- start --config config.toml --wallet wallet.key --clean

Docker Deployment

# Pull and run
docker pull qanto/node:latest
docker run -d --name qanto-node \
  -p 8545:8545 -p 30303:30303 \
  -v qanto-data:/data qanto/node:latest

Binary Release

# Download and run
wget https://github.com/qanto-org/qanto/releases/latest/download/qanto-linux-x64.tar.gz
tar -xzf qanto-linux-x64.tar.gz
./qanto-node --config mainnet.toml

Configuration

Basic config.toml setup:

[network]
port = 30303
bootstrap_nodes = [
  "/ip4/seed1.qanto.org/tcp/30303/p2p/12D3KooW..."
]

[rpc]
http_port = 8545
ws_port = 8546

[consensus]
block_time = 1000
max_block_size = 83886080
validator_set_size = 101

[mining]
enabled = true
algorithm = "qanhash"
threads = 0
gpu_enabled = true

[storage]
data_dir = "./qanto-data"
pruning_enabled = true

API Documentation

Qanto provides comprehensive REST and WebSocket APIs for blockchain interaction.

REST API Endpoints

# Blockchain queries
GET /api/v1/blocks/{height}
GET /api/v1/transactions/{hash}
GET /api/v1/accounts/{address}/balance

# Submit transaction
POST /api/v1/transactions
{
  "from": "qanto1sender...",
  "to": "qanto1recipient...",
  "amount": "1000000000",
  "fee": "1000",
  "signature": "0x..."
}

# Network information
GET /api/v1/network/info
GET /api/v1/validators
GET /api/v1/bridge/status

WebSocket API

Real-time event streaming:

const ws = new WebSocket('ws://localhost:8546');

// Subscribe to events
ws.send(JSON.stringify({
  "method": "subscribe",
  "params": ["newBlocks"]
}));

ws.onmessage = (event) => {
  console.log('New block:', JSON.parse(event.data));
};

SDK Integration

// JavaScript/TypeScript
import { QuantoClient } from '@qanto/sdk';

const client = new QuantoClient({
  endpoint: 'https://mainnet.qanto.org'
});

const tx = await client.sendTransaction({
  from: wallet.address,
  to: 'qanto1recipient...',
  amount: '1000000000'
});
# Python
from qanto_sdk import QuantoClient

client = QuantoClient('https://mainnet.qanto.network')
balance = client.get_balance('qanto1address...')

Technical Architecture

Qanto implements a revolutionary Layer-0 blockchain architecture:

Core Components

QantoDAG Ledger

  • Parallel Processing: 320,000 transactions per block with 80MB block size
  • Deterministic Ordering: DAG-based structure ensuring transaction consistency
  • Cross-Shard Atomicity: Seamless atomic transactions across multiple shards
  • State Management: Efficient UTXO model with RocksDB persistence

Multi-Layer Consensus

  • Proof of Work (PoW): Qanhash algorithm with GPU optimization and ASIC resistance
  • Delegated Proof of Stake (DPoS): Validator selection and governance
  • Proof of Storage/Execution (PoSe): Resource utilization verification
  • Byzantine Fault Tolerance: Resilient against up to 33% malicious nodes

Quantum-Resistant Security

  • Post-Quantum Signatures: CRYSTALS-Dilithium for transaction signing
  • Key Encapsulation: Kyber KEM for secure key exchange
  • Quantum-Hardened Hashing: Custom Qanhash32x algorithm
  • ΛΣ-ΩMEGA™ Framework: Modular cryptographic system integration

Cross-Chain Infrastructure

  • Universal Bridges: Support for Ethereum, Bitcoin, Cosmos, and Polkadot
  • Atomic Swap Engine: HTLC-based trustless asset exchanges
  • IBC Protocol: Inter-blockchain communication with light client verification
  • Asset Wrapping: Seamless cross-chain asset representation

Cross-Chain Interoperability

Supported Networks

Network Bridge Type Status Features
Ethereum Trustless ✅ Active ERC-20/721/1155 support
Bitcoin Federated ✅ Active Native BTC transfers
Cosmos IBC ✅ Active Native IBC protocol
Polkadot ZK-Proof 🔄 Beta Parachain integration
Solana Optimistic 🔄 Beta SPL token support
Avalanche Trustless 🔄 Beta C-Chain compatibility

Bridge Operations

# Cross-chain transfers
qanto-cli bridge deposit --chain ethereum --amount 1.5 --token ETH
qanto-cli bridge withdraw --chain ethereum --amount 1000000000 --token QETH

# Atomic swaps
qanto-cli swap create --offer "1000 QANTO" --request "0.1 BTC" --timeout 24h
qanto-cli swap complete --swap-id 0x123... --secret-key your-secret

Security Features

Vulnerability Management

  • Bug Bounty Program: Up to $1,000 for critical vulnerabilities
  • Responsible Disclosure: 90-day disclosure timeline
  • Security Updates: Automated security patch deployment
  • Incident Response: 24/7 security monitoring and response

Performance Benchmarks

Throughput Benchmarks

Configuration TPS Finality Block Size Network Load
Hyperscale 25,447,000 50ms 80MB 95% CPU
Production 200,580 100ms 40MB 70% CPU
Development 50,000 200ms 10MB 30% CPU
Testnet 10,000 500ms 2MB 15% CPU

Node Requirements

Node Type CPU RAM Storage Network
Full Validator 8 cores 8-16GB 50GB NVMe 100Mbps
Light Validator 4 cores 8GB 25GB SSD 50Mbps
Archive Node 32 cores 32GB 500GB HDD 1Gbps
RPC Node 16 cores 16-32GB 100GB SSD 500Mbps

Mining Performance

# GPU Mining (RTX 4090): 2.5 GH/s, 450W, 5.56 MH/W
# CPU Mining (AMD 7950X): 150 MH/s, 170W, 0.88 MH/W

Development

Building from Source

# Clone and setup
git clone https://github.com/qanto-org/qanto.git
cd qanto
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Build and test
cargo build --release
cargo test --all

# Run specific test suites
cargo test consensus::
cargo test interoperability::
cargo test security::

Development Environment

# Start local development network
cargo run --bin qanto-dev-network

# Run with debug logging
RUST_LOG=debug cargo run --bin qanto-node

# Performance profiling
cargo run --release --bin qanto-node --features profiling

Deployment

Production Deployment

# Infrastructure
cd infrastructure && terraform apply

# Kubernetes with Helm
helm upgrade --install qanto-api ./helm/api
helm upgrade --install qanto-boot-node ./helm/boot-node
helm upgrade --install qanto-website ./helm/website

# Docker Compose
docker-compose -f docker-compose.prod.yml up -d

Monitoring

# Health checks
curl http://localhost:8545/health
curl http://localhost:9090/metrics
qanto-cli node status

Documentation & Resources

  • Whitepaper: Formal specification and technical details
  • Architecture Guide: System architecture overview
  • Wallet Guide: CLI wallet operations
  • API Documentation: Complete REST and WebSocket specifications above
  • SDK Support: Multi-language SDKs for JavaScript, Python, Rust, and Go

Testnet Participation

Network Information

Quick Start

# Get testnet tokens
curl -X POST https://faucet.qanto.org/request \
  -d '{"address": "qanto1your-address..."}'

# Check balance and connect
qanto-cli balance qanto1your-address... --network testnet
qanto-cli connect --network testnet

# Setup validator
qanto-cli validator keygen --output validator-keys/
qanto-cli validator create --moniker "My Validator"
qanto-node --config testnet-validator.toml

For detailed instructions, see:

Security

Report security vulnerabilities responsibly:

Contributing

We welcome community contributions! Please read our Contributing Guidelines.

Development Process

  1. Fork the repository
  2. Create a feature branch
  3. Make changes with tests
  4. Run cargo test --all, cargo fmt, cargo clippy
  5. Submit a Pull Request

Guidelines

  • Follow Rust standard formatting
  • Write comprehensive tests
  • Update documentation for API changes
  • Follow our Code of Conduct

License

MIT License - see LICENSE file for details.

Qanto - Quantum-resistant Layer-0 blockchain with hyperscale performance.

Visit qanto.org | Follow [X] (https://x.com/QantoLayer0) | Join Discord

Recent Updates

Project Structure Updates

  • Updated configuration files: .cargo/config.toml, .github/workflows/main.yml, .gitignore, Cargo.lock, Cargo.toml, config-freetier.toml, config.toml.example, config.toml, docker-compose-freetier.yml
  • Updated documentation: docs/Optimizations.md, docs/QANTOWALLET_GUIDE.md, docs/ROADMAP.md, audits reports, and whitepaper
  • Modified Helm charts and values files for various components

Core Blockchain Updates

  • Updated myblockchain components including Cargo.toml, benchmarks, and core blockchain files
  • Enhanced node implementation files including advanced features, analytics, and various binaries
  • Resolved state root mismatch error in mining logic by removing post-payload transaction additions, ensuring consistent state calculations during block creation.
  • Improved transaction processing efficiency with optimized mempool management and batch processing.
  • Enhanced consensus algorithm for faster block times and higher transaction throughput.
  • Implemented sharding for improved scalability and parallel processing.
  • Enhanced interoperability with other blockchains through cross-chain protocols and bridges.
  • Improved security with enhanced consensus mechanisms and smart contract auditing tools.

SDK Updates

  • Updated JavaScript and Python SDK components

All tests have been verified to pass across the codebase.

About

Layer-0 blockchain featuring a DAG with hybrid consensus, governed by its SAGA AI for dynamic network optimization and unprecedented scalability.

Topics

infrastructure rust ai blockchain fintech post-quantum-cryptography dag decentralized-finance layer-0

Resources

Readme

License

MIT license

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity

Stars

3 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

1 tags

Sponsor this project

  •  
Learn more about GitHub Sponsors

Packages

No packages published

Contributors 3

  •  
  •  
  •  

Languages