difficulty

Documentation

Index

• func BigToCompact(n *big.Int) uint32
• func CalcWork(bits uint32) *big.Int
• func CompactToBig(compact uint32) *big.Int
• func CompactToBigWithDestination(compact uint32, destination *big.Int)
• func GetHashrateString(target *big.Int, TargetTimePerBlock time.Duration) string

Functions

func BigToCompact

func BigToCompact(n *big.Int) uint32

BigToCompact converts a whole number N to a compact representation using an unsigned 32-bit number. The compact representation only provides 23 bits of precision, so values larger than (2^23 - 1) only encode the most significant digits of the number. See CompactToBig for details.

func CalcWork

func CalcWork(bits uint32) *big.Int

CalcWork calculates a work value from difficulty bits. Anuma increases the difficulty for generating a block by decreasing the value which the generated hash must be less than. This difficulty target is stored in each block header using a compact representation as described in the documentation for CompactToBig. Since a lower target difficulty value equates to higher actual difficulty, the work value which will be accumulated must be the inverse of the difficulty. Also, in order to avoid potential division by zero and really small floating point numbers, the result adds 1 to the denominator and multiplies the numerator by 2^256.

func CompactToBig

func CompactToBig(compact uint32) *big.Int

CompactToBig converts a compact representation of a whole number N to an unsigned 32-bit number. The representation is similar to IEEE754 floating point numbers.

Like IEEE754 floating point, there are three basic components: the sign, the exponent, and the mantissa. They are broken out as follows:

• the most significant 8 bits represent the unsigned base 256 exponent

• bit 23 (the 24th bit) represents the sign bit

• the least significant 23 bits represent the mantissa

  ------------------------------------------------- | Exponent | Sign | Mantissa | ------------------------------------------------- | 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] | -------------------------------------------------

The formula to calculate N is:

N = (-1^sign) * mantissa * 256^(exponent-3)

func CompactToBigWithDestination

func CompactToBigWithDestination(compact uint32, destination *big.Int)

CompactToBigWithDestination is a version of CompactToBig that takes a destination parameter. This is useful for saving memory, as then the destination big.Int can be reused. See CompactToBig for further details.

func GetHashrateString

func GetHashrateString(target *big.Int, TargetTimePerBlock time.Duration) string

GetHashrateString returns the expected hashrate of the network on a certain difficulty target.