type ChainHeadType = {
  readonly number: BlockNumber;
  readonly hash: BlockHash;
  readonly timestamp: Uint256;        // Unix seconds
  readonly difficulty?: Uint256;      // 0 post-merge
  readonly totalDifficulty?: Uint256; // Cumulative from genesis
};

import { ChainHead } from '@tevm/voltaire/primitives';

// From RPC response
const block = await rpc.eth_getBlockByNumber('latest', false);
const head = ChainHead.from({
  number: block.number,
  hash: block.hash,
  timestamp: block.timestamp
});

console.log(`Block ${head.number}`);
console.log(`Hash: ${BlockHash.toHex(head.hash)}`);
console.log(`Timestamp: ${head.timestamp}`);

const head = ChainHead.from({
  number: 18000000n,
  hash: blockHash,
  timestamp: 1699000000n,
  difficulty: 0n  // Proof of Stake
});

console.log('Post-merge block (PoS)');

const head = ChainHead.from({
  number: 15000000n,
  hash: blockHash,
  timestamp: 1650000000n,
  difficulty: 12000000000000000n,          // Block difficulty
  totalDifficulty: 58750003716598352816469n // Cumulative
});

console.log(`Difficulty: ${head.difficulty}`);
console.log(`Total difficulty: ${head.totalDifficulty}`);

// Get latest block
const block = await rpc.eth_getBlockByNumber('latest', false);

const head = ChainHead.from({
  number: BigInt(block.number),
  hash: block.hash,
  timestamp: BigInt(block.timestamp),
  difficulty: block.difficulty ? BigInt(block.difficulty) : undefined,
  totalDifficulty: block.totalDifficulty ? BigInt(block.totalDifficulty) : undefined
});

const blockNumber = await rpc.eth_blockNumber();
console.log(`Current block: ${blockNumber}`);

function isPostMerge(head) {
  return head.difficulty === 0n;
}

function isPreMerge(head) {
  return head.difficulty && head.difficulty > 0n;
}

const now = BigInt(Math.floor(Date.now() / 1000));
const age = now - head.timestamp;

console.log(`Block age: ${age} seconds`);
console.log(`Block age: ${age / 60n} minutes`);

const now = BigInt(Math.floor(Date.now() / 1000));
const age = now - head.timestamp;

if (age < 30n) {
  console.log('Network healthy: recent block');
} else if (age < 300n) {
  console.log('Network normal');
} else {
  console.log('Warning: stale block data');
}

let previousHead = null;

async function checkForReorg() {
  const block = await rpc.eth_getBlockByNumber('latest', false);
  const currentHead = ChainHead.from(block);

  if (previousHead) {
    // Same number but different hash = reorg
    if (currentHead.number === previousHead.number &&
        !BlockHash.equals(currentHead.hash, previousHead.hash)) {
      console.log('Chain reorganization detected!');
    }

    // Number went backwards = deep reorg
    if (currentHead.number < previousHead.number) {
      console.log('Deep reorganization detected!');
    }
  }

  previousHead = currentHead;
}

setInterval(checkForReorg, 12000);  // Check every 12 seconds

async function isFinalized(blockNumber, rpc) {
  const latest = await rpc.eth_getBlockByNumber('latest', false);
  const currentBlock = BigInt(latest.number);

  // ~64 blocks per epoch, 2 epochs for finality
  const finalityDistance = 128n;

  return currentBlock - blockNumber >= finalityDistance;
}

const safeBlock = await rpc.eth_getBlockByNumber('safe', false);
const safeHead = ChainHead.from(safeBlock);

console.log(`Safe block: ${safeHead.number}`);

async function waitForBlock(targetBlock, rpc) {
  while (true) {
    const block = await rpc.eth_getBlockByNumber('latest', false);
    const head = ChainHead.from(block);

    if (head.number >= targetBlock) {
      return head;
    }

    await new Promise(resolve => setTimeout(resolve, 12000));
  }
}

async function getBlockRate(rpc, samples = 10) {
  const latest = await rpc.eth_getBlockByNumber('latest', false);
  const latestHead = ChainHead.from(latest);

  const oldBlockNum = latestHead.number - BigInt(samples);
  const old = await rpc.eth_getBlockByNumber(`0x${oldBlockNum.toString(16)}`, false);
  const oldHead = ChainHead.from(old);

  const timeDelta = latestHead.timestamp - oldHead.timestamp;
  const blockDelta = latestHead.number - oldHead.number;

  const blocksPerSecond = Number(blockDelta) / Number(timeDelta);
  return blocksPerSecond;
}