Epoch Length: 2048 blocks (~2.8 days at 2-minute blocks)
Epoch Key: SHA3-256("INTcoin-RandomX-Epoch-{N}")

Block 0-2047:    Epoch 0
Block 2048-4095:  Epoch 1
Block 4096-6143:  Epoch 2
...

// x86_64 (Intel/AMD)
- JIT compilation enabled
- Hardware AES instructions
- AVX2 vectorization

// ARM64 (Apple Silicon, AWS Graviton)
- Hardware AES instructions
- NEON vectorization
- Software JIT

// Other architectures
- Interpreter mode
- Software AES
- Portable implementation

#include "intcoin/consensus.h"

// Initialize RandomX (call once at startup)
auto init_result = RandomXValidator::Initialize();
if (init_result.IsError()) {
    // Handle error
}

// Calculate hash for block header
BlockHeader header;
header.version = 1;
header.prev_block_hash = previous_block.GetHash();
header.merkle_root = CalculateMerkleRoot(transactions);
header.timestamp = GetCurrentTime();
header.bits = next_difficulty;
header.nonce = 0;
header.randomx_key = RandomXValidator::GetRandomXKey(height);

// Mine (find valid nonce)
while (true) {
    auto hash_result = RandomXValidator::CalculateHash(header);
    if (hash_result.IsOk()) {
        uint256 hash = *hash_result.value;
        if (hash < target) {
            // Found valid block!
            header.randomx_hash = hash;
            break;
        }
    }
    header.nonce++;
}

// Validate block hash
auto validate_result = RandomXValidator::ValidateBlockHash(header);
if (validate_result.IsOk()) {
    // Block is valid
}

// Update dataset for new epoch (automatic)
if (RandomXValidator::NeedsDatasetUpdate(height)) {
    RandomXValidator::UpdateDataset(height);
}

// Shutdown (call at exit)
RandomXValidator::Shutdown();

Result<void> RandomXValidator::Initialize();
void RandomXValidator::Shutdown();
Result<uint256> RandomXValidator::CalculateHash(const BlockHeader& header);
Result<void> RandomXValidator::ValidateBlockHash(const BlockHeader& header);
uint256 RandomXValidator::GetRandomXKey(uint64_t height);
bool RandomXValidator::NeedsDatasetUpdate(uint64_t height);
Result<void> RandomXValidator::UpdateDataset(uint64_t height);

randomx_cache* g_randomx_cache;  // RandomX cache
randomx_vm* g_randomx_vm;        // RandomX VM
uint256 g_current_key;           // Current epoch key
uint64_t g_current_epoch;        // Current epoch number
std::mutex g_randomx_mutex;      // Thread safety
bool g_randomx_initialized;      // Initialization flag

DIFFICULTY_AVERAGING_WINDOW = 120 blocks  // V5: increased from 60
MEDIAN_TIMESTAMP_WINDOW = 11 blocks       // V5: new
DAMPING_FACTOR_UP = 3                     // V5: asymmetric (faster increase)
DAMPING_FACTOR_DOWN = 4                   // V5: asymmetric (slower decrease)
EWMA_DECAY = 0.97                         // V5: new
TARGET_BLOCK_TIME = 120 seconds

function GetNextWorkRequired(last_block, blockchain):
    // Get last N blocks
    blocks = blockchain.GetLastNBlocks(DIFFICULTY_AVERAGING_WINDOW)

    // V5: Use median timestamps (prevents manipulation)
    newest_median = GetMedianTimestamp(blocks[0:11])
    oldest_median = GetMedianTimestamp(blocks[109:120])
    actual_timespan = newest_median - oldest_median

    // Calculate expected timespan
    expected_timespan = (AVERAGING_WINDOW - MEDIAN_WINDOW) * TARGET_BLOCK_TIME

    // V5: Asymmetric damping (resists time-warp attacks)
    if actual_timespan < expected_timespan:
        // Blocks too fast - allow faster difficulty increase
        min_timespan = expected_timespan / DAMPING_FACTOR_UP
        actual_timespan = max(min_timespan, actual_timespan)
    else:
        // Blocks too slow - allow slower difficulty decrease
        max_timespan = expected_timespan * DAMPING_FACTOR_DOWN
        actual_timespan = min(max_timespan, actual_timespan)

    // V5: EWMA - weight recent blocks higher
    weights[i] = EWMA_DECAY^i  // Recent blocks weighted ~3x more
    avg_difficulty = WeightedAverage(blocks.difficulty, weights)

    // Calculate new difficulty
    new_difficulty = avg_difficulty * expected_timespan / actual_timespan

    return new_difficulty

