login

HF-20171113

Summary

Difficulty Adjustment Algorithm Description

Test Case

References

FAQ

Footnotes

hf-20171113 (in protocol:forks)

```
layout: specification
title: November 13th Bitcoin Cash Hardfork Technical Details
category: spec
date: 2017-11-07
activation: 1510600000
version: 1.3
```

When the median time past^{[1]} of the most recent `11`

blocks (`MTP - 11`

) is greater than or equal to UNIX timestamp `1510600000`

Bitcoin Cash will execute a hardfork according to this specification.

Starting from the next block these three consensus rules changes will take effect:

- Enforcement of LOW_S signatures (BIP 0146)
- Enforcement of NULLFAIL (BIP 0146)
- A replacement for the emergency difficulty adjustment.

The algorithm for the new difficulty adjustment is described below

To calculate the difficulty of a given block (`B`

), with an _{n} + 1`MTP-11`

^{[1]} greater than or equal to the unix timestamp `1510600000`

, perform the following steps:

*NOTE: Implementations must use integer arithmetic only*

- Let
`B`

be the Nth block in a Bitcoin Cash Blockchain._{n} - Let
`B`

be chosen_{last}^{[2]}from`[B`

._{n}- 2, B_{n}- 1, B_{n}] - Let
`B`

be chosen_{first}^{[2]}from`[B`

._{n}- 146, B_{n}- 145, B_{n}- 144] - Let the Timespan (
`TS`

) be equal to the difference in UNIX timestamps (in seconds) between`B`

and_{last}`B`

within the range_{first}`[72 * 600, 288 * 600]`

.

Values outside should be treated as their respective limit. - Let the Work Performed (
`W`

) be equal to the difference in chainwork^{[3]}between B_{last}and B_{first}. - Let the Projected Work (
`PW`

) be equal to`(W * 600) / TS`

. - Let Target (
`T`

) be equal to the`(2`

. This is calculated by taking the two’s complement of^{256}- PW) / PW`PW`

(`-PW`

) and dividing it by`PW`

(`-PW / PW`

). - The target difficulty for block
`B`

is then equal to the lesser of_{n}+ 1`T`

and`0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF`

- Create a genesis block with the following data:

```
nHeight = 0;
nTime = 1269211443;
nBits = 0x1C0FFFFF;
```

- Add
`2049`

blocks at`600`

second intervals with the same`nBits`

. - Add another
`10`

blocks at`600`

second intervals.`nBits`

should remain constant. - Add a block
`6000`

seconds in the future with`nBits`

remaining the same. - Add a block
`-4800`

seconds from the previous block.`nBits`

should remain the constant. - Add
`20`

blocks at`600`

second intervals.`nBits`

should remain constant. - Add a block at a
`550`

second interval.`nBits`

should remain constant. - Add
`10`

blocks at`550`

second intervals. The target difficulty should slowly decrease. `nBits`

should be`0x1C0FE7B1`

.- Add
`20`

more blocks at`10`

second intervals. The target difficulty decrease quickly. `nBits`

should be`0x1C0DB19F`

.- Add
`1`

block at an interval of`6000`

seconds. `nBits`

should be`0x1C0D9222`

.- Produce
`93`

blocks at`6000`

second intervals. The target difficulty should increase. `nBits`

should be`0x1C2F13B9`

.- Add one block at
`6000`

seconds. `nBits`

should be`0x1C2EE9BF`

.- Add
`192`

blocks at`6000`

second intervals. The target difficulty should increase. `nBits`

should be`0x1D00FFFF`

.- Add
`5`

blocks at`6000`

second intervals. Target should stay constant at the maximum value.

Q: Does this imply that if the blocks are timestamped sequentially, the last block has no effect since it will look at the block before that one?

A: Yes

- The
`MTP-11`

of a block is defined as the median timestamp of the last`11`

blocks prior to, and including, a specific block. - A block is chosen via the following mechanism:

Given a list:

`S = [B<sub>n</sub> - 2, B<sub>n</sub> - 1, B<sub>n</sub>]`

a. If timestamp (

`S<sub>0</sub>`

) greater than timestamp (`S<sub>2</sub>`

) then swap`S<sub>0</sub>`

and`S<sub>2</sub>`

.b. If timestamp (

`S<sub>0</sub>`

) greater than timestamp (`S<sub>1</sub>`

) then swap`S<sub>0</sub>`

and`S<sub>1</sub>`

.c. If timestamp (

`S<sub>1</sub>`

) greater than timestamp (`S<sub>2</sub>`

) then swap`S<sub>1</sub>`

and`S<sub>2</sub>`

.d. Return

`S<sub>1</sub>`

.See GetSuitableBlock

- Chainwork for a Block (B) is the sum of block proofs from the genesis block up to and including block
`B`

.

`Block proof`

is defined in chain.cpp