Difference between revisions of "Difficulty"

 
(19 intermediate revisions by 5 users not shown)
Line 3: Line 3:
 
=== What is difficulty? ===
 
=== What is difficulty? ===
  
Difficulty is a measure of how difficult it is to find a hash below a given [[target]]. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the [[Genesis block|Genesis Block]]?"
+
Difficulty is a measure of how difficult it is to find a hash below a given [[target]]. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the [[Genesis block|Genesis Block]]?". It has a close relationship with target but is not the same thing. Rather it has an inverse relationship where a higher difficulty implies a lower target value.
  
 
The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target.
 
The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target.
Mining pools also have a pool-specific share difficulty setting a lower limit for shares.
+
[[Mining pool]]s also have a pool-specific share difficulty setting a lower limit for shares.
  
 
=== How often does the network difficulty change? ===
 
=== How often does the network difficulty change? ===
Line 15: Line 15:
 
difficulty = difficulty_1_target / current_target  
 
difficulty = difficulty_1_target / current_target  
  
''target is a 256 bit number''
+
''target is a 256 bit [[big number]]''
  
 
''difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.''
 
''difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.''
Line 21: Line 21:
 
difficulty_1_target can be different for various ways to measure difficulty.
 
difficulty_1_target can be different for various ways to measure difficulty.
 
Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff").
 
Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff").
The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (this is known as "bdiff").
+
The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (known as "bdiff").
  
 
===How is difficulty stored in blocks?===
 
===How is difficulty stored in blocks?===
  
Each block stores a packed representation in its block header (called [[Block hashing algorithm|Bits]]) for its actual hexadecimal [[target]]. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:
+
Each block stores a packed representation in its block header (called [[Block hashing algorithm|Bits]]) for its actual [[hexadecimal]] [[target]]. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:
 
  0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000
 
  0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000
  
Line 47: Line 47:
 
  = 16307.669773817162 (pdiff)
 
  = 16307.669773817162 (pdiff)
  
Here's a fast way to calculate bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:
+
Here's a fast way to calculate Bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:
  
 
<source lang="cpp">
 
<source lang="cpp">
Line 102: Line 102:
 
There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).
 
There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).
  
The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately it never will, so we're ok.)
+
The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately, it never will, so we're ok.)
  
=== Can the network difficulty go down? ===
+
In the case of Bitcoin (BSV) and Bitcoin Cash (BCH), the network's difficulty can rise by a maximum of 100% of the current difficulty in a single adjustment.
Yes it can. See discussion in [[target]].
+
 
 +
In the original implementation, still used by Bitcoin Core (BTC), the difficulty can rise by a maximum of 400% of the current difficulty in a single adjustment.
 +
 
 +
=== Can the network difficulty decrease? ===
 +
Yes it can. See discussion in [[target]].
 +
 
 +
In the case of Bitcoin (BSV) and Bitcoin Cash (BCH), the network's difficulty can adjust downwards by up to 50% of the current difficulty in a single adjustment.
 +
 
 +
In the original implementation, still used by Bitcoin Core (BTC), the network's difficulty can adjust downwards by up to 75% of the current difficulty in a single adjustment.
  
 
=== What is the minimum difficulty? ===
 
=== What is the minimum difficulty? ===
Line 111: Line 119:
  
 
=== What network hash rate results in a given difficulty? ===
 
=== What network hash rate results in a given difficulty? ===
The difficulty is adjusted every 2016 blocks based on the [[Block_timestamp|time]] it took to find the previous 2016 blocks.  At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find.  If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced.  If they took less than two weeks, the difficulty is increased.  The change in difficulty is in proportion to the amount of time over or under two weeks the previous 2016 blocks took to find.
+
The difficulty is adjusted every 2016 blocks based on the [[Block_timestamp|time]] it took to find the previous 2016 blocks.  At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find.  If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced.  If they took less than two weeks, the difficulty is increased.  The change in difficulty, is in proportion to the amount of time over or under two weeks, the previous 2016 blocks took to find.
  
 
To find a block, the hash must be less than the target.  The hash is effectively a random number between 0 and 2**256-1.  The offset for difficulty 1 is
 
To find a block, the hash must be less than the target.  The hash is effectively a random number between 0 and 2**256-1.  The offset for difficulty 1 is
Line 125: Line 133:
 
The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds.  That means the hash rate of the network was
 
The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds.  That means the hash rate of the network was
 
  D * 2**48 / 0xffff / 600
 
  D * 2**48 / 0xffff / 600
over the previous 2016 blocks.  Can be further simplified to
+
over the previous 2016 blocks.  This can be further simplified to
 
  D * 2**32 / 600
 
  D * 2**32 / 600
 
without much loss of accuracy.
 
without much loss of accuracy.
Line 131: Line 139:
 
At difficulty 1, that is around 7 Mhashes per second.
 
At difficulty 1, that is around 7 Mhashes per second.
  
At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found the average network hash rate was
+
At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found, the average network hash rate was
 
  22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.
 
  22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.
 
=== How soon might I expect to generate a block? ===
 
The average time to find a block can be approximated by calculating:
 
time = difficulty * 2**32 / hashrate
 
where difficulty is the current difficulty, hashrate is the number of hashes your miner calculates per second, and time is the average in seconds between the blocks you find.
 
 
For example, using Python we calculate the average time to generate a block using a 1Ghash/s mining rig when the difficulty is 20000:
 
