Abstract long-exposure light trails — representative imagery of a chain tracking a smooth schedule.
Article · June 22, 2026 · Digital infrastructure

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.

aserti3-2d/retarget every block/90s spacing/one-hour half-life

Whyte Consolidated Research · 2026-06-22· 9 min read

By the numbers · BTX mainnet ASERT parameters
Every block
Retarget cadence
no 2,016-block epochs
90 s
Target spacing
ideal time between blocks
1 hour
Half-life
target doubles per hour off-schedule
50,000
Anchor height
the fixed schedule origin
1 · What it is, and what it is not

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.

What BTX difficulty is
  • 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.
What it is not
  • 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.
2 · The mechanism

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)
TermMeaningValue
time_diffActual seconds elapsed since the anchor blockmeasured
height_diffBlocks mined since the anchormeasured
ideal_deltaHow many seconds should have elapsed90 × (h+1)
target_spacingIdeal time between blocks90 s
half_lifeSensitivity 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).

3 · How it behaves

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.

Diagram · Absolute schedule vs. the relative scheme
ASERT's absolute schedule versus a relative difficulty schemeTwo panels. The top panel shows ASERT: a straight ideal-schedule line from the anchor block, with the actual chain drifting slightly above and below it and being smoothly pulled back, never oscillating. The bottom panel shows a relative scheme: difficulty overshoots and rings around the target line. The takeaway is that absolute anchoring removes accumulated error and ringing.ASERT · ABSOLUTE SCHEDULE · ANCHORED AT BLOCK 50,000ideal · 90s/blockanchordrifts above/below, pulled smoothly back onto scheduleRELATIVE SCHEME · NUDGE FROM PREVIOUS · RINGStarget levelovershoots the level it's trying to find — accumulated errorSame goal — a steady block rate. Anchoring to an absolute schedule is what removes the wobble.
ASERT (top) measures every block against a fixed schedule anchored at block 50,000, so drift is corrected without compounding. A relative scheme (bottom) nudges from the previous difficulty and tends to ring around the level it's chasing. Illustrative — not to scale.
4 · Implementation details worth knowing

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.

5 · The one-line summary

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.

FAQ

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.
Further reading

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.

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.