Conservative node policy

A Nakamoto-compatible policy for cleaner block space.

Bitcoin Tolerant is a conservative node policy that discourages excessive arbitrary data in relay and mining, while remaining humble before Nakamoto consensus.

We don't ask whether your data is good or bad. We ask whether it pays the real economic cost of the block space it consumes.

View GitHub Read the Policy Download / Build Support the Project

Strict in relay. Conservative in mining. Tolerant in consensus.

No moral filtering. No hidden subsidy. Honest blockspace pricing.

V2 — Design + Phase 1 core (observe-only)Honest Blockspace Pricing

V2 delivers what the roadmap promised: honest blockspace pricing.

V2 is not a change of direction — it is the specification of the marginal blockspace pricing item already on the roadmap, moved out of Roadmap and into its own body of work.

Status is deliberately narrow: the design document is complete, the pricing core (Phase 1) is implemented and compiles as observe-only, and Phases 2 and 3 are designed but not yet implemented. Nothing here ships as default-on.

A filter says:
“data, never.”
An honest price says:
“data, at today's price.”

Core

Permissive — arbitrary data even receives the witness discount.

Knots

Strict — arbitrary data is treated as spam and filtered.

Tolerant

Neutral — we don't judge your data, we charge what the block space it occupies actually costs.

The Hidden Subsidy

How a fix for signatures became a subsidy for files.

2017 — SegWit

SegWit created the witness area to fix transaction malleability and enable Lightning. A witness byte weighs 1 unit versus 4 for the body — a 75% discount. That discount was designed for signatures, and was also the mechanism that let the network raise capacity as a soft fork without splitting (though the big-blocks camp still separated as Bitcoin Cash).

2021–2023 — Taproot + inscriptions

Taproot plus Ordinals inscriptions discovered that the same witness discount applies to any data stuffed into the witness inside an OP_FALSE OP_IF … OP_ENDIF envelope. Storing an image suddenly cost one quarter of its real footprint.

Today

A discount intended for signatures now subsidises files that every node keeps forever. Bitcoin Core leaves it on by default (-datacarriercost=0.25).

Banning that data outright is impossible without censorship or another fork war. Removing its discount is a legitimate policy decision.
Tolerant doesn't fight the unwinnable battle of banning. It fights the winnable one of not subsidizing.

The Formula

Four lines. One honest number.

reference_rate   = total_fees(last 6 blocks) / total_vbytes(last 6 blocks)
economic_vbytes  = base_monetary_vbytes + data_vbytes × data_premium
required_fee     = economic_vbytes × reference_rate
as_if_feerate    = actual_fee / economic_vbytes

reference_rate
Reference market rate, averaged over the last 6 blocks (~1 hour).
economic_vbytes
The transaction's real footprint. Monetary vbytes are never multiplied; data vbytes carry the premium.
required_fee
The fee the transaction owes for the block space it actually consumes.
as_if_feerate
The “lie detector”: what a transaction is really paying per real vbyte, discount removed.

Monetary bytes are never multiplied. A pure payment has economic_vbytes == tx_vbytes, so as_if_feerate == normal_feerate. Someone sending money pays not one extra satoshi.

as_if_feerate reveals what is being paid for the real space occupied, not for the discounted space — the discount can no longer hide behind the witness.

Worked Example

A 50 KB image, priced honestly.

Scenario: a 50,000-byte image in the witness, plus ~150 vB of monetary machinery. Reference rate: 10 sat/vB.

Measure	With witness discount	Honest (Tolerant)
Image	50,000 bytes	50,000 bytes
Counted as	12,500 vB	50,000 vB
+ monetary base	150 vB	150 vB
Total space	12,650 vB	50,150 vB
Fee at 10 sat/vB	126,500 sat	501,500 sat

Paying 126,500 sat looks like market rate (10 sat/vB) — but on its true footprint that is only 2.5 sat/vB. The as-if feerate exposes it.

Market	reference_rate	Honest price
Fee spike	66 sat/vB	~3,300,000 sat
Calm	10 sat/vB	~501,500 sat
Drought	1 sat/vB	~50,150 sat

In a drought, the same image costs ~50,000 sat. Tolerant does not exploit quiet markets to punish data. If block space is genuinely cheap, data pays cheap — like everyone else. Overcharging without demand would be as dishonest as subsidizing during a spike. We refuse both.

Why 6 blocks?

One honest number you can argue with.

The reference price is the average of the last 6 blocks (~1 hour).

Short enough to reflect the current market, long enough to smooth out per-block noise.

Why not 1000 blocks (~1 week)?

A week is not a current price. It anchors the reference to the past and subsidizes data precisely during fee spikes — the failure V2 exists to prevent.

Why not 1 block?

A single anomalous block — empty, or padded by a miner with their own transactions — is not a market, and would be cheap to manipulate.

Is it fixed?

It is a visible, configurable constant, never a hidden adaptive algorithm. One honest number you can argue with beats several buried ones you can't.

Non-negotiables

What V2 does not do.

No consensus validation changes.
No BIP-110 enforcement. No SegData. No pruning. No new opcodes.
No chain-selection change — most-work valid chain always wins.
Never rejects externally valid blocks. Local policy is never consensus invalidity.
Market-priced exceptions are never default-on.
Never filters by content meaning — only by economic cost.
Scarcity is never charged where nothing is displaced.
Output count is never priced — payment batching is never penalized.
The externality multiplier is never inferred or auto-tuned.

Concept

What is Bitcoin Tolerant?

Bitcoin Tolerant is an independent policy fork based on Bitcoin Knots. It gives operators stricter local policy tools for relay and mining, without turning local policy preferences into consensus invalidity.

