diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index 19a0885..9adc9a1 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -86,7 +86,7 @@ func (ethash *Ethash) VerifyHeader(chain consensus.ChainHeaderReader, header *ty
 		return consensus.ErrUnknownAncestor
 	}
 	// Sanity checks passed, do a proper verification
-	return ethash.verifyHeader(chain, header, parent, false, seal, time.Now().Unix())
+	return ethash.verifyHeader(chain, header, parent, false, seal, time.Now().Unix(), chain.GetHeader)
 }
 
 // VerifyHeaders is similar to VerifyHeader, but verifies a batch of headers
@@ -165,7 +165,17 @@ func (ethash *Ethash) verifyHeaderWorker(chain consensus.ChainHeaderReader, head
 	if parent == nil {
 		return consensus.ErrUnknownAncestor
 	}
-	return ethash.verifyHeader(chain, headers[index], parent, false, seals[index], unixNow)
+	lookup := func(hash common.Hash, number uint64) *types.Header {
+		first := headers[0].Number.Uint64()
+		if number >= first && number-first < uint64(index) {
+			candidate := headers[number-first]
+			if candidate.Number.Uint64() == number && candidate.Hash() == hash {
+				return candidate
+			}
+		}
+		return chain.GetHeader(hash, number)
+	}
+	return ethash.verifyHeader(chain, headers[index], parent, false, seals[index], unixNow, lookup)
 }
 
 // VerifyUncles verifies that the given block's uncles conform to the consensus
@@ -224,7 +234,7 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
 		if ancestors[uncle.ParentHash] == nil || uncle.ParentHash == block.ParentHash() {
 			return errDanglingUncle
 		}
-		if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true, time.Now().Unix()); err != nil {
+		if err := ethash.verifyHeader(chain, uncle, ancestors[uncle.ParentHash], true, true, time.Now().Unix(), chain.GetHeader); err != nil {
 			return err
 		}
 	}
@@ -234,7 +244,7 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo
 // verifyHeader checks whether a header conforms to the consensus rules of the
 // stock Ethereum ethash engine.
 // See YP section 4.3.4. "Block Header Validity"
-func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, uncle bool, seal bool, unixNow int64) error {
+func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, parent *types.Header, uncle bool, seal bool, unixNow int64, lookup headerLookup) error {
 	// Ensure that the header's extra-data section is of a reasonable size (32)
 	if uint64(len(header.Extra)) > vars.MaximumExtraDataSize {
 		return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), vars.MaximumExtraDataSize)
@@ -250,7 +260,10 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 		return errOlderBlockTime
 	}
 	// Verify the block's difficulty based on its timestamp and parent's difficulty
-	expected := ethash.CalcDifficulty(chain, header.Time, parent)
+	expected := ethash.difficultyOnBranch(chain, header.Time, parent, lookup)
+	if expected == nil {
+		return consensus.ErrUnknownAncestor
+	}
 	if expected.Cmp(header.Difficulty) != 0 {
 		return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
 	}
@@ -345,7 +358,7 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainHeaderReader, header, pa
 // the difficulty that a new block should have when created at time
 // given the parent block's time and difficulty.
 func (ethash *Ethash) CalcDifficulty(chain consensus.ChainHeaderReader, time uint64, parent *types.Header) *big.Int {
-	return CalcDifficulty(chain.Config(), time, parent)
+	return ethash.difficultyOnBranch(chain, time, parent, chain.GetHeader)
 }
 
 // parent_time_delta is a convenience fn for CalcDifficulty
@@ -609,6 +622,9 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H
 		return consensus.ErrUnknownAncestor
 	}
 	header.Difficulty = ethash.CalcDifficulty(chain, header.Time, parent)
+	if header.Difficulty == nil {
+		return consensus.ErrUnknownAncestor
+	}
 	return nil
 }
 
@@ -624,6 +640,10 @@ func (ethash *Ethash) FinalizeAndAssemble(chain consensus.ChainHeaderReader, hea
 	if len(withdrawals) > 0 {
 		return nil, errors.New("ethash does not support withdrawals")
 	}
+	// Pinch: refuse to assemble a block whose coinbase is below the stake threshold.
+	if err := mutations.PinchStakeCheck(chain.Config(), header, state); err != nil {
+		return nil, err
+	}
 	// Finalize block
 	ethash.Finalize(chain, header, state, txs, uncles, nil)
 
diff --git a/core/state_processor.go b/core/state_processor.go
index f712bbd..346dfb1 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -102,6 +102,10 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	if len(withdrawals) > 0 && !(p.config.IsEnabledByTime(p.config.GetEIP4895TransitionTime, &blockTime) || p.config.IsEnabled(p.config.GetEIP4895Transition, blockNumber)) {
 		return nil, nil, 0, fmt.Errorf("withdrawals before shanghai")
 	}
+	// Pinch: stake-gated mining (no-op on other chains).
+	if err := mutations.PinchStakeCheck(p.config, header, statedb); err != nil {
+		return nil, nil, 0, err
+	}
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
 	p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), withdrawals)
 
diff --git a/eth/tracers/api_parity.go b/eth/tracers/api_parity.go
index 6142abc..d9599b2 100644
--- a/eth/tracers/api_parity.go
+++ b/eth/tracers/api_parity.go
@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/params/mutations"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/holiman/uint256"
 )
 
 // TraceFilterArgs represents the arguments for a call.