// src/consensus/consensus.cpp

uint32_t DifficultyCalculator::GetNextWorkRequired(
    const BlockHeader& last_block,
    const Blockchain& chain
) {
    const int AVERAGING_WINDOW = 60;
    const int DAMPING_FACTOR = 4;

    // Get last N blocks
    std::vector<BlockHeader> blocks;
    for (int i = 0; i < AVERAGING_WINDOW; i++) {
        blocks.push_back(chain.GetBlockHeader(last_block.height - i));
    }

    // Calculate actual timespan
    uint64_t actual_timespan = blocks[0].timestamp - blocks[AVERAGING_WINDOW-1].timestamp;

    // Calculate average difficulty
    uint256 total_difficulty{};
    for (const auto& block : blocks) {
        total_difficulty += CompactToTarget(block.bits);
    }
    uint256 avg_difficulty = total_difficulty / AVERAGING_WINDOW;

    // Calculate expected timespan
    uint64_t expected_timespan = (AVERAGING_WINDOW - 1) * consensus::TARGET_BLOCK_TIME;

    // Apply damping
    uint64_t min_timespan = expected_timespan / DAMPING_FACTOR;
    uint64_t max_timespan = expected_timespan * DAMPING_FACTOR;
    actual_timespan = std::clamp(actual_timespan, min_timespan, max_timespan);

    // Calculate new difficulty
    uint256 new_target = avg_difficulty * actual_timespan / expected_timespan;

    // Enforce limits
    if (new_target > consensus::MAX_TARGET) {
        new_target = consensus::MAX_TARGET;
    }
    if (new_target < consensus::MIN_TARGET) {
        new_target = consensus::MIN_TARGET;
    }

    return TargetToCompact(new_target);
}

uint256 DifficultyCalculator::CompactToTarget(uint32_t compact) {
    // Convert compact difficulty representation to full target
    uint32_t exponent = compact >> 24;
    uint32_t mantissa = compact & 0x00FFFFFF;

    uint256 target{};
    if (exponent <= 3) {
        mantissa >>= (8 * (3 - exponent));
        target = uint256{mantissa};
    } else {
        target = uint256{mantissa};
        // Shift left by (exponent - 3) bytes
        // Implementation needed
    }

    return target;
}

uint32_t DifficultyCalculator::TargetToCompact(const uint256& target) {
    // Convert full target to compact difficulty representation
    // Find first non-zero byte
    int leading_zeros = 0;
    for (int i = 31; i >= 0; i--) {
        if (target[i] != 0) {
            break;
        }
        leading_zeros++;
    }

    uint32_t exponent = 32 - leading_zeros;
    uint32_t mantissa = /* extract 3 bytes */;

    return (exponent << 24) | mantissa;
}

uint64_t GetBlockReward(uint64_t height) {
    uint64_t halvings = height / consensus::HALVING_INTERVAL; // 1,051,200 blocks

    if (halvings >= consensus::MAX_HALVINGS) { // 64 halvings
        return 0;
    }

    uint64_t reward = consensus::INITIAL_BLOCK_REWARD; // 105,113,636 INT
    reward >>= halvings; // Divide by 2^halvings

    return reward;
}

uint64_t GetSupplyAtHeight(uint64_t height) {
    uint64_t supply = 0;
    uint64_t current_height = 0;

    while (current_height < height) {
        uint64_t next_halving = ((current_height / consensus::HALVING_INTERVAL) + 1)
                               * consensus::HALVING_INTERVAL;
        uint64_t blocks_this_period = std::min(next_halving, height) - current_height;

        supply += blocks_this_period * GetBlockReward(current_height);
        current_height += blocks_this_period;
    }

    return supply;
}

// Coinbase validation checks:
1. Transaction must be a coinbase (1 input with prevout index = 0xFFFFFFFF)
2. Calculate block subsidy with halving based on height
3. Total output ≤ (subsidy + transaction fees)
4. Outputs must exist and have valid scripts
5. Miners may claim less than full reward (burns allowed)