$ python -c "print 20000 * 2**32 / 10**9 / 60 / 60.0"
 
23.85
 
and find that it takes just under 24 hours on average.
 
 
Remember - any one grinding of the hash stands the same chance of "winning" as any other.  The numbers game is how many attempts hardware can make per second.
 
  
 
==Related Links==
 
==Related Links==
Line 150: Line 146:
 
* See also: [[Target]]
 
* See also: [[Target]]
  
[[Category:Technical]]
+
==Attribution==
[[Category:Vocabulary]]
+
This content is based on content sourced from https://en.bitcoin.it/wiki/Difficulty under [https://creativecommons.org/licenses/by/3.0/ Creative Commons Attribution 3.0]. Although it may have been extensively revised and updated, we acknowledge the original authors.

Latest revision as of 00:47, 26 April 2022

See also: Target

What is difficulty?

Difficulty is a measure of how difficult it is to find a hash below a given target. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the Genesis Block?". It has a close relationship with target but is not the same thing. Rather it has an inverse relationship where a higher difficulty implies a lower target value.

The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target. Mining pools also have a pool-specific share difficulty setting a lower limit for shares.

How often does the network difficulty change?

See target.

What is the formula for difficulty?

difficulty = difficulty_1_target / current_target

target is a 256 bit big number

difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.

difficulty_1_target can be different for various ways to measure difficulty. Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff"). The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (known as "bdiff").

How is difficulty stored in blocks?

Each block stores a packed representation in its block header (called Bits) for its actual hexadecimal target. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:

0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

Note that the 0x0404cb value is a signed value in this format. The largest legal value for this field is 0x7fffff. To make a larger value you must shift it down one full byte. Also 0x008000 is the smallest positive valid value.

How is difficulty calculated? What is the difference between bdiff and pdiff?

The highest possible target (difficulty 1) is defined as 0x1d00ffff, which gives us a hex target of

0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

It should be noted that pooled mining often uses non-truncated targets, which puts "pool difficulty 1" at

0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

So the difficulty at 0x1b0404cb is therefore:

0x00000000FFFF0000000000000000000000000000000000000000000000000000 /
0x00000000000404CB000000000000000000000000000000000000000000000000 
= 16307.420938523983 (bdiff)

And:

0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF /
0x00000000000404CB000000000000000000000000000000000000000000000000 
= 16307.669773817162 (pdiff)

Here's a fast way to calculate Bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:

<source lang="cpp">

  1. include <iostream>
  2. include <cmath>

inline float fast_log(float val) {

  int * const exp_ptr = reinterpret_cast <int *>(&val);
  int x = *exp_ptr;
  const int log_2 = ((x >> 23) & 255) - 128;
  x &= ~(255 << 23);
  x += 127 << 23;
  *exp_ptr = x;
  val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
  return ((val + log_2) * 0.69314718f);

}

float difficulty(unsigned int bits) {

   static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
   return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));

}

int main() {

   std::cout << difficulty(0x1b0404cb) << std::endl;
   return 0;

} </source>

To see the math to go from the normal difficulty calculations (which require large big ints bigger than the space in any normal integer) to the calculation above, here's some python:

<source lang="python"> import decimal, math l = math.log e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))) print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))) print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3))) print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3))) print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2) print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2) print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8) </source>

What is the current difficulty?

Current difficulty

What is the maximum difficulty?

There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).

The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately, it never will, so we're ok.)

In the case of Bitcoin (BSV) and Bitcoin Cash (BCH), the network's difficulty can rise by a maximum of 100% of the current difficulty in a single adjustment.

In the original implementation, still used by Bitcoin Core (BTC), the difficulty can rise by a maximum of 400% of the current difficulty in a single adjustment.

Can the network difficulty decrease?

Yes it can. See discussion in target.

In the case of Bitcoin (BSV) and Bitcoin Cash (BCH), the network's difficulty can adjust downwards by up to 50% of the current difficulty in a single adjustment.

In the original implementation, still used by Bitcoin Core (BTC), the network's difficulty can adjust downwards by up to 75% of the current difficulty in a single adjustment.

What is the minimum difficulty?

The minimum difficulty, when the target is at the maximum allowed value, is 1. This is the difficulty of the Genesis block.

What network hash rate results in a given difficulty?

The difficulty is adjusted every 2016 blocks based on the time it took to find the previous 2016 blocks. At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find. If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced. If they took less than two weeks, the difficulty is increased. The change in difficulty, is in proportion to the amount of time over or under two weeks, the previous 2016 blocks took to find.

To find a block, the hash must be less than the target. The hash is effectively a random number between 0 and 2**256-1. The offset for difficulty 1 is

0xffff * 2**208

and for difficulty D is

(0xffff * 2**208)/D

The expected number of hashes we need to calculate to find a block with difficulty D is therefore

D * 2**256 / (0xffff * 2**208)

or just

D * 2**48 / 0xffff

The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds. That means the hash rate of the network was

D * 2**48 / 0xffff / 600

over the previous 2016 blocks. This can be further simplified to

D * 2**32 / 600

without much loss of accuracy.

At difficulty 1, that is around 7 Mhashes per second.

At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found, the average network hash rate was

22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.

Related Links

Attribution

This content is based on content sourced from https://en.bitcoin.it/wiki/Difficulty under Creative Commons Attribution 3.0. Although it may have been extensively revised and updated, we acknowledge the original authors.