Bitcoin Tolerant does not reject valid most-work Bitcoin blocks merely because they contain data above local policy limits. It separates three layers cleanly.

“Prefer clean blocks in a tie. Follow the most-work valid chain once the tie is broken.”

Three layers

Relay policy
What transactions the node gossips.
Mining policy
What transactions the node includes in its templates.
Consensus validation
Which chains the node considers valid — unchanged.

This separation is the core of the project.

Policy

Four separations, one discipline.

Relay Policy

Reject or avoid relaying excessive arbitrary-data transactions using conservative local policy.

Mining Policy

Exclude oversized arbitrary-data transactions from local block templates.

Consensus Discipline

Do not change consensus validation. Valid blocks remain valid.

Fork Risk Reduction

Prefer clean blocks in equal-work ties, but follow the valid chain with the most accumulated proof-of-work once the tie is broken.

Implementation

Implemented in V1

Bitcoin Tolerant Policy V1 is implemented in the Tolerant branch.

bitcoin.conf

# Enable Tolerant conservative policy profile
-tolerant=1
-tolerantdatacarriersize=83
-tolerantlogpolicy=1
-tolerantminingfilter=1
-toleranttiepreference=1
 
# When -tolerant=1, the resolved profile is:
datacarrier=1
datacarriersize=83
fullcount=1
# No bare datacarrier

Tolerant module

src/node/tolerant.h

src/node/tolerant.cpp

Clean block scoring
Policy helpers
Tolerant-specific logging
Observation tools

Layer

Behavior

Relay

Logging in MemPoolAccept::PreChecks using existing datacarrier policy.

Mining

Defensive filtering in BlockAssembler::TestPackageTransactions.

Consensus

No consensus changes. Valid blocks are still accepted.

Observation

BCLog::TOLERANT with -debug=tolerant. Clean block score is logged in UpdateTip. Equal-work ties are detected but chain selection is not changed in V1.

V2 Implementation

Defaults are off. Everything ships as observe-only.

bitcoin.conf — V2 defaults

# All V2 flags default to off / observe.
-tolerantv2=0
-tolerantpricingmode=observe
-tolerantmarketexceptions=0
-tolerantreferenceblocks=6
-tolerantopportunitycost=average
-tolerantpermanencepremium=1.0
-tolerantexternalitypremium=1.0
-tolerantwitnesspolicy=observe
-toleranttaprootpolicy=observe
-tolerantutxobloatpolicy=observe

New modules

src/node/tolerant_pricing.h

src/node/tolerant_pricing.cpp

With -tolerantv2=0 the node behaves byte-for-byte as today.

Safety

No consensus enforcement by default.

Bitcoin Tolerant V1 does not introduce new consensus rules. It does not enforce BIP-110 as consensus. It does not reject the valid chain with the most accumulated proof-of-work.

Its goal is to make local relay and mining policy stricter while reducing unnecessary chain fracture.

Local policy should not automatically become consensus fracture.

RDTS status

RDTS consensus enforcement remains unsupported and unsafe by default. consensusrules=rdts remains opt-in and should not be presented as the default Tolerant behavior.

# Recommended build -DRDTS_CONSENT=UNSUPPORTED_UNSAFE_NO_ENFORCEMENT

Build

Compile and test locally.

build

git clone https://github.com/HansLove/bitcoin-tolerant.git
cd bitcoin-tolerant
git checkout Tolerant
cmake -B build -DRDTS_CONSENT=UNSUPPORTED_UNSAFE_NO_ENFORCEMENT
cmake --build build

test

build/test/functional/test_runner.py feature_tolerant_policy.py

The functional test feature_tolerant_policy.py has passed.

Philosophy

Tolerance is not weakness.

In Bitcoin, tolerance does not mean accepting everything into your mempool. It means preserving consensus discipline even when local policies differ.

Node operators can be sovereign. Miners can be conservative. The network can still remain coordinated around Nakamoto consensus.

Strict where local. Tolerant where global.

Tolerance is the discipline of not turning every disagreement into a fork.

Strength without aggression
Patience under pressure
Memory and continuity
Tolerance without weakness

Phased rollout

Three phases. Zero touch on consensus.

Phase 1

Observe only

Classify, price, and log. No behavior change.

Core implemented

Phase 2

Mining template only

Exclude underpriced data from local block templates. Relay untouched.

Designed

Phase 3

Relay policy

Optional, only after Phase 2 proves stable over time. Deliberately last.

Designed

No phase touches consensus.

Roadmap

After V2.

gettolerantpricing RPC

Publish the reference price in machine-readable form for tooling and dashboards.

UTXO-bloat analysis

Dust-based only. Output count is never priced; payment batching is never penalized.

Network-sourced reference rate validation

Cross-check the local reference rate against network-observable signals to detect manipulation.

Open source

Open source and auditable.

Bitcoin Tolerant is public and auditable. Developers can review the code, build from source, run tests, and contribute improvements.

GitHub Repository Tolerant Branch Policy Documentation Build Instructions

repo

# Clone and switch to the Tolerant branch
git clone https://github.com/HansLove/bitcoin-tolerant
git checkout Tolerant

Support

Support Bitcoin Tolerant

If you want to support the effort to preserve consensus while keeping node policy sovereign, you can contribute here.

Bitcoin

bc1q2xwae968t339g22x6rldjxv7autklanr46k6j3

USDT / EVM compatible

Ethereum · Polygon · other EVM

0x67c09ba6Da5c72474fcaD9d1E209E126b7605D8B

This EVM address may be used for USDT on Ethereum, Polygon, and several compatible EVM networks. Always verify the network before sending.