// BTQ Genesis Block
nTime = 1771804800;
nNonce = 184980;
hashGenesisBlock = 0x0000ca45ea08433961609b50cd0c3f76d14589f8f61973ebbc344c3a160f7cdd

pchMessageStart[0] = 0xf1;
pchMessageStart[1] = 0xb2;
pchMessageStart[2] = 0xa3;
pchMessageStart[3] = 0xd4;

// Maximum block sizes
static const unsigned int MAX_BLOCK_SERIALIZED_SIZE = 8000000;  // 8MB
static const unsigned int MAX_BLOCK_WEIGHT = 8000000;           // 8MW
static const unsigned int MAX_BLOCK_SIGOPS_COST = 80000;        // 4x Bitcoin

// Transaction limits (increased for Dilithium)
static const unsigned int MAX_STANDARD_TX_WEIGHT = 400000;

src/crypto/
├── dilithium/           # Dilithium reference implementation
│   ├── api.h
│   ├── params.h
│   ├── sign.c
│   ├── packing.c
│   ├── polyvec.c
│   └── ...
├── dilithium_key.h      # C++ key wrapper
├── dilithium_key.cpp
├── dilithium_wrapper.h  # C/C++ interface
├── dilithium_wrapper.c
├── sha256.cpp           # Existing Bitcoin crypto
├── ripemd160.cpp
└── ...

// Private key wrapper
class CDilithiumKey {
    std::vector<unsigned char> keydata;  // 2,560 bytes
    
    void MakeNewKey();                    // Generate keypair
    bool Sign(const uint256& hash, 
              std::vector<unsigned char>& sig);
    CDilithiumPubKey GetPubKey() const;
    bool IsValid() const;
};

// Public key wrapper
class CDilithiumPubKey {
    std::vector<unsigned char> keydata;  // 1,312 bytes
    
    bool Verify(const uint256& hash,
                const std::vector<unsigned char>& sig);
    CKeyID GetID() const;  // RIPEMD160(SHA256(pubkey))
};

// Added for Dilithium verification
OP_CHECKSIGDILITHIUM     // Verify Dilithium signature
OP_DILITHIUM_PUBKEY      // Mark Dilithium script

<1312-byte pubkey> OP_CHECKSIGDILITHIUM

scriptPubKey: OP_0 <20-byte hash>
witness:      <2421-byte sig> <1312-byte pubkey>

scriptPubKey: OP_2 <32-byte merkle_root>
witness:      <stack args...> <leaf script> <control block>

// In interpreter.cpp
bool is_dilithium = (pubkey.size() > 100);  // 1312 vs 33

if (is_dilithium) {
    // Use OP_CHECKSIGDILITHIUM
} else {
    // Use OP_CHECKSIG (ECDSA)
}

// Wallet database records
DILITHIUM_KEY          // Unencrypted Dilithium key
DILITHIUM_CRYPTED_KEY  // Encrypted Dilithium key

Key:   (DILITHIUM_KEY, KeyID)
Value: 2560-byte raw private key

Key:   (DILITHIUM_CRYPTED_KEY, KeyID)  
Value: AES-256-CBC encrypted key

CKeyID GetID() const {
    uint256 hash;
    SHA256(pubkey.data(), pubkey.size(), hash.data());
    
    CKeyID id;
    RIPEMD160(hash.data(), 32, id.data());
    return id;  // 20 bytes
}

// Mainnet
base58Prefixes[PUBKEY_ADDRESS] = {75};     // B...
base58Prefixes[DILITHIUM_PUBKEY] = {76};   // D...
base58Prefixes[SCRIPT_ADDRESS] = {135};    // Q...
base58Prefixes[DILITHIUM_SCRIPT] = {136};  // R...

// Bech32 Human-Readable Part
bech32_hrp = "qbtc";  // qbtc1q...

┌─────────────────┐
│ Dilithium       │
│ Public Key      │
│ (1,312 bytes)   │
└────────┬────────┘
         │
         ▼
    SHA-256 Hash
         │
         ▼
  RIPEMD-160 Hash
         │
         ▼
┌─────────────────┐
│ Public Key Hash │
│ (20 bytes)      │
└────────┬────────┘
         │
    ┌────┴────┐
    ▼         ▼
Base58      Bech32m
  X...     qbtc1z...
(historical) (P2MR, current)

// Address generation
"getnewdilithiumaddress"
    -> Generate new Dilithium address

// Message signing
"signmessagewithdilithium"
    -> Sign message with Dilithium key
"verifydilithiumsignature"
    -> Verify Dilithium signature

// Transaction signing
"signtransactionwithdilithium"
    -> Sign transaction with Dilithium

// Key management
"importdilithiumkey"
    -> Import Dilithium private key

1. Select UTXOs (listunspent)
2. Build transaction (createrawtransaction)
3. Sign with Dilithium (signtransactionwithdilithium)
4. Broadcast (sendrawtransaction)

// For each input:
1. Check UTXO exists and is unspent
2. Determine signature type (size-based)
3. If Dilithium:
   a. Extract 2421-byte signature from witness
   b. Extract 1312-byte pubkey from witness
   c. Compute sighash (BIP-143 style)
   d. Verify: Dilithium2.Verify(pubkey, sighash, sig)
4. Check amounts (inputs >= outputs + fees)
5. Accept to mempool

┌──────────┐    inv(txid)    ┌──────────┐
│  Node A  │ ───────────────▶│  Node B  │
│          │◀─────────────── │          │
│          │   getdata(txid) │          │
│          │ ───────────────▶│          │
│          │     tx(data)    │          │
└──────────┘                 └──────────┘

# Run all unit tests
make check

# Run specific Dilithium tests
./src/test/test_btq --run_test=dilithium_key_tests
./src/test/test_btq --run_test=dilithium_address_script_tests
./src/test/test_btq --run_test=dilithium_wallet_tests
./src/test/test_btq --run_test=dilithium_descriptor_tests

# Run all functional tests
./test/functional/test_runner.py

# Run BTQ-specific tests
./test/functional/btq_regtest_mining.py
./test/functional/btq_chain_identity.py

# Core dependencies
build-essential, libtool, autotools-dev, automake
pkg-config, bsdmainutils, python3

# Crypto/network
libevent-dev, libboost-dev, libsqlite3-dev

# Optional
libqt5-dev (GUI), libdb-dev (legacy wallet)

./autogen.sh
./configure [options]
make -j$(nproc)
make check  # Run tests