@@ -140,6 +141,18 @@ func (api *TraceAPI) traceBlockReward(ctx context.Context, block *types.Block, c
 	chainConfig := api.debugAPI.backend.ChainConfig()
 	minerReward, _ := mutations.GetRewards(chainConfig, block.Header(), block.Uncles())
 
+	// Pinch (PINCH-STAKE-1): the credited reward depends on the coinbase tier;
+	// derive it from the block's final state.
+	if mutations.PinchStakeActive(chainConfig, block.Number()) {
+		statedb, release, err := api.debugAPI.backend.StateAtBlock(ctx, block, defaultTraceReexec, nil, true, false)
+		if err != nil {
+			return nil, err
+		}
+		r, _ := mutations.PinchMinedReward(chainConfig, block.Header(), statedb.GetBalance(block.Coinbase()))
+		release()
+		minerReward = r
+	}
+
 	coinbase := block.Coinbase()
 
 	tr := &ParityTrace{
@@ -161,6 +174,11 @@ func (api *TraceAPI) traceBlockReward(ctx context.Context, block *types.Block, c
 func (api *TraceAPI) traceBlockUncleRewards(ctx context.Context, block *types.Block, config *TraceConfig) ([]*ParityTrace, error) {
 	chainConfig := api.debugAPI.backend.ChainConfig()
 	_, uncleRewards := mutations.GetRewards(chainConfig, block.Header(), block.Uncles())
+	if mutations.PinchStakeActive(chainConfig, block.Number()) {
+		for i := range uncleRewards { // Pinch: no uncle rewards after activation
+			uncleRewards[i] = new(uint256.Int)
+		}
+	}
 
 	results := make([]*ParityTrace, len(uncleRewards))
 	for i, uncle := range block.Uncles() {
diff --git a/go.mod b/go.mod
index abca422..7375ec1 100644
--- a/go.mod
+++ b/go.mod
@@ -182,9 +182,3 @@ require (
 	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
-
-replace github.com/etclabscore/go-openrpc-reflect => github.com/fukuii-project/archive-reference-material v0.0.0-20220829134241-ba5a99fa846d
-
-replace github.com/etclabscore/go-jsonschema-walk => github.com/fukuii-project/archive-reference-material v0.0.0-20200501124244-44dea48ac8a4
-
-replace github.com/yusufpapurcu/wmi => github.com/fukuii-project/archive-reference-material v0.0.0-20240128142943-6c94d732ac31
diff --git a/go.sum b/go.sum
index 638052d..57d679e 100644
--- a/go.sum
+++ b/go.sum
@@ -147,6 +147,10 @@ github.com/edsrzf/mmap-go v1.2.0 h1:hXLYlkbaPzt1SaQk+anYwKSRNhufIDCchSPkUD6dD84=
 github.com/edsrzf/mmap-go v1.2.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q=
 github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A=
 github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s=
+github.com/etclabscore/go-jsonschema-walk v0.0.6 h1:DrNzoKWKd8f8XB5nFGBY00IcjakRE22OTI12k+2LkyY=
+github.com/etclabscore/go-jsonschema-walk v0.0.6/go.mod h1:VdfDY72AFAiUhy0ZXEaWSpveGjMT5JcDIm903NGqFwQ=
+github.com/etclabscore/go-openrpc-reflect v0.0.37 h1:IH0e7JqIvR9OhbbFWi/BHIkXrqbR3Zyia3RJ733eT6c=
+github.com/etclabscore/go-openrpc-reflect v0.0.37/go.mod h1:0404Ky3igAasAOpyj1eESjstTyneBAIk5PgJFbK4s5E=
 github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY=
 github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
 github.com/ethereum/evmc/v7 v7.5.0 h1:vwKcs1DINXqvaymranmlpO64fysJJkirCCJ+kkaPaCs=
@@ -436,6 +440,8 @@ github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBi
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.mongodb.org/mongo-driver v1.17.7 h1:a9w+U3Vt67eYzcfq3k/OAv284/uUUkL0uP75VE5rCOU=
 go.mongodb.org/mongo-driver v1.17.7/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ=
 go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
diff --git a/miner/worker.go b/miner/worker.go
index 6b2804d..1ab117e 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -28,6 +28,7 @@ import (
 	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
 	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
 	"github.com/ethereum/go-ethereum/core"
@@ -531,11 +532,20 @@ func (w *worker) newWorkLoop(recommit time.Duration) {
 			// If sealing is running resubmit a new work cycle periodically to pull in
 			// higher priced transactions. Disable this overhead for pending blocks.
 			if w.isRunning() && (!w.chainConfig.GetConsensusEngineType().IsClique() || w.chainConfig.GetCliquePeriod() > 0) {
+				// PINCH-DIFF-1: while the stall decay is running, the template
+				// has to be rebuilt with a fresh timestamp or the falling
+				// target never reaches the miner. See PinchStallRecommitDue.
+				stalling := ethash.PinchStallRecommitDue(w.chain, w.chain.CurrentHeader(), time.Now().Unix())
 				// Short circuit if no new transaction arrives.
-				if w.newTxs.Load() == 0 {
+				if w.newTxs.Load() == 0 && !stalling {
 					timer.Reset(recommit)
 					continue
 				}
+				if stalling {
+					// Without this the rebuilt template is byte-identical and
+					// nothing moves.
+					timestamp = time.Now().Unix()
+				}
 				commit(true, commitInterruptResubmit)
 			}
 
diff --git a/params/mutations/pinch_test.go b/params/mutations/pinch_test.go
new file mode 100644
index 0000000..dcb914b
--- /dev/null
+++ b/params/mutations/pinch_test.go
@@ -0,0 +1,255 @@
+package mutations
+
+import (
+	"encoding/json"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/params/types/coregeth"
+	"github.com/holiman/uint256"
+)
+
+func pinchTestConfig(t *testing.T, chainID int64) *coregeth.CoreGethChainConfig {
+	t.Helper()
+	raw := `{"networkId":` + big.NewInt(chainID).String() + `,"chainId":` + big.NewInt(chainID).String() + `,
+	 "eip155Block":0,"ethash":{},
+	 "blockReward":{"0x0":"0x2b5e3af16b1880000","0x200b20":"0x15af1d78b58c40000","0x401640":"0xad78ebc5ac620000"}}`
+	c := &coregeth.CoreGethChainConfig{}
+	if err := json.Unmarshal([]byte(raw), c); err != nil {
+		t.Fatalf("config: %v", err)
+	}
+	return c
+}
+
+func pinchState(t *testing.T) *state.StateDB {
+	t.Helper()
+	st, err := state.New(common.Hash{}, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return st
+}
+
+func pinch(n uint64) *uint256.Int { return pinchAmount(n) }
+
+func milli(n uint64) *uint256.Int { // n/1000 PINCH
+	return new(uint256.Int).Mul(uint256.NewInt(n), uint256.NewInt(1_000_000_000_000_000))
+}
+
+func TestPinchThreshold(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	cases := []struct {
+		n   uint64
+		sup *uint256.Int
+		thr *uint256.Int
+	}{
+		{0, pinch(0), pinch(0)},
+		{1, pinch(50), milli(125)},
+		{20_000, pinch(1_000_000), pinch(2_500)},
+		{100_000, pinch(5_000_000), pinch(12_500)},
+		{200_000, pinch(10_000_000), pinch(25_000)},
+		{300_000, pinch(15_000_000), pinch(25_000)},
+		{2_100_000, pinch(104_999_975), pinch(25_000)},
+	}
+	for _, c := range cases {
+		if got := PinchScheduledSupply(cfg, c.n); got.Cmp(c.sup) != 0 {
+			t.Errorf("supply(%d) = %s want %s", c.n, got, c.sup)
+		}
+		if got := PinchStakeThreshold(cfg, new(big.Int).SetUint64(c.n)); got.Cmp(c.thr) != 0 {
+			t.Errorf("threshold(%d) = %s want %s", c.n, got, c.thr)
+		}
+	}
+}
+
+func TestPinchTiers(t *testing.T) {
+	thr := pinch(2_500)
+	cases := []struct {
+		bal      *uint256.Int
+		num, den uint64
+		ok       bool
+	}{
+		{pinch(0), 0, 1, false},
+		{new(uint256.Int).Sub(pinch(2_500), uint256.NewInt(1)), 0, 1, false},
+		{pinch(2_500), 1, 2, true},
+		{pinch(9_999), 1, 2, true},
+		{pinch(10_000), 3, 5, true},
+		{pinch(20_000), 3, 4, true},
+		{pinch(49_999), 3, 4, true},
+		{pinch(50_000), 1, 1, true},
+		{pinch(9_000_000), 1, 1, true},
+	}
+	for i, c := range cases {
+		n, d, ok := PinchStakeTier(thr, c.bal)
+		if n != c.num || d != c.den || ok != c.ok {
+			t.Errorf("case %d: got %d/%d %v want %d/%d %v", i, n, d, ok, c.num, c.den, c.ok)
+		}
+	}
+}
+
+func TestPinchRewardsAndGate(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	fork := PinchStakeForkMainnet // threshold 2,500 PINCH at activation
+	miner := common.HexToAddress("0x1111111111111111111111111111111111111111")
+
+	type tc struct {
+		block   uint64
+		balance *uint256.Int
+		reward  *uint256.Int // credited to miner
+		gateErr bool
+	}
+	cases := []tc{
+		{fork - 1, pinch(0), pinch(50), false},      // before fork: old rules
+		{fork, pinch(0), pinch(0), true},            // below threshold: invalid
+		{fork, pinch(2_499), pinch(0), true},        // just below
+		{fork, pinch(2_500), pinch(25), false},      // 50%
+		{fork, pinch(10_000), pinch(30), false},     // 60%
+		{fork, pinch(20_000), milli(37_500), false}, // 75%
+		{fork, pinch(50_000), pinch(50), false},     // 100%
+		{fork, pinch(2_000_000), pinch(50), false},  // capped at 100%
+		{2_100_000, pinch(24_999), pinch(0), true},  // threshold capped at 25k
+		{2_100_000, pinch(25_000), milli(12_500), false},
+		{2_100_000, pinch(500_000), pinch(25), false}, // halving applies
+	}
+	for i, c := range cases {
+		st := pinchState(t)
+		st.AddBalance(miner, c.balance)
+		h := &types.Header{Number: new(big.Int).SetUint64(c.block), Coinbase: miner}
+		err := PinchStakeCheck(cfg, h, st)
+		if (err != nil) != c.gateErr {
+			t.Errorf("case %d: gate err=%v want %v", i, err, c.gateErr)
+		}
+		AccumulateRewards(cfg, st, h, nil)
+		got := new(uint256.Int).Sub(st.GetBalance(miner), c.balance)
+		if got.Cmp(c.reward) != 0 {
+			t.Errorf("case %d (block %d, bal %s): reward %s want %s", i, c.block, c.balance, got, c.reward)
+		}
+	}
+}
+
+func TestPinchUncles(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	fork := PinchStakeForkMainnet
+	miner := common.HexToAddress("0x1111111111111111111111111111111111111111")
+	richUncle := common.HexToAddress("0x2222222222222222222222222222222222222222")
+	poorUncle := common.HexToAddress("0x3333333333333333333333333333333333333333")
+	st := pinchState(t)
+	st.AddBalance(miner, pinch(500_000))
+	st.AddBalance(richUncle, pinch(100_000))
+	h := &types.Header{Number: new(big.Int).SetUint64(fork + 10), Coinbase: miner}
+	uncles := []*types.Header{
+		{Number: new(big.Int).SetUint64(fork + 9), Coinbase: richUncle},
+		{Number: new(big.Int).SetUint64(fork + 9), Coinbase: poorUncle},
+	}
+	AccumulateRewards(cfg, st, h, uncles)
+	// After activation: no uncle rewards, no nephew bonus.
+	if got := new(uint256.Int).Sub(st.GetBalance(richUncle), pinch(100_000)); !got.IsZero() {
+		t.Errorf("rich uncle reward %s want 0", got)
+	}
+	if got := st.GetBalance(poorUncle); !got.IsZero() {
+		t.Errorf("poor uncle reward %s want 0", got)
+	}
+	if got, want := new(uint256.Int).Sub(st.GetBalance(miner), pinch(500_000)), pinch(50); got.Cmp(want) != 0 {
+		t.Errorf("miner reward %s want %s", got, want)
+	}
+	// Before activation the classic Ethash uncle rewards still apply.
+	st2 := pinchState(t)
+	h2 := &types.Header{Number: new(big.Int).SetUint64(fork - 1), Coinbase: miner}
+	AccumulateRewards(cfg, st2, h2, []*types.Header{{Number: new(big.Int).SetUint64(fork - 2), Coinbase: poorUncle}})
+	if got, want := st2.GetBalance(poorUncle), milli(43_750); got.Cmp(want) != 0 {
+		t.Errorf("pre-fork uncle reward %s want %s", got, want)
+	}
+}
+
+// Per-block issuance after activation never exceeds the scheduled reward,
+// whatever the balances and uncles.
+func TestPinchIssuanceBound(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	fork := PinchStakeForkMainnet
+	bals := []uint64{0, 24_999, 25_000, 100_000, 200_000, 500_000, 10_000_000}
+	addrs := []common.Address{
+		common.HexToAddress("0xa1"), common.HexToAddress("0xa2"), common.HexToAddress("0xa3"),
+	}
+	for _, blk := range []uint64{fork, fork + 1, 2_100_000, 4_200_001} {
+		for _, bm := range bals {
+			for _, bu := range bals {
+				st := pinchState(t)
+				st.AddBalance(addrs[0], pinch(bm))
+				st.AddBalance(addrs[1], pinch(bu))
+				st.AddBalance(addrs[2], pinch(bu))
+				before := new(uint256.Int)
+				for _, a := range addrs {
+					before.Add(before, st.GetBalance(a))
+				}
+				h := &types.Header{Number: new(big.Int).SetUint64(blk), Coinbase: addrs[0]}
+				uncles := []*types.Header{
+					{Number: new(big.Int).SetUint64(blk - 1), Coinbase: addrs[1]},
+					{Number: new(big.Int).SetUint64(blk - 2), Coinbase: addrs[2]},
+				}
+				AccumulateRewards(cfg, st, h, uncles)
+				after := new(uint256.Int)
+				for _, a := range addrs {
+					after.Add(after, st.GetBalance(a))
+				}
+				minted := new(uint256.Int).Sub(after, before)
+				if limit := schedule(blk); minted.Cmp(limit) > 0 {
+					t.Fatalf("block %d miner %d uncles %d: minted %s > schedule %s", blk, bm, bu, minted, limit)
+				}
+			}
+		}
+	}
+}
+
+func schedule(blk uint64) *uint256.Int {
+	return new(uint256.Int).Rsh(pinch(50), uint(blk/2_100_000))
+}
+
+// PinchMinedReward recovers the credited reward from the final balance.
+func TestPinchMinedReward(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	fork := PinchStakeForkMainnet
+	miner := common.HexToAddress("0x1111111111111111111111111111111111111111")
+	pre := []*uint256.Int{
+		pinch(25_000), pinch(99_999), new(uint256.Int).Sub(pinch(100_000), uint256.NewInt(1)),
+		pinch(100_000), pinch(199_990), pinch(200_000), pinch(499_999), pinch(500_000), pinch(7_777_777),
+	}
+	for _, blk := range []uint64{fork, 2_100_000} {
+		for i, b := range pre {
+			st := pinchState(t)
+			st.AddBalance(miner, b)
+			h := &types.Header{Number: new(big.Int).SetUint64(blk), Coinbase: miner}
+			AccumulateRewards(cfg, st, h, nil)
+			want := new(uint256.Int).Sub(st.GetBalance(miner), b)
+			got, ok := PinchMinedReward(cfg, h, st.GetBalance(miner))
+			if !ok || got.Cmp(want) != 0 {
+				t.Errorf("block %d case %d: derived %v (ok=%v) want %s", blk, i, got, ok, want)
+			}
+		}
+	}
+	if _, ok := PinchMinedReward(cfg, &types.Header{Number: new(big.Int).SetUint64(fork - 1)}, pinch(1)); ok {
+		t.Error("derived reward before activation")
+	}
+}
+
+func TestPinchOtherChainsUnaffected(t *testing.T) {
+	cfg := params.ClassicChainConfig
+	miner := common.HexToAddress("0x1111111111111111111111111111111111111111")
+	st := pinchState(t)
+	h := &types.Header{Number: big.NewInt(int64(PinchStakeForkMainnet) + 5), Coinbase: miner}
+	if err := PinchStakeCheck(cfg, h, st); err != nil {
+		t.Fatalf("classic gated: %v", err)
+	}
+	if PinchStakeActive(cfg, h.Number) {
+		t.Fatal("stake active on classic")
+	}
+	if PinchStakeActive(pinchTestConfig(t, 5261647), big.NewInt(int64(PinchStakeForkTestnet)-1)) {
+		t.Fatal("testnet active before fork")
+	}
+	if !PinchStakeActive(pinchTestConfig(t, 5261647), big.NewInt(int64(PinchStakeForkTestnet))) {
+		t.Fatal("testnet inactive at fork")
+	}
+}
diff --git a/params/mutations/rewards.go b/params/mutations/rewards.go
index 9c7eef6..eb1cb35 100644
--- a/params/mutations/rewards.go
+++ b/params/mutations/rewards.go
@@ -65,6 +65,14 @@ func GetRewards(config ctypes.ChainConfigurator, header *types.Header, uncles []
 // reward. The coinbase of each uncle block is also rewarded.
 func AccumulateRewards(config ctypes.ChainConfigurator, state *state.StateDB, header *types.Header, uncles []*types.Header) {
 	minerReward, uncleRewards := GetRewards(config, header, uncles)
+	if PinchStakeActive(config, header.Number) {
+		minerReward, uncleRewards = pinchAdjustRewards(config, state, header, uncles)
+		treasuryReward := pinchTreasuryReward(config, header, minerReward)
+		if !treasuryReward.IsZero() {
+			minerReward.Sub(minerReward, treasuryReward)
+			state.AddBalance(pinchTreasuryAddress, treasuryReward)
+		}
+	}
 	for i, uncle := range uncles {
 		state.AddBalance(uncle.Coinbase, uncleRewards[i])
 	}
diff --git a/consensus/ethash/pinch_fork_test.go b/consensus/ethash/pinch_fork_test.go
new file mode 100644
--- /dev/null
+++ b/consensus/ethash/pinch_fork_test.go
@@ -0,0 +1,128 @@
+package ethash
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params/mutations"
+	"github.com/ethereum/go-ethereum/params/types/coregeth"
+	"github.com/ethereum/go-ethereum/params/types/ctypes"
+)
+
+// A long block interval BEFORE activation must not restart the window.
+//
+// Before the fork there is no stall decay, so a long gap is ordinary EIP-100
+// history and says nothing about present hashpower. Treating it as a restart
+// prices the activation block off a single old block: measured on the testnet
+// at 2.86 G where 12.95 G was correct, i.e. cheap blocks handed out at the
+// exact moment the chain can least afford them.
+func TestPinchLWMAIgnoresPreForkGaps(t *testing.T) {
+	const (
+		fork       = 50
+		difficulty = 12_950_000_000
+	)
+	byHash := map[common.Hash]*types.Header{}
+	var parent *types.Header
+
+	// 60 blocks at target, except block 20 which took 15 minutes — the kind of
+	// gap the live chain produced on 15 November, long before any fork.
+	for i := 1; i <= 60; i++ {
+		interval := uint64(pinchLWMATarget)
+		if i == 20 {
+			interval = 900
+		}
+		h := &types.Header{
+			Number:     big.NewInt(int64(i)),
+			Difficulty: big.NewInt(difficulty),
+		}
+		if parent != nil {
+			h.ParentHash = parent.Hash()
+			h.Time = parent.Time + interval
+		} else {
+			h.Time = 1000
+		}
+		byHash[h.Hash()] = h
+		parent = h
+	}
+	lookup := func(hash common.Hash, _ uint64) *types.Header { return byHash[hash] }
+
+	got := pinchLWMA(parent, lookup, fork)
+	if got == nil {
+		t.Fatal("no difficulty returned")
+	}
+
+	// The pre-fork gap is clamped as an outlier but must not restart the
+	// window, so the result stays near the chain's real difficulty.
+	lo := big.NewInt(difficulty / 2)
+	if got.Cmp(lo) < 0 {
+		t.Fatalf("a pre-fork gap restarted the window: got %v, expected near %d", got, difficulty)
+	}
+
+	// Same chain, but now the gap is at a block after activation: that one is
+	// a genuine decayed block and must restart the window.
+	var post *types.Header
+	byHash2 := map[common.Hash]*types.Header{}
+	for i := 1; i <= 60; i++ {
+		interval := uint64(pinchLWMATarget)
+		if i == 55 { // after fork=50
+			interval = 900
+		}
+		h := &types.Header{
+			Number:     big.NewInt(int64(i)),
+			Difficulty: big.NewInt(difficulty),
+		}
+		if post != nil {
+			h.ParentHash = post.Hash()
+			h.Time = post.Time + interval
+		} else {
+			h.Time = 1000
+		}
+		byHash2[h.Hash()] = h
+		post = h
+	}
+	lookup2 := func(hash common.Hash, _ uint64) *types.Header { return byHash2[hash] }
+
+	gotPost := pinchLWMA(post, lookup2, fork)
+	if gotPost == nil {
+		t.Fatal("no difficulty returned for the post-fork chain")
+	}
+	if gotPost.Cmp(got) >= 0 {
+		t.Fatalf("a post-fork gap failed to restart the window: got %v, pre-fork case gave %v", gotPost, got)
+	}
+}
+
+type releaseChainReader struct {
+	consensus.ChainHeaderReader
+	config ctypes.ChainConfigurator
+}
+
+func (r releaseChainReader) Config() ctypes.ChainConfigurator { return r.config }
+
+func TestPinchLWMAReleaseSchedule(t *testing.T) {
+	for _, c := range []struct {
+		chainID int64
+		height  uint64
+	}{
+		{5261646, mutations.PinchDifficultyForkMainnet}, {5261647, 30},
+	} {
+		chain := releaseChainReader{config: &coregeth.CoreGethChainConfig{ChainID: big.NewInt(c.chainID)}}
+		fork, scheduled := pinchLWMAFork(chain)
+		if scheduled != (c.height != 0) || fork != c.height {
+			t.Fatalf("chain %d scheduled at %d, expected %d", c.chainID, fork, c.height)
+		}
+		if !scheduled {
+			continue
+		}
+		parent := &types.Header{Number: new(big.Int).SetUint64(fork - 2)}
+		if pinchLWMAActive(chain, parent) {
+			t.Fatalf("chain %d enabled before fork at %d", c.chainID, fork)
+		}
+		parent.Number.SetUint64(fork - 1)
+		if !pinchLWMAActive(chain, parent) {
+			t.Fatalf("chain %d inactive at fork %d", c.chainID, fork)
+		}
+	}
+}
diff --git a/consensus/ethash/pinch_lwma.go b/consensus/ethash/pinch_lwma.go
new file mode 100644
--- /dev/null
+++ b/consensus/ethash/pinch_lwma.go
@@ -0,0 +1,199 @@
+// PINCH-DIFF-1 — difficulty retarget and stall recovery.
+//
+// Spec: chain/PINCH_DIFF_SPEC.md in the Pinch repository. Three parts:
+//
+//  1. LWMA over the last pinchLWMAWindow blocks, replacing EIP-100. It reacts
+//     in about a quarter of the window instead of the 130+ blocks EIP-100
+//     needs to absorb a large hashrate change.
+//
+//  2. A stall decay: once a block has been outstanding longer than
+//     pinchStallStart, the difficulty it must meet falls continuously, halving
+//     every pinchHalvingPeriod seconds. Without this the chain cannot recover
+//     on its own, because a retarget only runs when a block is found and a
+//     stall is precisely the absence of one.
+//
+//  3. A window restart at a decayed block. LWMA averages the window, so one
+//     cheap block barely moves it and the next block is priced from pre-stall
+//     history — measured at 216x the block that was actually solved, which
+//     walks the chain straight back into the stall. After a decayed block the
+//     window restarts from it, and difficulty discovery begins again at the
+//     level that was really solved.
+//
+// The decay is part of the difficulty value, not an exception applied to the
+// seal check, so a header records the work actually done and total chain work
+// stays honest.
+package ethash
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params/mutations"
+	"github.com/ethereum/go-ethereum/params/vars"
+)
+
+// Zero leaves the candidate disabled until an agreed activation schedule.
+const (
+	pinchLWMATestnetFork = 30
+
+	pinchLWMAWindow = 60 // blocks
+	pinchLWMATarget = 13 // seconds, target block time
+
+	pinchStallStart    = 120 // seconds before the decay starts
+	pinchHalvingPeriod = 60  // seconds for the decay to halve the difficulty
+)
+
+// pinchHalfTable[i] = round(2^(-i/16) * 65536). Interpolating inside this
+// table approximates 2^-x to within 0.03%, which matters: a piecewise-linear
+// decay has a kink at each halving boundary, and a miner may place its
+// timestamp up to 15s ahead. Across a kink those 15s are worth 1.25x; through
+// this table they are worth 1.19x, the same as true exponential decay, with no
+// discontinuity to aim at.
+var pinchHalfTable = [17]int64{
+	65536, 62757, 60097, 57549, 55109, 52773, 50535, 48393, 46341,
+	44376, 42495, 40693, 38968, 37316, 35734, 34219, 32768,
+}
+
+type headerLookup func(common.Hash, uint64) *types.Header
+
+// pinchLWMAFork returns the activation height for this chain, and whether the
+// rule is scheduled at all.
+func pinchLWMAFork(chain consensus.ChainHeaderReader) (uint64, bool) {
+	id := chain.Config().GetChainID()
+	if id == nil {
+		return 0, false
+	}
+	switch {
+	case id.Cmp(mutations.PinchMainnetChainID) == 0:
+		return mutations.PinchDifficultyForkMainnet, mutations.PinchDifficultyForkMainnet != 0
+	case id.Cmp(mutations.PinchTestnetChainID) == 0:
+		return pinchLWMATestnetFork, pinchLWMATestnetFork != 0
+	default:
+		return 0, false
+	}
+}
+
+func pinchLWMAActive(chain consensus.ChainHeaderReader, parent *types.Header) bool {
+	fork, scheduled := pinchLWMAFork(chain)
+	return scheduled && parent.Number.Uint64()+1 >= fork
+}
+
+// pinchLWMA returns the base difficulty for the block after parent, before any
+// stall decay. It walks back over completed intervals on the branch being
+// verified, stopping early at a decayed block so that the window restarts
+// there. A nil result signals history too incomplete to price the block.
+//
+// fork is the activation height. Only a block at or above it can restart the
+// window: before activation there was no stall decay, so a long interval there
+// is ordinary EIP-100 history and means nothing about present hashpower.
+// Treating one as a restart drops the activation block far below its true
+// difficulty — measured on the testnet at 2.86 G against an expected 12.95 G,
+// which would have handed out cheap blocks at exactly the moment the chain is
+// least able to afford them.
+func pinchLWMA(parent *types.Header, lookup headerLookup, fork uint64) *big.Int {
+	var (
+		weighted    int64
+		weightSum   int64
+		count       int64
+		difficulies = new(big.Int)
+		current     = parent
+	)
+	// Oldest-first weighting is what LWMA asks for, but walking the chain gives
+	// newest-first, so collect the intervals and weight them afterwards.
+	type sample struct {
+		difficulty *big.Int
+		interval   int64
+	}
+	samples := make([]sample, 0, pinchLWMAWindow)
+
+	for i := 0; i < pinchLWMAWindow; i++ {
+		height := current.Number.Uint64()
+		if height == 0 {
+			break // genesis has no interval of its own
+		}
+		previous := lookup(current.ParentHash, height-1)
+		if previous == nil || previous.Time >= current.Time || current.Difficulty.Sign() <= 0 {
+			break
+		}
+		interval := int64(current.Time - previous.Time)
+		// Only a block mined under these rules can have been decayed.
+		decayed := interval > pinchStallStart && height >= fork
+		if interval > 6*pinchLWMATarget {
+			interval = 6 * pinchLWMATarget // outlier clamp
+		}
+		samples = append(samples, sample{new(big.Int).Set(current.Difficulty), interval})
+		if decayed {
+			// This block was solved under the stall decay. Everything older
+			// describes hashpower that is no longer here.
+			break
+		}
+		current = previous
+	}
+	if len(samples) == 0 {
+		return nil
+	}
+	// samples[0] is the newest; weight i runs 1..n from oldest to newest.
+	for i := len(samples) - 1; i >= 0; i-- {
+		weight := int64(len(samples) - i)
+		weighted += weight * samples[i].interval
+		weightSum += weight
+		difficulies.Add(difficulies, samples[i].difficulty)
+		count++
+	}
+	target := weightSum * pinchLWMATarget
+	if floor := target / 100; weighted < floor {
+		weighted = floor // bounds a timestamp-compression attack
+	}
+	difficulty := difficulies.Mul(difficulies, big.NewInt(target))
+	difficulty.Div(difficulty, big.NewInt(weighted*count))
+	if difficulty.Cmp(vars.MinimumDifficulty) < 0 {
+		difficulty.Set(vars.MinimumDifficulty)
+	}
+	return difficulty
+}
+
+// pinchStallDecay lowers base once a block has been outstanding longer than
+// pinchStallStart, halving every pinchHalvingPeriod seconds. Integer only.
+func pinchStallDecay(base *big.Int, elapsed int64) *big.Int {
+	if base == nil || elapsed <= pinchStallStart {
+		return base
+	}
+	over := elapsed - pinchStallStart
+	units := over * 1024 / pinchHalvingPeriod // 1024 units == one halving
+	steps := units / 1024
+	if steps >= 256 {
+		return new(big.Int).Set(vars.MinimumDifficulty)
+	}
+	frac := units % 1024
+	i := frac / 64
+	r := frac % 64
+	mul := pinchHalfTable[i] + (pinchHalfTable[i+1]-pinchHalfTable[i])*r/64
+
+	out := new(big.Int).Rsh(base, uint(steps))
+	out.Mul(out, big.NewInt(mul))
+	out.Rsh(out, 16) // divide by 65536
+	if out.Cmp(vars.MinimumDifficulty) < 0 {
+		out.Set(vars.MinimumDifficulty)
+	}
+	return out
+}
+
+func (ethash *Ethash) difficultyOnBranch(chain consensus.ChainHeaderReader, time uint64, parent *types.Header, lookup headerLookup) *big.Int {
+	fork, scheduled := pinchLWMAFork(chain)
+	if !scheduled || parent.Number.Uint64()+1 < fork {
+		return CalcDifficulty(chain.Config(), time, parent)
+	}
+	base := pinchLWMA(parent, lookup, fork)
+	if base == nil {
+		// Not enough history on this branch to price the block with LWMA. Fall
+		// back rather than reject: this happens only in the first blocks of a
+		// chain, and rejecting there would stop it before it starts.
+		base = CalcDifficulty(chain.Config(), time, parent)
+	}
+	if time <= parent.Time {
+		return base
+	}
+	return pinchStallDecay(base, int64(time-parent.Time))
+}
diff --git a/consensus/ethash/pinch_lwma_test.go b/consensus/ethash/pinch_lwma_test.go
new file mode 100644
--- /dev/null
+++ b/consensus/ethash/pinch_lwma_test.go
@@ -0,0 +1,188 @@
+package ethash
+
+import (
+	"math"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params/vars"
+)
+
+// chainOf builds a fake branch, newest last, and a lookup over it.
+func chainOf(difficulty *big.Int, interval uint64, n int) (*types.Header, headerLookup) {
+	headers := make([]*types.Header, n)
+	byHash := map[common.Hash]*types.Header{}
+	for i := 0; i < n; i++ {
+		h := &types.Header{
+			Number:     big.NewInt(int64(i + 1)),
+			Time:       1000 + uint64(i+1)*interval,
+			Difficulty: new(big.Int).Set(difficulty),
+		}
+		if i > 0 {
+			h.ParentHash = headers[i-1].Hash()
+		}
+		headers[i] = h
+		byHash[h.Hash()] = h
+	}
+	lookup := func(hash common.Hash, _ uint64) *types.Header { return byHash[hash] }
+	return headers[n-1], lookup
+}
+
+// A chain running exactly at target must hold its difficulty steady.
+func TestPinchLWMASteadyState(t *testing.T) {
+	d := big.NewInt(17_400_000_000)
+	parent, lookup := chainOf(d, pinchLWMATarget, pinchLWMAWindow+2)
+	got := pinchLWMA(parent, lookup, 0)
+	if got == nil {
+		t.Fatal("no difficulty returned for a complete window")
+	}
+	ratio := new(big.Float).Quo(new(big.Float).SetInt(got), new(big.Float).SetInt(d))
+	f, _ := ratio.Float64()
+	if math.Abs(f-1) > 0.02 {
+		t.Fatalf("steady chain moved difficulty by %.1f%% (got %v, want ~%v)", (f-1)*100, got, d)
+	}
+}
+
+// The case that broke the first draft of the spec: 59 blocks of pre-crash
+// history plus one decayed block must NOT price the next block from the old
+// window. The window has to restart at the decayed block.
+func TestPinchLWMARestartsAtDecayedBlock(t *testing.T) {
+	const pre = 17_400_000_000
+	parent, lookup := chainOf(big.NewInt(pre), pinchLWMATarget, pinchLWMAWindow)
+
+	// Append a decayed block: solved after 600s at a much lower difficulty.
+	decayed := &types.Header{
+		Number:     new(big.Int).Add(parent.Number, big.NewInt(1)),
+		ParentHash: parent.Hash(),
+		Time:       parent.Time + 600,
+		Difficulty: big.NewInt(67_968_750),
+	}
+	inner := lookup
+	lookup2 := func(hash common.Hash, n uint64) *types.Header {
+		if hash == decayed.ParentHash {
+			return parent
+		}
+		return inner(hash, n)
+	}
+
+	got := pinchLWMA(decayed, lookup2, 0)
+	if got == nil {
+		t.Fatal("no difficulty returned")
+	}
+	// Window restarted: one sample, interval clamped to 6T, so D*T/78 = D/6.
+	want := new(big.Int).Div(decayed.Difficulty, big.NewInt(6))
+	diff := new(big.Int).Sub(got, want)
+	diff.Abs(diff)
+	if diff.Cmp(big.NewInt(1_000_000)) > 0 {
+		t.Fatalf("window did not restart: got %v, want about %v", got, want)
+	}
+	// And specifically: it must not come back anywhere near the pre-crash level.
+	if got.Cmp(big.NewInt(pre/100)) > 0 {
+		t.Fatalf("difficulty sprang back toward pre-stall level: %v", got)
+	}
+}
+
+// The decay must reach a level any machine can solve, and do so continuously.
+func TestPinchStallDecay(t *testing.T) {
+	base := big.NewInt(17_400_000_000)
+
+	if got := pinchStallDecay(base, pinchStallStart); got.Cmp(base) != 0 {
+		t.Fatalf("decay applied before the stall threshold: %v", got)
+	}
+	for _, tc := range []struct {
+		elapsed int64
+		want    float64 // expected fraction of base
+	}{
+		{180, 0.5},
+		{240, 0.25},
+		{420, 1.0 / 32},
+		{600, 1.0 / 256},
+	} {
+		got := pinchStallDecay(base, tc.elapsed)
+		want := new(big.Float).Mul(new(big.Float).SetInt(base), big.NewFloat(tc.want))
+		gotF, _ := new(big.Float).SetInt(got).Float64()
+		wantF, _ := want.Float64()
+		if math.Abs(gotF-wantF)/wantF > 0.01 {
+			t.Fatalf("decay at %ds: got %.0f, want %.0f", tc.elapsed, gotF, wantF)
+		}
+	}
+	// Monotonic, and never below the floor.
+	prev := pinchStallDecay(base, pinchStallStart+1)
+	for e := int64(pinchStallStart + 2); e < 4000; e++ {
+		cur := pinchStallDecay(base, e)
+		if cur.Cmp(prev) > 0 {
+			t.Fatalf("decay rose between %ds and %ds", e-1, e)
+		}
+		if cur.Cmp(vars.MinimumDifficulty) < 0 {
+			t.Fatalf("decay fell below MinimumDifficulty at %ds: %v", e, cur)
+		}
+		prev = cur
+	}
+}
+
+// A miner may place its timestamp up to 15s ahead. That must not be worth much.
+func TestPinchStallDecayTimestampGaming(t *testing.T) {
+	base := big.NewInt(17_400_000_000)
+	worst := 1.0
+	for e := int64(pinchStallStart + 1); e < 1200; e++ {
+		honest, _ := new(big.Float).SetInt(pinchStallDecay(base, e)).Float64()
+		cheat, _ := new(big.Float).SetInt(pinchStallDecay(base, e+15)).Float64()
+		if cheat > 0 {
+			if adv := honest / cheat; adv > worst {
+				worst = adv
+			}
+		}
+	}
+	if worst > 1.21 {
+		t.Fatalf("15s of timestamp manipulation is worth %.3fx; the table should hold it near 1.19x", worst)
+	}
+}
+
+// Recovery end to end: 1.34 GH/s leaves, 2 MH/s remains. The spec requires the
+// first 15 blocks inside 20 minutes.
+func TestPinchRecoveryWithinFifteenBlocks(t *testing.T) {
+	const hashrate = 2e6
+	parent, lookup := chainOf(big.NewInt(17_400_000_000), pinchLWMATarget, pinchLWMAWindow)
+	headers := map[common.Hash]*types.Header{}
+	outer := lookup
+	look := func(hash common.Hash, n uint64) *types.Header {
+		if h, ok := headers[hash]; ok {
+			return h
+		}
+		return outer(hash, n)
+	}
+
+	var clock int64
+	for i := 0; i < 15; i++ {
+		base := pinchLWMA(parent, look, 0)
+		if base == nil {
+			t.Fatal("no base difficulty")
+		}
+		// Find when this miner solves the decaying target.
+		var elapsed int64
+		for elapsed = 1; elapsed < 86400; elapsed++ {
+			d := pinchStallDecay(base, elapsed)
+			df, _ := new(big.Float).SetInt(d).Float64()
+			if float64(elapsed) >= df/hashrate {
+				break
+			}
+		}
+		solved := pinchStallDecay(base, elapsed)
+		clock += elapsed
+		next := &types.Header{
+			Number:     new(big.Int).Add(parent.Number, big.NewInt(1)),
+			ParentHash: parent.Hash(),
+			Time:       parent.Time + uint64(elapsed),
+			Difficulty: solved,
+		}
+		headers[next.Hash()] = next
+		headers[parent.Hash()] = parent
+		parent = next
+	}
+	if clock > 20*60 {
+		t.Fatalf("recovery took %.1f minutes; the spec allows 20", float64(clock)/60)
+	}
+	t.Logf("15 blocks in %.1f minutes, final difficulty %v", float64(clock)/60, parent.Difficulty)
+}
diff --git a/consensus/ethash/pinch_replay_test.go b/consensus/ethash/pinch_replay_test.go
new file mode 100644
--- /dev/null
+++ b/consensus/ethash/pinch_replay_test.go
@@ -0,0 +1,180 @@
+package ethash
+
+import (
+	"encoding/json"
+	"math/big"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params/types/coregeth"
+	"github.com/ethereum/go-ethereum/params/types/ctypes"
+)
+
+// PINCH-DIFF-1 acceptance criterion 4: pre-activation history is byte-identical.
+//
+// Replays every real mainnet header through the modified difficulty code and
+// requires the recorded difficulty back, exactly. Run against a header dump
+// produced by chain/export-headers.cjs:
+//
+//	PINCH_HEADERS=../../../../chain/diff-test/headers.json go test -run Replay ./consensus/ethash/
+//
+// Skipped when the dump is absent, so the suite still runs anywhere.
+
+type replayHeader struct {
+	N int64  `json:"n"`
+	T uint64 `json:"t"`
+	D string `json:"d"`
+	U int    `json:"u"`
+}
+
+var emptyUncleHash = types.EmptyUncleHash
+
+func loadReplayHeaders(t *testing.T) []replayHeader {
+	t.Helper()
+	path := os.Getenv("PINCH_HEADERS")
+	if path == "" {
+		path = "../../../../chain/diff-test/headers.json"
+	}
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Skipf("no mainnet header dump at %s; run chain/export-headers.cjs to produce one", path)
+	}
+	var hs []replayHeader
+	if err := json.Unmarshal(raw, &hs); err != nil {
+		t.Fatalf("header dump unreadable: %v", err)
+	}
+	if len(hs) < 2 {
+		t.Fatalf("header dump has %d entries", len(hs))
+	}
+	return hs
+}
+
+// pinchMainnetConfig reads the real chain/genesis.mainnet.json rather than
+// restating its fields, so this test cannot drift from what the live nodes
+// actually run.
+func pinchMainnetConfig(t *testing.T) ctypes.ChainConfigurator {
+	t.Helper()
+	path := os.Getenv("PINCH_GENESIS")
+	if path == "" {
+		path = "../../../../chain/genesis.mainnet.json"
+	}
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		t.Skipf("no mainnet genesis at %s", path)
+	}
+	var outer struct {
+		Config *coregeth.CoreGethChainConfig `json:"config"`
+	}
+	if err := json.Unmarshal(raw, &outer); err != nil || outer.Config == nil {
+		t.Fatalf("mainnet genesis config unreadable: %v", err)
+	}
+	if id := outer.Config.GetChainID(); id == nil || id.Int64() != 5261646 {
+		t.Fatalf("genesis is not Pinch mainnet: chain id %v", id)
+	}
+	return outer.Config
+}
+
+func header(h replayHeader) *types.Header {
+	d, ok := new(big.Int).SetString(h.D, 10)
+	if !ok {
+		panic("bad difficulty " + h.D)
+	}
+	out := &types.Header{
+		Number:     big.NewInt(h.N),
+		Time:       h.T,
+		Difficulty: d,
+		UncleHash:  emptyUncleHash,
+	}
+	if h.U != 0 {
+		// Any non-empty value: the Byzantium rule only tests inequality
+		// against the empty-uncles hash.
+		out.UncleHash = common.HexToHash("0x01")
+	}
+	return out
+}
+
+// Every header the live chain produced must come back out of the new code
+// unchanged. One mismatch is a chain split.
+func TestPinchMainnetReplayUnchanged(t *testing.T) {
+	hs := loadReplayHeaders(t)
+	config := pinchMainnetConfig(t)
+
+	var checked int
+	for i := 1; i < len(hs); i++ {
+		parent := header(hs[i-1])
+		want := header(hs[i]).Difficulty
+		got := CalcDifficulty(config, hs[i].T, parent)
+		if got.Cmp(want) != 0 {
+			t.Fatalf("block %d: difficulty changed: got %v, chain has %v (parent %d, interval %ds, parent uncles %d)",
+				hs[i].N, got, want, hs[i-1].N, int64(hs[i].T)-int64(hs[i-1].T), hs[i-1].U)
+		}
+		checked++
+	}
+	t.Logf("%d headers replayed unchanged, head %d", checked, hs[len(hs)-1].N)
+}
+
+// Check the actual scheduled difficulty path for all historical blocks.
+func TestPinchReplayUnchangedWithForkScheduled(t *testing.T) {
+	hs := loadReplayHeaders(t)
+	chain := releaseChainReader{config: pinchMainnetConfig(t)}
+	fork, scheduled := pinchLWMAFork(chain)
+	head := uint64(hs[len(hs)-1].N)
+	if !scheduled {
+		t.Skip("mainnet fork disabled in this build")
+	}
+	if head >= fork {
+		t.Fatalf("fixture head %d must be before scheduled fork %d", head, fork)
+	}
+	engine := new(Ethash)
+	lookup := func(common.Hash, uint64) *types.Header {
+		t.Fatal("pre-fork difficulty attempted an LWMA lookup")
+		return nil
+	}
+	for i := 1; i < len(hs); i++ {
+		parent := header(hs[i-1])
+		want := header(hs[i]).Difficulty
+		got := engine.difficultyOnBranch(chain, hs[i].T, parent, lookup)
+		if got.Cmp(want) != 0 {
+			t.Fatalf("block %d repriced by a scheduled fork: got %v, chain has %v", hs[i].N, got, want)
+		}
+	}
+	t.Logf("fork scheduled at %d: all %d historical headers unchanged through head %d", fork, len(hs)-1, head)
+}
+
+// A pre-fork gap must not restart the window for the activation block itself.
+// Uses real history: take the last 60 blocks, pretend the fork activates at the
+// head, and confirm the result is priced off the window rather than off one
+// block. The guard is what makes this hold; without it the testnet produced
+// 2.86 G where 12.95 G was correct.
+func TestPinchActivationBlockUsesRealHistory(t *testing.T) {
+	hs := loadReplayHeaders(t)
+	if len(hs) < pinchLWMAWindow+2 {
+		t.Skip("not enough history")
+	}
+	byHash := map[common.Hash]*types.Header{}
+	var parent *types.Header
+	for i := len(hs) - pinchLWMAWindow - 1; i < len(hs); i++ {
+		h := header(hs[i])
+		if parent != nil {
+			h.ParentHash = parent.Hash()
+		}
+		byHash[h.Hash()] = h
+		parent = h
+	}
+	lookup := func(hash common.Hash, _ uint64) *types.Header { return byHash[hash] }
+
+	fork := parent.Number.Uint64() // activate at the head
+	got := pinchLWMA(parent, lookup, fork)
+	if got == nil {
+		t.Fatal("no difficulty for the activation block")
+	}
+	// Must land within a factor of 2 of what the chain is actually running at.
+	lo := new(big.Int).Div(parent.Difficulty, big.NewInt(2))
+	hi := new(big.Int).Mul(parent.Difficulty, big.NewInt(2))
+	if got.Cmp(lo) < 0 || got.Cmp(hi) > 0 {
+		t.Fatalf("activation block mispriced: got %v, chain is at %v", got, parent.Difficulty)
+	}
+	t.Logf("activation at %d priced %v against a running %v", fork, got, parent.Difficulty)
+}
diff --git a/consensus/ethash/pinch_stall.go b/consensus/ethash/pinch_stall.go
new file mode 100644
--- /dev/null
+++ b/consensus/ethash/pinch_stall.go
@@ -0,0 +1,29 @@
+package ethash
+
+import (
+	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// PinchStallRecommitDue reports whether the miner should rebuild its sealing
+// template even though no new transaction has arrived.
+//
+// The stall decay in PINCH-DIFF-1 is a function of the gap between a block's
+// timestamp and its parent's, so it only reaches a miner if the template is
+// rebuilt with a fresh timestamp. The sealing loop normally refuses to do that
+// on an empty mempool, and refreshes its timestamp only on a new head — which
+// never arrives during a stall, because a stall is the absence of one. Left
+// alone, eth_getWork would serve the same target forever and the decay would
+// be invisible to the only party that could act on it.
+//
+// Pinch's mempool is empty almost all of the time, so this is the ordinary
+// case here rather than an edge case.
+func PinchStallRecommitDue(chain consensus.ChainHeaderReader, parent *types.Header, now int64) bool {
+	if chain == nil || parent == nil {
+		return false
+	}
+	if !pinchLWMAActive(chain, parent) {
+		return false
+	}
+	return now-int64(parent.Time) > pinchStallStart
+}
diff --git a/params/mutations/pinch.go b/params/mutations/pinch.go
new file mode 100644
--- /dev/null
+++ b/params/mutations/pinch.go
@@ -0,0 +1,240 @@
+// Pinch stake-gated mining (PINCH-STAKE-1, revision 2).
+//
+// From the activation block onwards, on the Pinch networks only:
+//
+//  1. Threshold T(n) = min(25,000 PINCH, 0.25% of the scheduled supply
+//     mined up to block n). It starts near 2,500 PINCH at activation on
+//     mainnet and reaches 25,000 PINCH once 10,000,000 PINCH have been
+//     scheduled (around block 200,000). It depends only on the block number.
+//  2. A block is valid only if its coinbase holds at least T(n)
+//     (balance after the block's transactions, before block rewards).
+//  3. The block reward is the scheduled reward (50 PINCH, halving every
+//     2,100,000 blocks) multiplied by a tier fraction:
+//     >= 20·T -> 100%
+//     >=  8·T ->  75%
+//     >=  4·T ->  60%
+//     >=    T ->  50%
+//     The fraction never exceeds 100%. The unpaid part is never minted.
+//  4. Uncle rewards and the nephew bonus are not paid after activation, so a
+//     block never mints more than the scheduled reward. (Uncles are still
+//     valid and still count for difficulty.)
+//
+// All balances are read before any reward of the block is credited.
+package mutations
+
+import (
+	"errors"
+	"math/big"
+	"sort"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params/types/ctypes"
+	"github.com/holiman/uint256"
+)
+
+// PinchDifficultyForkMainnet gates the mainnet difficulty and treasury rules together.
+const PinchDifficultyForkMainnet uint64 = 81735
+
+const pinchTreasuryDivisor = 500 // 0.2% of the actual block reward
+
+var pinchTreasuryAddress = common.HexToAddress("0x12Ae6677e2b9ac4E469507B318Da01ff9E5Ec7Ec")
+
+var (
+	PinchMainnetChainID = big.NewInt(5261646)
+	PinchTestnetChainID = big.NewInt(5261647)
+
+	// Activation blocks. The testnet (retired public testnet / local tests)
+	// activates almost immediately so the rule can be exercised quickly.
+	PinchStakeForkMainnet uint64 = 20000
+	PinchStakeForkTestnet uint64 = 30
+
+	ErrPinchStakeTooLow = errors.New("pinch: coinbase balance below the PINCH mining threshold")
+)
+
+func pinchAmount(whole uint64) *uint256.Int {
+	return new(uint256.Int).Mul(uint256.NewInt(whole), uint256.NewInt(1_000_000_000_000_000_000))
+}
+
+// pinchTier: balance must be at least mult × threshold for num/den of the reward.
+type pinchTier struct {
+	mult     uint64
+	num, den uint64
+}
+
+// Ordered from highest to lowest.
+var pinchTiers = []pinchTier{
+	{20, 1, 1},
+	{8, 3, 4},
+	{4, 3, 5},
+	{1, 1, 2},
+}
+
+// PinchStakeCap is the highest value the mining threshold can reach.
+var PinchStakeCap = pinchAmount(25_000)
+
+// Threshold = scheduled supply × 25 / 10000 (0.25%), capped at PinchStakeCap.
+const (
+	pinchThresholdNum = 25
+	pinchThresholdDen = 10_000
+)
+
+// PinchScheduledSupply returns the sum of scheduled block rewards for blocks
+// 1..n (uncle rewards excluded), from the chain's block reward schedule.
+func PinchScheduledSupply(config ctypes.ChainConfigurator, n uint64) *uint256.Int {
+	total := new(uint256.Int)
+	if n == 0 {
+		return total
+	}
+	sched := config.GetEthashBlockRewardSchedule()
+	if len(sched) == 0 {
+		r := ctypes.EthashBlockReward(config, new(big.Int).SetUint64(n))
+		return total.Mul(r, uint256.NewInt(n))
+	}
+	keys := make([]uint64, 0, len(sched))
+	for k := range sched {
+		keys = append(keys, k)
+	}
+	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
+	for i, from := range keys {
+		if from > n {
+			break
+		}
+		lo := from
+		if lo < 1 {
+			lo = 1
+		}
+		hi := n
+		if i+1 < len(keys) && keys[i+1]-1 < hi {
+			hi = keys[i+1] - 1
+		}
+		if hi < lo {
+			continue
+		}
+		cnt := uint256.NewInt(hi - lo + 1)
+		total.Add(total, new(uint256.Int).Mul(sched[from], cnt))
+	}
+	return total
+}
+
+// PinchStakeThreshold returns the mining threshold T(n) for block n.
+func PinchStakeThreshold(config ctypes.ChainConfigurator, n *big.Int) *uint256.Int {
+	t := PinchScheduledSupply(config, n.Uint64())
+	t.Mul(t, uint256.NewInt(pinchThresholdNum))
+	t.Div(t, uint256.NewInt(pinchThresholdDen))
+	if t.Cmp(PinchStakeCap) > 0 {
+		t.Set(PinchStakeCap)
+	}
+	return t
+}
+
+func pinchForkBlock(config ctypes.ChainConfigurator) (uint64, bool) {
+	id := config.GetChainID()
+	if id == nil {
+		return 0, false
+	}
+	switch {
+	case id.Cmp(PinchMainnetChainID) == 0:
+		return PinchStakeForkMainnet, true
+	case id.Cmp(PinchTestnetChainID) == 0:
+		return PinchStakeForkTestnet, true
+	}
+	return 0, false
+}
+
+// PinchStakeActive reports whether the stake rule applies at block number n.
+func PinchStakeActive(config ctypes.ChainConfigurator, n *big.Int) bool {
+	fork, ok := pinchForkBlock(config)
+	if !ok || n == nil {
+		return false
+	}
+	return n.Cmp(new(big.Int).SetUint64(fork)) >= 0
+}
+
+// PinchStakeTier returns the reward fraction num/den for a balance at
+// threshold t. ok is false when the balance is below the threshold.
+func PinchStakeTier(t, balance *uint256.Int) (num, den uint64, ok bool) {
+	for _, tr := range pinchTiers {
+		if balance.Cmp(new(uint256.Int).Mul(t, uint256.NewInt(tr.mult))) >= 0 {
+			return tr.num, tr.den, true
+		}
+	}
+	return 0, 1, false
+}
+
+// PinchStakeCheck returns an error if the block's coinbase does not meet the
+// mining threshold. It must be called after the block's transactions have
+// been applied and before rewards are credited.
+func PinchStakeCheck(config ctypes.ChainConfigurator, header *types.Header, st *state.StateDB) error {
+	if !PinchStakeActive(config, header.Number) {
+		return nil
+	}
+	t := PinchStakeThreshold(config, header.Number)
+	if _, _, ok := PinchStakeTier(t, st.GetBalance(header.Coinbase)); !ok {
+		return ErrPinchStakeTooLow
+	}
+	return nil
+}
+
+func pinchScale(v *uint256.Int, num, den uint64, ok bool) *uint256.Int {
+	if !ok {
+		return new(uint256.Int)
+	}
+	r := new(uint256.Int).Mul(v, uint256.NewInt(num))
+	return r.Div(r, uint256.NewInt(den))
+}
+
+// pinchAdjustRewards replaces the Ethash rewards after activation:
+// the miner receives scheduled reward × tier fraction (no nephew bonus) and
+// uncles receive nothing. Per-block issuance therefore never exceeds the
+// scheduled reward, which keeps total supply within the 210M schedule
+// (plus the uncle rewards already minted before activation).
+func pinchAdjustRewards(config ctypes.ChainConfigurator, st *state.StateDB, header *types.Header, uncles []*types.Header) (*uint256.Int, []*uint256.Int) {
+	num, den, ok := PinchStakeTier(PinchStakeThreshold(config, header.Number), st.GetBalance(header.Coinbase))
+	miner := pinchScale(ctypes.EthashBlockReward(config, header.Number), num, den, ok)
+	out := make([]*uint256.Int, len(uncles))
+	for i := range out {
+		out[i] = new(uint256.Int)
+	}
+	return miner, out
+}
+
+// pinchTreasuryReward takes the treasury share from the actual tiered reward.
+func pinchTreasuryReward(config ctypes.ChainConfigurator, header *types.Header, gross *uint256.Int) *uint256.Int {
+	id := config.GetChainID()
+	share := new(uint256.Int)
+	if PinchDifficultyForkMainnet != 0 && header.Number.IsUint64() &&
+		header.Number.Uint64() >= PinchDifficultyForkMainnet &&
+		id != nil && id.Cmp(PinchMainnetChainID) == 0 {
+		share.Div(gross, uint256.NewInt(pinchTreasuryDivisor))
+	}
+	return share
+}
+
+// PinchMinedReward returns the block reward that was actually credited to the
+// coinbase of a post-activation block, given the coinbase balance in the
+// block's final state. Because rewards grow with the tier and tiers are
+// ordered, exactly one tier is consistent with the final balance.
+// ok is false when the rule is not active for this block.
+func PinchMinedReward(config ctypes.ChainConfigurator, header *types.Header, postBalance *uint256.Int) (*uint256.Int, bool) {
+	if !PinchStakeActive(config, header.Number) {
+		return nil, false
+	}
+	base := ctypes.EthashBlockReward(config, header.Number)
+	thr := PinchStakeThreshold(config, header.Number)
+	for _, t := range pinchTiers {
+		r := pinchScale(base, t.num, t.den, true)
+		if header.Coinbase != pinchTreasuryAddress {
+			r.Sub(r, pinchTreasuryReward(config, header, r))
+		}
+		if postBalance.Cmp(r) < 0 {
+			continue
+		}
+		pre := new(uint256.Int).Sub(postBalance, r)
+		if n, d, ok := PinchStakeTier(thr, pre); ok && n == t.num && d == t.den {
+			return r, true
+		}
+	}
+	return new(uint256.Int), true
+}
diff --git a/params/mutations/pinch_extra_test.go b/params/mutations/pinch_extra_test.go
new file mode 100644
--- /dev/null
+++ b/params/mutations/pinch_extra_test.go
@@ -0,0 +1,138 @@
+package mutations
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/holiman/uint256"
+	"math/big"
+	"testing"
+)
+
+// Fork policy suppresses both uncle issuance and the nephew bonus.
+func TestPinchExtraUncleIssuanceSuppressed(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	st := pinchState(t)
+	m := common.HexToAddress("0x101")
+	u := common.HexToAddress("0x102")
+	st.AddBalance(m, pinch(500000))
+	st.AddBalance(u, pinch(500000))
+	n := PinchStakeForkMainnet + 10
+	h := &types.Header{Number: new(big.Int).SetUint64(n), Coinbase: m}
+	uncles := []*types.Header{{Number: new(big.Int).SetUint64(n - 1), Coinbase: u}}
+	AccumulateRewards(cfg, st, h, uncles)
+	minted := new(uint256.Int).Add(new(uint256.Int).Sub(st.GetBalance(m), pinch(500000)), new(uint256.Int).Sub(st.GetBalance(u), pinch(500000)))
+	want := pinch(50)
+	if minted.Cmp(want) != 0 {
+		t.Fatalf("minted %s want %s", minted, want)
+	}
+	if st.GetBalance(u).Cmp(pinch(500000)) != 0 {
+		t.Fatal("uncle rewarded")
+	}
+}
+
+func TestPinchExtraPostTransactionThresholdAndRevert(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	st := pinchState(t)
+	m := common.HexToAddress("0x103")
+	h := &types.Header{Number: new(big.Int).SetUint64(PinchStakeForkMainnet), Coinbase: m}
+	st.AddBalance(m, new(uint256.Int).Sub(PinchStakeThreshold(cfg, h.Number), uint256.NewInt(1)))
+	if PinchStakeCheck(cfg, h, st) == nil {
+		t.Fatal("below threshold accepted")
+	}
+	snap := st.Snapshot()
+	st.AddBalance(m, uint256.NewInt(1))
+	if err := PinchStakeCheck(cfg, h, st); err != nil {
+		t.Fatal(err)
+	}
+	st.RevertToSnapshot(snap)
+	if PinchStakeCheck(cfg, h, st) == nil {
+		t.Fatal("reverted threshold accepted")
+	}
+}
+
+func TestPinchExtraSharedCoinbaseUsesPreRewardTier(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	st := pinchState(t)
+	m := common.HexToAddress("0x104")
+	initial := new(uint256.Int).Sub(new(uint256.Int).Mul(PinchStakeThreshold(cfg, new(big.Int).SetUint64(PinchStakeForkMainnet+10)), uint256.NewInt(4)), uint256.NewInt(1))
+	st.AddBalance(m, initial)
+	n := PinchStakeForkMainnet + 10
+	h := &types.Header{Number: new(big.Int).SetUint64(n), Coinbase: m}
+	us := []*types.Header{{Number: new(big.Int).SetUint64(n - 1), Coinbase: m}, {Number: new(big.Int).SetUint64(n - 2), Coinbase: m}}
+	want := pinch(25) // No uncle/nephew rewards with shared coinbase.
+	AccumulateRewards(cfg, st, h, us)
+	if got := new(uint256.Int).Sub(st.GetBalance(m), initial); got.Cmp(want) != 0 {
+		t.Fatalf("reward affected its own tier: %s want %s", got, want)
+	}
+}
+
+func TestPinchExtraExactTierEdgesAndRounding(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	for _, height := range []uint64{20000, 100000, 200000, 2100000} {
+		thr := PinchStakeThreshold(cfg, new(big.Int).SetUint64(height))
+		for _, mult := range []uint64{1, 4, 8, 20} {
+			b := new(uint256.Int).Mul(thr, uint256.NewInt(mult))
+			before := new(uint256.Int).Sub(b, uint256.NewInt(1))
+			an, ad, ao := PinchStakeTier(thr, b)
+			bn, bd, bo := PinchStakeTier(thr, before)
+			if ao == bo && an*bd == bn*ad {
+				t.Fatalf("missing edge height %d mult %d", height, mult)
+			}
+			got := pinchScale(uint256.NewInt(7), an, ad, ao)
+			want := uint256.NewInt(7 * an / ad)
+			if got.Cmp(want) != 0 {
+				t.Fatal("rounding")
+			}
+			if b.Cmp(new(uint256.Int).Mul(thr, uint256.NewInt(mult))) != 0 {
+				t.Fatal("mutated balance")
+			}
+		}
+	}
+}
+
+func TestPinchExtraRewardDerivationAtAllBoundaries(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	for _, height := range []uint64{PinchStakeForkMainnet, 100000, 200000, 2100000, 4200000} {
+		h := &types.Header{Number: new(big.Int).SetUint64(height)}
+		thr := PinchStakeThreshold(cfg, h.Number)
+		for _, amount := range []uint64{1, 4, 8, 20} {
+			for _, offset := range []uint64{0, 1} {
+				pre := new(uint256.Int).Sub(new(uint256.Int).Mul(thr, uint256.NewInt(amount)), uint256.NewInt(offset))
+				n, d, ok := PinchStakeTier(thr, pre)
+				if !ok {
+					continue
+				}
+				reward := pinchScale(schedule(height), n, d, ok)
+				post := new(uint256.Int).Add(pre, reward)
+				got, active := PinchMinedReward(cfg, h, post)
+				if !active || got.Cmp(reward) != 0 {
+					t.Fatalf("derivation height %d balance %s got %s want %s", height, pre, got, reward)
+				}
+			}
+		}
+	}
+}
+
+func TestPinchExtraScheduledSupplyBoundaries(t *testing.T) {
+	cfg := pinchTestConfig(t, 5261646)
+	cases := []struct {
+		height            uint64
+		supply, threshold string
+	}{
+		{0, "0", "0"}, {1, "50000000000000000000", "125000000000000000"},
+		{20000, "1000000000000000000000000", "2500000000000000000000"},
+		{100000, "5000000000000000000000000", "12500000000000000000000"},
+		{199999, "9999950000000000000000000", "24999875000000000000000"},
+		{200000, "10000000000000000000000000", "25000000000000000000000"},
+		{2100000, "104999975000000000000000000", "25000000000000000000000"},
+		{4200000, "157499962500000000000000000", "25000000000000000000000"},
+	}
+	for _, c := range cases {
+		if got := PinchScheduledSupply(cfg, c.height).Dec(); got != c.supply {
+			t.Fatalf("supply %d got %s want %s", c.height, got, c.supply)
+		}
+		if got := PinchStakeThreshold(cfg, new(big.Int).SetUint64(c.height)).Dec(); got != c.threshold {
+			t.Fatalf("threshold %d got %s want %s", c.height, got, c.threshold)
+		}
+	}
+}
diff --git a/params/mutations/pinch_treasury_test.go b/params/mutations/pinch_treasury_test.go
new file mode 100644
--- /dev/null
+++ b/params/mutations/pinch_treasury_test.go
@@ -0,0 +1,59 @@
+package mutations
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/holiman/uint256"
+)
+
+func TestPinchTreasuryRewardAccounting(t *testing.T) {
+	fork := PinchDifficultyForkMainnet
+	if fork == 0 {
+		t.Skip("mainnet fork disabled in this build")
+	}
+	miner := common.HexToAddress("0x1000")
+	for _, c := range []struct {
+		name  string
+		chain int64
+		block uint64
+		tier  uint64
+		to    common.Address
+		gross uint64
+		share uint64
+	}{
+		{"before", 5261646, fork - 1, 20, miner, 50000, 0},
+		{"at full", 5261646, fork, 20, miner, 50000, 100},
+		{"75 percent", 5261646, fork, 8, miner, 37500, 75},
+		{"60 percent", 5261646, fork, 4, miner, 30000, 60},
+		{"50 percent", 5261646, fork, 1, miner, 25000, 50},
+		{"after halving", 5261646, 2_100_000, 20, miner, 25000, 50},
+		{"treasury mines", 5261646, fork, 20, pinchTreasuryAddress, 50000, 100},
+		{"testnet unchanged", 5261647, fork, 20, miner, 50000, 0},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			cfg := pinchTestConfig(t, c.chain)
+			header := &types.Header{Number: new(big.Int).SetUint64(c.block), Coinbase: c.to}
+			pre := new(uint256.Int).Mul(PinchStakeThreshold(cfg, header.Number), uint256.NewInt(c.tier))
+			st := pinchState(t)
+			// One extra wei keeps final balance reconstruction away from a tier boundary.
+			pre.Add(pre, uint256.NewInt(1))
+			st.AddBalance(c.to, pre)
+			AccumulateRewards(cfg, st, header, nil)
+			minerWant := c.gross - c.share
+			if c.to == pinchTreasuryAddress {
+				minerWant = c.gross
+			} else if got := st.GetBalance(pinchTreasuryAddress); got.Cmp(milli(c.share)) != 0 {
+				t.Fatalf("treasury %s, want %s", got, milli(c.share))
+			}
+			if net := new(uint256.Int).Sub(st.GetBalance(c.to), pre); net.Cmp(milli(minerWant)) != 0 {
+				t.Fatalf("credited miner reward %s, want %s", net, milli(minerWant))
+			}
+			if net, ok := PinchMinedReward(cfg, header, st.GetBalance(c.to)); !ok || net.Cmp(milli(minerWant)) != 0 {
+				t.Fatalf("derived miner reward %s, want %s", net, milli(minerWant))
+			}
+		})
+	}
+}
diff --git a/params/version.go b/params/version.go
--- a/params/version.go
+++ b/params/version.go
@@ -24,7 +24,7 @@
 	VersionMajor = 1        // Major version component of the current release
 	VersionMinor = 13       // Minor version component of the current release
 	VersionPatch = 0        // Patch version component of the current release
-	VersionMeta  = "stable" // Version metadata to append to the version string
+	VersionMeta  = "pinch.6" // Version metadata to append to the version string
 	// VersionName is the devp2p FAMILY name and must not carry the version.
 	// node.Config.NodeName() appends "/v<VersionWithMeta>" itself, and network
 	// censuses group peers by this first segment -- etcnodes.org counts 512 of
