-
Notifications
You must be signed in to change notification settings - Fork 0
/
difficulty.go
177 lines (162 loc) · 6.02 KB
/
difficulty.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
package ethash
import (
"math/big"
"github.com/holiman/uint256"
"github.com/pecoin/go-fullnode/core/types"
)
const (
// frontierDurationLimit is for Frontier:
// The decision boundary on the blocktime duration used to determine
// whether difficulty should go up or down.
frontierDurationLimit = 13
// minimumDifficulty The minimum that the difficulty may ever be.
minimumDifficulty = 131072
// expDiffPeriod is the exponential difficulty period
expDiffPeriodUint = 100000
// difficultyBoundDivisorBitShift is the bound divisor of the difficulty (2048),
// This constant is the right-shifts to use for the division.
difficultyBoundDivisor = 11
)
// CalcDifficultyFrontierU256 is the difficulty adjustment algorithm. It returns the
// difficulty that a new block should have when created at time given the parent
// block's time and difficulty. The calculation uses the Frontier rules.
func CalcDifficultyFrontierU256(time uint64, parent *types.Header) *big.Int {
/*
Algorithm
block_diff = pdiff + pdiff / 2048 * (1 if time - ptime < 13 else -1) + int(2^((num // 100000) - 2))
Where:
- pdiff = parent.difficulty
- ptime = parent.time
- time = block.timestamp
- num = block.number
*/
pDiff := uint256.NewInt()
pDiff.SetFromBig(parent.Difficulty) // pDiff: pdiff
adjust := pDiff.Clone()
adjust.Rsh(adjust, difficultyBoundDivisor) // adjust: pDiff / 2048
if time-parent.Time < frontierDurationLimit {
pDiff.Add(pDiff, adjust)
} else {
pDiff.Sub(pDiff, adjust)
}
if pDiff.LtUint64(minimumDifficulty) {
pDiff.SetUint64(minimumDifficulty)
}
// 'pdiff' now contains:
// pdiff + pdiff / 2048 * (1 if time - ptime < 13 else -1)
if periodCount := (parent.Number.Uint64() + 1) / expDiffPeriodUint; periodCount > 1 {
// diff = diff + 2^(periodCount - 2)
expDiff := adjust.SetOne()
expDiff.Lsh(expDiff, uint(periodCount-2)) // expdiff: 2 ^ (periodCount -2)
pDiff.Add(pDiff, expDiff)
}
return pDiff.ToBig()
}
// CalcDifficultyHomesteadU256 is the difficulty adjustment algorithm. It returns
// the difficulty that a new block should have when created at time given the
// parent block's time and difficulty. The calculation uses the Homestead rules.
func CalcDifficultyHomesteadU256(time uint64, parent *types.Header) *big.Int {
/*
https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
Algorithm:
block_diff = pdiff + pdiff / 2048 * max(1 - (time - ptime) / 10, -99) + 2 ^ int((num / 100000) - 2))
Our modification, to use unsigned ints:
block_diff = pdiff - pdiff / 2048 * max((time - ptime) / 10 - 1, 99) + 2 ^ int((num / 100000) - 2))
Where:
- pdiff = parent.difficulty
- ptime = parent.time
- time = block.timestamp
- num = block.number
*/
pDiff := uint256.NewInt()
pDiff.SetFromBig(parent.Difficulty) // pDiff: pdiff
adjust := pDiff.Clone()
adjust.Rsh(adjust, difficultyBoundDivisor) // adjust: pDiff / 2048
x := (time - parent.Time) / 10 // (time - ptime) / 10)
var neg = true
if x == 0 {
x = 1
neg = false
} else if x >= 100 {
x = 99
} else {
x = x - 1
}
z := new(uint256.Int).SetUint64(x)
adjust.Mul(adjust, z) // adjust: (pdiff / 2048) * max((time - ptime) / 10 - 1, 99)
if neg {
pDiff.Sub(pDiff, adjust) // pdiff - pdiff / 2048 * max((time - ptime) / 10 - 1, 99)
} else {
pDiff.Add(pDiff, adjust) // pdiff + pdiff / 2048 * max((time - ptime) / 10 - 1, 99)
}
if pDiff.LtUint64(minimumDifficulty) {
pDiff.SetUint64(minimumDifficulty)
}
// for the exponential factor, a.k.a "the bomb"
// diff = diff + 2^(periodCount - 2)
if periodCount := (1 + parent.Number.Uint64()) / expDiffPeriodUint; periodCount > 1 {
expFactor := adjust.Lsh(adjust.SetOne(), uint(periodCount-2))
pDiff.Add(pDiff, expFactor)
}
return pDiff.ToBig()
}
// MakeDifficultyCalculatorU256 creates a difficultyCalculator with the given bomb-delay.
// the difficulty is calculated with Byzantium rules, which differs from Homestead in
// how uncles affect the calculation
func MakeDifficultyCalculatorU256(bombDelay *big.Int) func(time uint64, parent *types.Header) *big.Int {
// Note, the calculations below looks at the parent number, which is 1 below
// the block number. Thus we remove one from the delay given
bombDelayFromParent := bombDelay.Uint64() - 1
return func(time uint64, parent *types.Header) *big.Int {
/*
https://github.com/ethereum/EIPs/issues/100
pDiff = parent.difficulty
BLOCK_DIFF_FACTOR = 9
a = pDiff + (pDiff // BLOCK_DIFF_FACTOR) * adj_factor
b = min(parent.difficulty, MIN_DIFF)
child_diff = max(a,b )
*/
x := (time - parent.Time) / 9 // (block_timestamp - parent_timestamp) // 9
c := uint64(1) // if parent.unclehash == emptyUncleHashHash
if parent.UncleHash != types.EmptyUncleHash {
c = 2
}
xNeg := x >= c
if xNeg {
// x is now _negative_ adjustment factor
x = x - c // - ( (t-p)/p -( 2 or 1) )
} else {
x = c - x // (2 or 1) - (t-p)/9
}
if x > 99 {
x = 99 // max(x, 99)
}
// parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
y := new(uint256.Int)
y.SetFromBig(parent.Difficulty) // y: p_diff
pDiff := y.Clone() // pdiff: p_diff
z := new(uint256.Int).SetUint64(x) //z : +-adj_factor (either pos or negative)
y.Rsh(y, difficultyBoundDivisor) // y: p__diff / 2048
z.Mul(y, z) // z: (p_diff / 2048 ) * (+- adj_factor)
if xNeg {
y.Sub(pDiff, z) // y: parent_diff + parent_diff/2048 * adjustment_factor
} else {
y.Add(pDiff, z) // y: parent_diff + parent_diff/2048 * adjustment_factor
}
// minimum difficulty can ever be (before exponential factor)
if y.LtUint64(minimumDifficulty) {
y.SetUint64(minimumDifficulty)
}
// calculate a fake block number for the ice-age delay
// Specification: https://eips.ethereum.org/EIPS/eip-1234
var pNum = parent.Number.Uint64()
if pNum >= bombDelayFromParent {
if fakeBlockNumber := pNum - bombDelayFromParent; fakeBlockNumber >= 2*expDiffPeriodUint {
z.SetOne()
z.Lsh(z, uint(fakeBlockNumber/expDiffPeriodUint-2))
y.Add(z, y)
}
}
return y.ToBig()
}
}