Bitcoin Cash Protocol Upgrades

# HF-20171113

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

## Summary

When the median time past 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

## Difficulty Adjustment Algorithm Description

To calculate the difficulty of a given block (Bn + 1), with an `MTP-11` greater than or equal to the unix timestamp `1510600000`, perform the following steps:

NOTE: Implementations must use integer arithmetic only

1. Let Bn be the Nth block in a Bitcoin Cash Blockchain.
2. Let Blast be chosen from [Bn - 2, Bn - 1, Bn].
3. Let Bfirst be chosen from [Bn - 146, Bn - 145, Bn - 144].
4. Let the Timespan (`TS`) be equal to the difference in UNIX timestamps (in seconds) between Blast and Bfirst within the range `[72 * 600, 288 * 600]`. Values outside should be treated as their respective limit.
5. Let the Work Performed (`W`) be equal to the difference in chainwork between Blast and Bfirst.
6. Let the Projected Work (`PW`) be equal to `(W * 600) / TS`.
7. Let Target (`T`) be equal to the (2256 - PW) / PW. This is calculated by taking the two’s complement of `PW` (`-PW`) and dividing it by `PW` (`-PW / PW`).
8. The target difficulty for block Bn + 1 is then equal to the lesser of `T` and `0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF`

## Test Case

1. Create a genesis block with the following data:
``````    nHeight = 0;
nTime = 1269211443;
nBits = 0x1C0FFFFF;
``````
1. Add `2049` blocks at `600` second intervals with the same `nBits`.
2. Add another `10` blocks at `600` second intervals. `nBits` should remain constant.
3. Add a block `6000` seconds in the future with `nBits` remaining the same.
4. Add a block `-4800` seconds from the previous block. `nBits` should remain the constant.
5. Add `20` blocks at `600` second intervals. `nBits` should remain constant.
6. Add a block at a `550` second interval. `nBits` should remain constant.
7. Add `10` blocks at `550` second intervals. The target difficulty should slowly decrease.
8. `nBits` should be `0x1C0FE7B1`.
9. Add `20` more blocks at `10` second intervals. The target difficulty decrease quickly.
10. `nBits` should be `0x1C0DB19F`.
11. Add `1` block at an interval of `6000` seconds.
12. `nBits` should be `0x1C0D9222`.
13. Produce `93` blocks at `6000` second intervals. The target difficulty should increase.
14. `nBits` should be `0x1C2F13B9`.
15. Add one block at `6000` seconds.
16. `nBits` should be `0x1C2EE9BF`.
17. Add `192` blocks at `6000` second intervals. The target difficulty should increase.
18. `nBits` should be `0x1D00FFFF`.
19. Add `5` blocks at `6000` second intervals. Target should stay constant at the maximum value.

## FAQ

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

## Footnotes

1. The `MTP-11` of a block is defined as the median timestamp of the last `11` blocks prior to, and including, a specific block.
2. 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>`.

1. 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