Difficulty without the wobble.
BTX retargets every single block — against a fixed schedule.
Most people assume a Bitcoin-derived chain inherits Bitcoin's difficulty rule: measure how long the last 2,016 blocks took, nudge difficulty up or down, repeat every two weeks. BTX does not do that. It also does not use Dash's DarkGravityWave for MatMul mining. Instead it uses ASERT — specifically the aserti3-2d algorithm, the same family Bitcoin Cash adopted — and it retargets every block.
ASERT stands for Absolutely Scheduled Exponentially Rising Targets. Rather than reacting to the previous block, it pins difficulty to an absolute schedule anchored at one fixed block and computes the next target as a smooth exponential of how far ahead or behind that schedule the chain currently sits. The payoff: no accumulated error, and none of the ringing the relative scheme produces. This is how the mechanism works, why the difficulty climbs the way operators have been seeing, and the implementation details that make it safe for consensus.
Whyte Consolidated Research · 2026-06-22· 9 min read
Not Bitcoin's epoch retarget. Not DarkGravityWave. ASERT.
Bitcoin's rule is relative: it looks at how long the last 2,016 blocks took and adjusts difficulty from its previous value, once per epoch. That feedback loop overshoots — difficulty tends to oscillate around the target rather than settle on it. Dash's DarkGravityWave is a faster relative scheme, and a DarkGravityWaveLegacy function does still exist in the BTX source — but it is dead code for MatMul mining. The comments are unambiguous: “DGW is NOT used for MatMul mining -- ASERT only.”
ASERT takes a different stance. It does not ask “how did the last few blocks do relative to the previous difficulty?” It asks “where shouldthe chain be by now, against a schedule fixed at one anchor block — and how far off is it?” That single change, from relative to absolute, is what removes the accumulated error and the oscillation.
- ✓Per-block retarget — every block's target is recomputed, not just once per epoch.
- ✓aserti3-2d — the same ASERT family Bitcoin Cash adopted.
- ✓Anchored to an absolute schedule at block 50,000, not nudged from the parent.
- ✓90-second target spacing; one-hour half-life sensitivity.
- ✓Deterministic fixed-point 2^x — identical on every node.
- ✓Fail-closed: bad parameters return powLimit, never a crash.
- ✕Not Bitcoin's 2,016-block epoch retarget (the relative scheme that oscillates).
- ✕Not Dash's DarkGravityWave for MatMul mining.
- ✕DarkGravityWaveLegacy exists in the code but is dead for MatMul.
- ✕No accumulated error — absolute anchoring means no Bitcoin-style ringing.
One formula, anchored to a fixed point in the chain.
The whole adjustment is a single exponential, measured relative to the anchor block:
next_target = anchor_target × 2^((time_diff − ideal_delta) / half_life) ideal_delta = target_spacing × (height_diff + 1)
| Term | Meaning | Value |
|---|---|---|
| time_diff | Actual seconds elapsed since the anchor block | measured |
| height_diff | Blocks mined since the anchor | measured |
| ideal_delta | How many seconds should have elapsed | 90 × (h+1) |
| target_spacing | Ideal time between blocks | 90 s |
| half_life | Sensitivity constant (nMatMulAsertHalfLife) | 3,600 s |
Source references: src/pow.cpp:1747 (the formula), src/kernel/chainparams.cpp:155 (90s spacing), src/kernel/chainparams.cpp:213 (one-hour half-life).
Behind schedule, difficulty drops. Ahead, it rises. By octaves.
The sign of the exponent does all the work. If the chain is running behind schedule — blocks coming too slowly, so time_diff > ideal_delta — the exponent is positive, the target rises, and difficulty dropsto invite blocks back onto schedule. If it's running ahead — blocks too fast — the exponent goes negative, the target shrinks, and difficulty rises.
The one-hour half-life sets the rate of that response. For every hour the chain is behind its ideal schedule, the target doubles — difficulty halves. For every hour ahead, difficulty doubles. That is exactly the steep climb operators have been seeing: sustained hashrate well above target pulls difficulty up roughly an octave per hour, so a couple of hours of heavy mining shows up as the ~4× rise.
Crucially, because the target is always measured against the absoluteanchor schedule and not the previous block, small errors don't compound from one block to the next. There's no feedback loop chasing its own tail — and so none of the Bitcoin-style ringing where difficulty keeps overshooting the level it's trying to find.
The engineering that makes an exponential safe for consensus.
Per-block, anchored. The anchor is the ASERT activation block — mainnet height 50,000 (chainparams.cpp:212). It is re-anchored only if an optional retune or half-life upgrade activates, and none are configured on mainnet — those heights are set to INT32_MAX.
Fixed-point 2^x.A blockchain can't do real exponentials — floating point would diverge between nodes and break consensus. So the exponent is scaled by 2^16 (ASERT_RADIX_BITS = 16) and split: the integer part becomes bit-shifts, and the 16-bit fractional part is fed through a cubic polynomial approximation of 2^frac (pow.cpp:1788–1795). The result is bit-identical on every node — which is the entire point.
Slew guard. A NORMAL_SLEW_GUARD_SHIFTclamps how far a single block's target may move from its parent (pow.cpp:850–857), bounding per-block swings from timestamp games.
Fail-closed. Any invalid parameter — a zero or negative half-life, a bad anchor — returns powLimit, the easiest difficulty, rather than crashing (pow.cpp:1763). The chain degrades safely instead of halting.
What the target gates.The resulting target is compared against the block's matmul_digest (pow.cpp:2601) — so this difficulty directly governs how hard the 512×512 M31 matrix-multiply digest has to be. Network hashrate follows from it: networkhashps = difficulty × 2³² / 90.
Per-block ASERT, 90-second spacing, one-hour half-life, anchored at block 50,000.
If you remember one sentence: BTX difficulty is per-block ASERT (aserti3-2d), 90-second spacing, a one-hour half-life, anchored at block 50,000, gating the MatMul digest. It is not Bitcoin's epoch retarget, and it is not DarkGravityWave.
The practical consequences fall out of that. Difficulty reacts within blocks rather than over a fortnight, so hashrate changes are absorbed quickly. The one-hour half-life means sustained over-target hashrate climbs difficulty about an octave per hour — fast, but smooth. And because the schedule is absolute, the chain corrects drift without ringing. The fixed-point math, slew guard, and fail-closed defaults are what let an exponential live safely inside a consensus rule.
BTX difficulty & ASERT — questions
- Does BTX use Bitcoin's difficulty algorithm?
- No. Bitcoin retargets once every 2,016 blocks by measuring how long the last epoch took and nudging difficulty relative to its previous value. BTX retargets every single block using ASERT (aserti3-2d), which pins difficulty to an absolute schedule anchored at one fixed block rather than nudging from the previous block. The two schemes behave very differently — the relative scheme can ring and oscillate; the absolute one does not accumulate error.
- Does BTX use Dash's DarkGravityWave?
- No — not for MatMul mining. A DarkGravityWaveLegacy function still exists in the source, but it is dead code for the MatMul path. The comments are explicit: "DGW is NOT used for MatMul mining -- ASERT only." Every MatMul block's target comes from the ASERT calculation.
- What does ASERT actually stand for?
- Absolutely Scheduled Exponentially Rising Targets. "Absolutely scheduled" because the ideal block time is fixed against an anchor block, not measured relative to the previous block. "Exponentially rising targets" because the target is computed as a smooth exponential of how far ahead or behind that schedule the chain currently sits.
- What is the half-life and why does it matter?
- The half-life is 3,600 seconds — one hour. It sets the sensitivity of the response. For every hour the chain runs behind its ideal schedule, the target doubles (difficulty halves); for every hour it runs ahead, difficulty doubles. Sustained over-target hashrate therefore pulls difficulty up roughly an octave per hour, which is the ~4× rise operators have observed over a couple of hours of heavy mining.
- How can a blockchain compute 2^x deterministically?
- It can't use real floating-point exponentials — those would diverge between nodes and break consensus. Instead BTX scales the exponent by 2^16, splits it into an integer part handled with bit-shifts and a 16-bit fractional part approximated by a cubic polynomial. The result is identical on every node, which is what consensus requires.
- What does the resulting difficulty actually gate?
- The ASERT target is compared against the block's matmul_digest, so it directly governs how hard the 512×512 M31 matrix-multiply digest must be to make a valid block. Network hashrate is reported as difficulty × 2³² / 90, where 90 is the target spacing in seconds.
This piece walks through BTX's difficulty-adjustment rule as implemented in the chain's source. The items below are primary sources and related pieces from this site.
- reference.cash — ASERT (aserti3-2d) difficulty algorithm specification
- BTX — Mine: MatMul proof-of-work and operator launch kit
- Whyte Consolidated — Proof of Useful Work and the 2-for-1 GPU
- Whyte Consolidated — Block 125,000: BTX closes the MatMul precompute loophole
- Whyte Consolidated — 20× on Apple Silicon: tuning the BTX MatMul GPU miner
- Whyte Consolidated — Bitcoin built the chassis. BTX changed the engine.
For informational purposes only. Not financial, investment, or legal advice. Technical claims reflect the BTX project's released source as cited and may be subject to further iteration; source line numbers refer to a specific revision and can shift between versions. Mining outcomes depend on hardware, difficulty, and market conditions, and are not guaranteed.