Parallax | Open source P2P Programmable Cash System

XHash

The memory‑hard Proof‑of‑Work used by Parallax. Ethash‑style Hashimoto with Parallax’s consensus rules, difficulty mapping, and epoch handling.

Consensus‑Relevant Details

As reflected by xhash/consensus.go and Parallax chain config.

Aspect	Value / Behavior	Notes
Hash function (seal)	Legacy Keccak‑256	RLP over specific header fields
Target mapping	target = ⌊(2^256−1)/D⌋	Result must be ≤ target
MixDigest	Must equal computed digest	Mismatch ⇒ invalid PoW
MTP	Median of last 11	Enforced: Time > MTP(parent); Future drift ≤ 300s
Epoch length	Config‑defined (e.g., 720 blocks)	Determines cache/DAG regeneration cadence
Retarget interval	2016 blocks	Bitcoin-like retarget interval

Overview

XHash is Parallax’s Proof‑of‑Work engine: Ethash‑style Hashimoto (light/full) with Parallax‑specific consensus wiring, difficulty mapping, and epoch handling.

Mining evaluates Hashimoto over a header seal hash and 64‑bit nonce, using either a cache (light) or dataset (full).
Verification checks MixDigest equality and compares the result to a target derived from difficulty: target = ⌊(2^256−1)/D⌋.
Seal hash uses Legacy Keccak‑256 over an RLP list of specific header fields.

SealHash

pseudocode

SealHash(header):
  enc = [
    header.ParentHash,
    header.Coinbase,
    header.Root,
    header.TxHash,
    header.ReceiptHash,
    header.Bloom,
    header.Difficulty,
    header.Number,
    header.GasLimit,
    header.GasUsed,
    header.Time,
    header.Extra,
    header.EpochStartTime,
  ]
  if header.BaseFee != nil:
    enc.append(header.BaseFee)
  return keccak256(rlp.encode(enc))

Mining Loop

Hashimoto‑light/full with 64‑bit nonce search and little‑endian target compare in the inner loop.

Miners iterate nonce ∈ [0..2^64−1], computing (digest, result) = hashimoto(cache/dataset, sealHash, nonce).
MixDigest must match the header field exactly; result must be ≤ target.
Full miners use the per‑epoch dataset; light verifiers/nodes can validate with caches (no full DAG).
Dataset/cache regenerate on epoch boundaries (e.g., every 720 blocks)

Nonce search (pseudocode)

pseudocode

mine(header, cacheOrDataset):
  target = floor((2^256 - 1) / header.Difficulty)
  nonce  = random64()
  loop:
    (mix, res) = hashimoto(cacheOrDataset, SealHash(header), nonce)
    if mix == header.MixDigest and Big(res) <= target:
      return nonce
    nonce = (nonce + 1) mod 2^64

Header Verification

What a node checks before accepting a PoW header.

Size of Extra ≤ MaximumExtraDataSize.
Time ≤ now + 300s and Time > MTP(parent) (median of last 11).
EpochStartTime invariants: set on retarget boundary; otherwise equal to parent’s EpochStartTime.
Exact difficulty match: CalcNakamotoDifficulty(config, parent).
PoW seal: MixDigest equality and XHash(header) ≤ target(two256m1 / D).

verifySeal (conceptual)

pseudocode

verifySeal(h):
  require(h.Difficulty > 0)
  if fulldag:
    (mix, res) = hashimotoFull(dataset(epoch(h.Number)), SealHash(h), h.Nonce)
  else:
    (mix, res) = hashimotoLight(datasetSize(h.Number), cache(epoch(h.Number)), SealHash(h), h.Nonce)
  require(mix == h.MixDigest)
  target = floor((2^256 - 1) / h.Difficulty)
  require(Big(res) <= target)

Epochs, Cache & Dataset (DAG)

Regeneration cadence and miner compatibility notes.

Epoch number is derived from block height; cache/dataset sizes depend on epoch via datasetSize(height).
Parallax uses shorter epochs than legacy Ethash (e.g., 720‑block epochs) to fit ~5‑day regeneration at 10‑minute blocks.
Nodes keep caches to make verification light; full DAG not required to validate headers.

Regeneration trigger

pseudocode

if newEpoch(height):
  regenerate cache
  if mining full: regenerate dataset

Difficulty & Epoch Anchors

Interaction between PoW and the difficulty schedule.

Retarget every 2016 blocks.
On a boundary: header.EpochStartTime = header.Time; otherwise, propagate parent’s value.
CalcNakamotoDifficulty(config, parent) derives the next difficulty; PoW simply enforces it via the target check.
These rules are enforced in header verification before fork‑choice.

Anchor invariants

pseudocode

if height % R == 0:
  require(h.EpochStartTime == h.Time)
else:
  require(h.EpochStartTime == parent.EpochStartTime)

Difficulty Algorithm & Fork-choice Rules XHash Specification