mirror of https://github.com/luxfi/chains.git synced 2026-09-24 00:26:00 +00:00

Files

T

zeekay 8045450815 feat: move all VM implementations into chains/

VMs now live in ONE place: chains/<name>/ owns the full implementation.
Previously split across node/vms/<name>/ (impl) + chains/<name>/main.go
(plugin wrapper). Now consolidated.

New layout:
  chains/<name>vm/*.go              — package <name>vm (VM code)
  chains/<name>vm/cmd/plugin/main.go — package main (plugin binary)
  chains/<name>vm/go.mod             — module github.com/luxfi/chains/<name>vm

Moved 11 VMs: aivm, bridgevm, dexvm, graphvm, identityvm, keyvm,
oraclevm, quantumvm, relayvm, thresholdvm, zkvm.

External callers now import github.com/luxfi/chains/<name> directly.

2026-04-13 05:27:00 -07:00

4.4 KiB

Raw Blame History

Q-chain Virtual Machine (QVM)

The Q-chain Virtual Machine (QVM) is a quantum-resistant blockchain virtual machine implementation for the Lux Network. It provides advanced cryptographic features including quantum signatures and parallel transaction processing.

Features

Quantum Resistance

Corona Key Support: Quantum-resistant key generation and management
Quantum Signatures: Post-quantum cryptographic signatures for transaction and block validation
Quantum Stamp Validation: Time-based quantum stamps for enhanced security

Performance Optimization

Parallel Transaction Processing: Process multiple transactions concurrently
Configurable Batch Sizes: Optimize throughput based on network conditions
Worker Pool Architecture: Efficient resource utilization with pooled workers

Configuration

The QVM can be configured through the config.Config structure:

type Config struct {
    TxFee                   uint64        // Base transaction fee
    CreateAssetTxFee        uint64        // Asset creation fee
    QuantumVerificationFee  uint64        // Fee for quantum signature verification
    MaxParallelTxs          int           // Maximum parallel transactions
    QuantumAlgorithmVersion uint32        // Quantum algorithm version
    CoronaKeySize         int           // Size of Corona keys in bytes
    QuantumStampEnabled     bool          // Enable quantum stamp validation
    QuantumStampWindow      time.Duration // Validity window for quantum stamps
    ParallelBatchSize       int           // Batch size for parallel processing
    QuantumSigCacheSize     int           // Cache size for quantum signatures
    CoronaEnabled         bool          // Enable Corona key support
    MinQuantumConfirmations uint32        // Minimum confirmations for quantum stamps
}

Architecture

Core Components

VM (vm.go): Main virtual machine implementation
Factory (factory.go): VM factory for creating QVM instances
Config (config/config.go): Configuration management
Quantum Signer (quantum/signer.go): Quantum signature implementation

Transaction Flow

Transactions are submitted to the transaction pool
Worker threads process transactions in parallel batches
Quantum signatures are verified using the quantum signer
Valid transactions are included in blocks
Blocks are signed with quantum stamps

RPC API

The QVM exposes the following RPC endpoints:

qvm.getBlock: Retrieve a block by ID
qvm.generateCoronaKey: Generate a new Corona key pair
qvm.verifyQuantumSignature: Verify a quantum signature
qvm.getPendingTransactions: Get pending transactions
qvm.getHealth: Get VM health status
qvm.getConfig: Get current configuration

Security Features

Quantum Signatures

The QVM implements quantum-resistant signatures using:

SHA-512 based hashing with quantum noise
XOR-based signature generation with private keys
Time-windowed validation to prevent replay attacks

Corona Keys

Corona keys provide:

Large key sizes (default 1024 bytes)
Version tracking for algorithm upgrades
Nonce-based randomization

Parallel Processing Safety

Thread-safe transaction pool with mutex protection
Isolated worker threads for transaction processing
Atomic operations for state updates

Usage

Creating a QVM Instance

factory := &qvm.Factory{
    Config: config.DefaultConfig(),
}

vm, err := factory.New(logger)
if err != nil {
    return err
}

Initializing the VM

err := vm.Initialize(
    ctx,
    chainRuntime,
    db,
    genesisBytes,
    upgradeBytes,
    configBytes,
    toEngine,
    fxs,
    appSender,
)

Building Blocks

block, err := vm.BuildBlock(ctx)
if err != nil {
    return err
}

Testing

The QVM includes comprehensive error handling and logging for production use:

Error recovery for parallel processing failures
Detailed logging at all levels (Info, Debug, Error)
Health check monitoring
Metrics collection

Future Enhancements

Planned improvements include:

Additional quantum-resistant algorithms (SPHINCS+, Dilithium, Falcon)
Enhanced parallel processing with GPU acceleration
Cross-chain quantum signature verification
Advanced caching strategies for improved performance

4.4 KiB Raw Blame History