DIFFICULTY (0x44)

(none)

Pre-Merge: block.difficulty (mining difficulty)
Post-Merge: block.prevrandao (beacon chain randomness)

Pre-Merge: stack.push(block.difficulty)
Post-Merge: stack.push(block.prevrandao)

Difficulty range: ~2 PH (petahash) average
Adjusts every block to maintain ~13.2 second block time
Higher difficulty = more computational work required

PREVRANDAO: 32-byte value from beacon chain
More unpredictable than PoW difficulty
Determined by beacon chain RANDAO mix
Cannot be manipulated by single validator

import { difficulty } from '@tevm/voltaire/evm/block';
import { createFrame } from '@tevm/voltaire/evm/Frame';

// Pre-merge frame
const preMergeFrame = createFrame({
  stack: [],
  hardfork: 'LONDON',
  blockContext: {
    block_difficulty: 10_000_000_000_000n // 10 TH
  }
});

difficulty(preMergeFrame);
console.log(preMergeFrame.stack); // [10000000000000n]

// Post-merge frame
const postMergeFrame = createFrame({
  stack: [],
  hardfork: 'PARIS',
  blockContext: {
    block_prevrandao: 0x123456789abcdef...n // Beacon chain randomness
  }
});

difficulty(postMergeFrame);
console.log(postMergeFrame.stack); // [beacon chain PREVRANDAO value]

// Detect if post-merge based on DIFFICULTY value
difficulty(frame);
const value = frame.stack[0];

// Pre-merge: Large difficulty value (billions+)
// Post-merge: PREVRANDAO (unpredictable 256-bit value)

const isPostMerge = /* check hardfork or use PREVRANDAO heuristics */;

// PRE-MERGE ONLY: Weak randomness
difficulty(frame);
const diff = frame.stack[0];

// Hash difficulty for pseudo-randomness (not secure!)
const random = keccak256(diff);

// POST-MERGE: Better randomness (still not secure for high stakes)
difficulty(frame); // Returns PREVRANDAO
const prevrandao = frame.stack[0];

// More unpredictable than PoW difficulty
// But still not suitable for high-value lotteries

// Pre-merge only
contract DifficultyAware {
    uint256 public constant MIN_DIFFICULTY = 1_000_000_000_000;

    function checkDifficulty() public view returns (bool) {
        return block.difficulty >= MIN_DIFFICULTY;
    }
}

// Post-merge: Use PREVRANDAO for improved randomness
contract RandomnessBetter {
    function randomNumber() public view returns (uint256) {
        // block.difficulty is now PREVRANDAO
        return uint256(keccak256(abi.encodePacked(
            block.prevrandao, // Same as block.difficulty post-merge
            block.timestamp,
            msg.sender
        )));
    }
}

contract MergeAware {
    uint256 public constant MERGE_BLOCK = 15_537_394;

    function getRandomness() public view returns (uint256) {
        if (block.number >= MERGE_BLOCK) {
            // Post-merge: Use PREVRANDAO
            return uint256(block.prevrandao);
        } else {
            // Pre-merge: Use difficulty (less random)
            return uint256(block.difficulty);
        }
    }
}

// Solidity 0.8.18+ has block.prevrandao
contract Modern {
    function getPrevrandao() public view returns (uint256) {
        return block.prevrandao; // Explicit name
    }

    function getDifficulty() public view returns (uint256) {
        return block.difficulty; // Still works, returns PREVRANDAO post-merge
    }
}

contract ImprovedLottery {
    // Post-merge PREVRANDAO is better but still manipulable
    function drawWinner(address[] memory participants) public view returns (address) {
        // PREVRANDAO is more unpredictable than PoW difficulty
        // But validators can still influence it slightly
        uint256 randomness = uint256(keccak256(abi.encodePacked(
            block.prevrandao,
            block.timestamp,
            participants.length
        )));

        uint256 index = randomness % participants.length;
        return participants[index];
    }
}

// VULNERABLE (Pre-Merge)
contract DifficultyLottery {
    function draw() external {
        uint256 winner = uint256(block.difficulty) % 100;
        // Miner can try different nonces to influence difficulty
    }
}

// IMPROVED but not perfect (Post-Merge)
contract PrevrandaoLottery {
    function draw() external {
        uint256 winner = uint256(block.prevrandao) % 100;
        // Validators can influence RANDAO reveal but:
        // - Must reveal in advance (can't see outcome first)
        // - Mixed with many other validators
        // - Still not suitable for high-stakes randomness
    }
}

// BROKEN POST-MERGE
contract DifficultyThreshold {
    function isHighDifficulty() public view returns (bool) {
        // Pre-merge: Returns true if mining difficulty high
        // Post-merge: Returns unpredictable value (PREVRANDAO)
        return block.difficulty > 10_000_000_000_000;
    }
}

// SECURE: Chainlink VRF
contract SecureLottery {
    VRFCoordinatorV2Interface COORDINATOR;

    function requestRandomWords() external {
        // Request verifiable randomness from Chainlink
        uint256 requestId = COORDINATOR.requestRandomWords(
            keyHash,
            subId,
            requestConfirmations,
            callbackGasLimit,
            numWords
        );
    }

    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal {
        // Use cryptographically secure randomness
        uint256 winner = randomWords[0] % participants.length;
    }
}

// Genesis or test network
const frame = createFrame({
  hardfork: 'LONDON',
  blockContext: { block_difficulty: 0n }
});

difficulty(frame);
console.log(frame.stack); // [0n]

// Random 256-bit value from beacon chain
const frame = createFrame({
  hardfork: 'PARIS',
  blockContext: {
    block_prevrandao: 0x9876543210abcdef...n
  }
});

difficulty(frame);
console.log(frame.stack); // [PREVRANDAO value]

// Pre-merge: Theoretical max difficulty
const maxDifficulty = (1n << 256n) - 1n;

// Post-merge: Any 256-bit value possible
const anyPrevrandao = 0xffffffffffffffffffffffffffffffffffffffffn;

// Pre-merge: Difficulty adjusted to maintain ~13.2s blocks
// Difficulty Bomb: Exponentially increasing difficulty
// Ice Age: Periods of increased difficulty to force upgrades

Block 15,537,393: Last PoW block
Block 15,537,394: First PoS block (TTD reached)

Pre-Merge:  DIFFICULTY = mining difficulty
Post-Merge: DIFFICULTY = PREVRANDAO (beacon chain randomness)

Opcode: 0x44
Name: DIFFICULTY (unchanged)
Return: PREVRANDAO (semantic change)
Rationale: Reuse opcode, avoid breaking EVM layout