Result<void> ConsensusValidator::ValidateCoinbase(const Transaction& coinbase,
                                                 uint64_t height,
                                                 uint64_t total_fees) {
    // 1. Check if this is actually a coinbase transaction
    if (!coinbase.IsCoinbase()) {
        return Result<void>::Error("Transaction is not a coinbase transaction");
    }

    // 2. Calculate block subsidy with halving
    uint64_t subsidy = 0;
    uint64_t halving_count = height / consensus::HALVING_INTERVAL;

    if (halving_count >= consensus::MAX_HALVINGS) {
        // After max halvings, no more subsidy (only fees)
        subsidy = 0;
    } else {
        // Halve the reward for each halving period using bit shift
        subsidy = consensus::INITIAL_BLOCK_REWARD >> halving_count;
    }

    // 3. Calculate expected reward (subsidy + fees)
    uint64_t expected_reward = subsidy + total_fees;

    // 4. Validate outputs exist
    if (coinbase.outputs.empty()) {
        return Result<void>::Error("Coinbase transaction has no outputs");
    }

    // 5. Validate output scripts are not empty
    for (const auto& output : coinbase.outputs) {
        if (output.script_pubkey.bytes.empty()) {
            return Result<void>::Error("Coinbase output has empty script");
        }
    }

    // 6. Check total output value doesn't exceed expected reward
    uint64_t total_output = coinbase.GetTotalOutputValue();

    if (total_output > expected_reward) {
        return Result<void>::Error(
            "Coinbase output value exceeds expected reward (got " +
            std::to_string(total_output) + ", expected max " +
            std::to_string(expected_reward) + ")"
        );
    }

    // Note: It's acceptable for miners to claim less than the full reward
    // (this is sometimes done intentionally or due to bugs)

    return Result<void>::Ok();
}

// Every 1,051,200 blocks (~4 years), reward halves
uint64_t halving_count = height / 1051200;

// Bit shift right = divide by 2^n
// subsidy >>= 1  means subsidy = subsidy / 2
// subsidy >> n   means subsidy = subsidy / 2^n

uint64_t subsidy = 105113636 >> halving_count;

// Examples:
// Height 0:         105113636 >> 0 = 105,113,636 INT
// Height 1,051,200: 105113636 >> 1 =  52,556,818 INT
// Height 2,102,400: 105113636 >> 2 =  26,278,409 INT
// Height 3,153,600: 105113636 >> 3 =  13,139,204 INT

#include "intcoin/consensus.h"

// Validate a block's coinbase transaction
Block block;
uint64_t total_fees = 0;

// Calculate fees from all non-coinbase transactions
for (size_t i = 1; i < block.transactions.size(); i++) {
    const auto& tx = block.transactions[i];

    // Get input value
    uint64_t input_value = 0;
    for (const auto& input : tx.inputs) {
        auto utxo = blockchain.GetUTXO(input.prevout);
        if (utxo.IsOk()) {
            input_value += utxo.value->amount;
        }
    }

    // Get output value
    uint64_t output_value = tx.GetTotalOutputValue();

    // Fee = input - output
    if (input_value > output_value) {
        total_fees += (input_value - output_value);
    }
}

// Validate coinbase
auto result = ConsensusValidator::ValidateCoinbase(
    block.transactions[0],  // Coinbase must be first transaction
    block.header.height,
    total_fees
);

if (result.IsError()) {
    std::cerr << "Coinbase validation failed: " << result.error << "\n";
    // Reject block
}

namespace consensus {
    constexpr uint64_t TARGET_BLOCK_TIME = 120;           // 2 minutes
    constexpr uint64_t HALVING_INTERVAL = 1051200;       // ~4 years
    constexpr uint64_t INITIAL_BLOCK_REWARD = 105113636; // INT
    constexpr uint64_t MAX_HALVINGS = 64;
    constexpr uint64_t MAX_SUPPLY = 221000000000000;     // 221 Trillion INT
    constexpr uint64_t MAX_BLOCK_SIZE = 8 * 1024 * 1024; // 8 MB
    constexpr uint64_t COINBASE_MATURITY = 100;          // blocks
    constexpr uint32_t MIN_DIFFICULTY_BITS = 0x1f00ffff;
}