BIP-110: The Temporary Softfork

1. What BIP-110 Does

BIP-110 proposes a one-year temporary consensus softfork restricting arbitrary data embedding in Bitcoin transactions. It targets the "inscriptions" phenomenon by capping data field sizes across seven transaction components.

The Seven Consensus Rules

2. The Game Theory

BIP-110's activation mechanism is a textbook example of asymmetric incentive design. The mechanism creates a situation where signaling is always rational and holding out is increasingly costly.

The Asymmetric Payoff

This creates a weakly dominant strategy: signaling is never worse than not signaling, and sometimes strictly better. In game theory terms, this is the most powerful incentive alignment you can create. The rational play is identical regardless of what you believe others will do.

The Three Phases

3. The Payoff Matrix

Here's the miner's decision matrix during the mandatory signaling period, assuming a clear majority has already signaled:

4. The Tipping Point Dynamic

The mechanism creates a ratchet effect that accelerates adoption once momentum builds.

Why the 55% Threshold Matters

5. The Last-Minute Flip

A common mistake is reading current signaling data as a prediction of outcome. It isn't. Miners have zero incentive to signal early, and every incentive to wait.

How the Flip Happens

6. The Remaining Barriers (Not Financial)

The financial argument against signaling is essentially zero. Inscription fees are a rounding error compared to the 3.125 BTC subsidy. The remaining barriers to activation are coordination and politics, not economics.

7. The Economic Majority Feedback Loop

The game theory doesn't stop at miners. Exchanges, custodians, and payment processors face the same asymmetric payoff, and their rational response creates a feedback loop that amplifies the activation pressure.

The Exchange Decision Matrix

The cost of upgrading is trivial: swap a node binary, restart. The cost of being on the wrong side of a chain split is existential for an exchange. This is the same dominant strategy miners face: prepare or risk ruin.

Who Needs to Prepare?

In every case, the cost of preparation is trivial and the cost of being wrong is severe. The rational move is always to prepare.

8. Code Audit: What the Code Actually Does

We performed a comprehensive audit of the BIP-110 implementation across 70 commits, 80+ modified files in the dathonohm/bitcoin repository (branch 29.3.knots20260210+UASF-BIP110), comparing against the Bitcoin Knots 29.x-knots base.

Consensus Rule Implementation

The core consensus changes are clean and well-structured. A new SCRIPT_VERIFY_REDUCED_DATA flag (bit 21) gates all rule enforcement in the script interpreter:

// src/script/interpreter.h
+ SCRIPT_VERIFY_REDUCED_DATA = (1U << 21),

// Combined mandatory flags when deployment is active:
+ static constexpr unsigned int REDUCED_DATA_MANDATORY_VERIFY_FLAGS{0
+     | SCRIPT_VERIFY_REDUCED_DATA
+     | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
+     | SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION
+     | SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS
+ };

The Grandfather Clause

Per-input flag overriding exempts pre-activation UTXOs. This is the most complex part of the implementation:

// src/validation.cpp - ConnectBlock()
+ for (size_t j = 0; j < tx.vin.size(); j++) {
+     prevheights[j] = view.AccessCoin(tx.vin[j].prevout).nHeight;
+     if (prevheights[j] < reduced_data_start_height) {
+         flags_per_input.resize(tx.vin.size(), flags);
+         flags_per_input[j] = flags & ~REDUCED_DATA_MANDATORY_VERIFY_FLAGS;
+     }
+ }

+ if (cacheFullScriptStore && (!pvChecks) && flags_per_input.empty()) {
      // Only cache if flags are uniform across all inputs

Activation Mechanism

The modified BIP9 state machine adds three new parameters to BIP9Deployment:

The state machine is modified so there is no FAILED state:

// src/versionbits.cpp
 if (count >= nThreshold) {
     stateNext = ThresholdState::LOCKED_IN;
+ } else if (max_activation_height < INT_MAX &&
+            pindexPrev->nHeight + 1 >= max_activation_height - nPeriod) {
+     stateNext = ThresholdState::LOCKED_IN;  // Force lock-in
 } else if (pindexPrev->GetMedianTimePast() >= nTimeTimeout) {
     stateNext = ThresholdState::FAILED;
 }

Combined with NO_TIMEOUT, the deployment always activates, either via organic 55% signaling or forced lock-in at max_activation_height.

9. Policy-Level Restrictions in the Current Release

The consensus rules auto-expire after ~52,416 blocks. Five categories of policy and wallet changes in the current release are relaxed in a post-expiry software update, as implied by any temporary deployment.

What the Current Release Enforces (Until Updated)

Network-Level Changes

10. Test Coverage Gaps

The test suite includes 4 dedicated test files with ~2,000+ lines of Python functional tests. The coverage is broad but has precision issues at critical boundaries.

11. Conclusion

The Game Theory Is Sound

BIP-110's activation mechanism is well-designed for its stated goal. The asymmetric payoff (zero cost to signal, real cost if caught not-signaling), the first-mover advantage, the ratchet effect through mandatory signaling, and subsidy dominance over inscription fees create a powerful coordination mechanism where the financial case against signaling effectively doesn't exist. A 55% threshold is aggressive by Bitcoin standards, but defensible for a temporary measure.

The Code Is Competent

The consensus rule implementation is clean, well-tested (with caveats), and follows Bitcoin Core conventions. The cache-poisoning fix in v0.3 shows active bug-hunting. The per-input flag override for the grandfather clause is the most complex piece and it's implemented correctly. The consensus auto-expiry mechanism works as designed.

The Temporary Framing Is Accurate

The Bottom Line

BIP-110 is a well-engineered mechanism for its stated purpose. The game theory strongly favors activation. The code is sound. The consensus rules are genuinely temporary. The remaining barriers are coordination and politics, not economics, and the mechanism is specifically designed to compress coordination into a narrow window at the deadline. Current signaling numbers are not predictive of outcome. The action, if it comes, will come fast.