aboutsummaryrefslogtreecommitdiffstats
path: root/consensus/ethash
diff options
context:
space:
mode:
authorMartin Holst Swende <martin@swende.se>2018-09-16 05:44:25 +0800
committerMartin Holst Swende <martin@swende.se>2018-09-16 05:54:16 +0800
commit3df7df0386a78a6d818fb6dfbbbcf07ddedc658f (patch)
treedd54d93cef1704f1316bf504cc24ed7d9c1abd79 /consensus/ethash
parent0732617b655df7f35aff985612af8ba379cdb3fb (diff)
downloaddexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar.gz
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar.bz2
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar.lz
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar.xz
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.tar.zst
dexon-3df7df0386a78a6d818fb6dfbbbcf07ddedc658f.zip
ethash: less copy-paste for EIP 1234
Diffstat (limited to 'consensus/ethash')
-rw-r--r--consensus/ethash/consensus.go183
1 files changed, 67 insertions, 116 deletions
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index 874f09819..0394c37bb 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -43,6 +43,16 @@ var (
ConstantinopleBlockReward = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople
maxUncles = 2 // Maximum number of uncles allowed in a single block
allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks
+
+ // calcDifficultyConstantinople is the difficulty adjustment algorithm for Constantinople.
+ // 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 Byzantium rules, but with bomb offset 5M.
+ calcDifficultyConstantinople = makeDifficultyCalculator(big.NewInt(4999999))
+
+ // calcDifficultyByzantium 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 Byzantium rules.
+ calcDifficultyByzantium = makeDifficultyCalculator(big.NewInt(2999999))
)
// Various error messages to mark blocks invalid. These should be private to
@@ -319,126 +329,67 @@ var (
big9 = big.NewInt(9)
big10 = big.NewInt(10)
bigMinus99 = big.NewInt(-99)
- big2999999 = big.NewInt(2999999)
- big4999999 = big.NewInt(4999999)
)
-// calcDifficultyConstantinople 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 Constantinople rules.
-func calcDifficultyConstantinople(time uint64, parent *types.Header) *big.Int {
- // https://github.com/ethereum/EIPs/issues/100.
- // algorithm:
- // diff = (parent_diff +
- // (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
- // ) + 2^(periodCount - 2)
-
- bigTime := new(big.Int).SetUint64(time)
- bigParentTime := new(big.Int).Set(parent.Time)
-
- // holds intermediate values to make the algo easier to read & audit
- x := new(big.Int)
- y := new(big.Int)
-
- // (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9
- x.Sub(bigTime, bigParentTime)
- x.Div(x, big9)
- if parent.UncleHash == types.EmptyUncleHash {
- x.Sub(big1, x)
- } else {
- x.Sub(big2, x)
- }
- // max((2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9, -99)
- if x.Cmp(bigMinus99) < 0 {
- x.Set(bigMinus99)
- }
- // parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
- y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
- x.Mul(y, x)
- x.Add(parent.Difficulty, x)
-
- // minimum difficulty can ever be (before exponential factor)
- if x.Cmp(params.MinimumDifficulty) < 0 {
- x.Set(params.MinimumDifficulty)
- }
- // calculate a fake block number for the ice-age delay:
- // https://github.com/ethereum/EIPs/pull/1234
- // fake_block_number = max(0, block.number - 5_000_000)
- fakeBlockNumber := new(big.Int)
- if parent.Number.Cmp(big4999999) >= 0 {
- fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, big4999999) // Note, parent is 1 less than the actual block number
- }
- // for the exponential factor
- periodCount := fakeBlockNumber
- periodCount.Div(periodCount, expDiffPeriod)
-
- // the exponential factor, commonly referred to as "the bomb"
- // diff = diff + 2^(periodCount - 2)
- if periodCount.Cmp(big1) > 0 {
- y.Sub(periodCount, big2)
- y.Exp(big2, y, nil)
- x.Add(x, y)
- }
- return x
-}
-
-// calcDifficultyByzantium 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 Byzantium rules.
-func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
- // https://github.com/ethereum/EIPs/issues/100.
- // algorithm:
- // diff = (parent_diff +
- // (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
- // ) + 2^(periodCount - 2)
-
- bigTime := new(big.Int).SetUint64(time)
- bigParentTime := new(big.Int).Set(parent.Time)
-
- // holds intermediate values to make the algo easier to read & audit
- x := new(big.Int)
- y := new(big.Int)
-
- // (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9
- x.Sub(bigTime, bigParentTime)
- x.Div(x, big9)
- if parent.UncleHash == types.EmptyUncleHash {
- x.Sub(big1, x)
- } else {
- x.Sub(big2, x)
- }
- // max((2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9, -99)
- if x.Cmp(bigMinus99) < 0 {
- x.Set(bigMinus99)
- }
- // parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
- y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
- x.Mul(y, x)
- x.Add(parent.Difficulty, x)
-
- // minimum difficulty can ever be (before exponential factor)
- if x.Cmp(params.MinimumDifficulty) < 0 {
- x.Set(params.MinimumDifficulty)
- }
- // calculate a fake block number for the ice-age delay:
- // https://github.com/ethereum/EIPs/pull/669
- // fake_block_number = max(0, block.number - 3_000_000)
- fakeBlockNumber := new(big.Int)
- if parent.Number.Cmp(big2999999) >= 0 {
- fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, big2999999) // Note, parent is 1 less than the actual block number
- }
- // for the exponential factor
- periodCount := fakeBlockNumber
- periodCount.Div(periodCount, expDiffPeriod)
+// makeDifficultyCalculator 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 makeDifficultyCalculator(bombDelay *big.Int) func(time uint64, parent *types.Header) *big.Int {
+ return func(time uint64, parent *types.Header) *big.Int {
+ // https://github.com/ethereum/EIPs/issues/100.
+ // algorithm:
+ // diff = (parent_diff +
+ // (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
+ // ) + 2^(periodCount - 2)
+
+ bigTime := new(big.Int).SetUint64(time)
+ bigParentTime := new(big.Int).Set(parent.Time)
+
+ // holds intermediate values to make the algo easier to read & audit
+ x := new(big.Int)
+ y := new(big.Int)
+
+ // (2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9
+ x.Sub(bigTime, bigParentTime)
+ x.Div(x, big9)
+ if parent.UncleHash == types.EmptyUncleHash {
+ x.Sub(big1, x)
+ } else {
+ x.Sub(big2, x)
+ }
+ // max((2 if len(parent_uncles) else 1) - (block_timestamp - parent_timestamp) // 9, -99)
+ if x.Cmp(bigMinus99) < 0 {
+ x.Set(bigMinus99)
+ }
+ // parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
+ y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
+ x.Mul(y, x)
+ x.Add(parent.Difficulty, x)
+
+ // minimum difficulty can ever be (before exponential factor)
+ if x.Cmp(params.MinimumDifficulty) < 0 {
+ x.Set(params.MinimumDifficulty)
+ }
+ // calculate a fake block number for the ice-age delay:
+ // https://github.com/ethereum/EIPs/pull/669
+ // fake_block_number = max(0, block.number - 3_000_000)
+ fakeBlockNumber := new(big.Int)
+ if parent.Number.Cmp(bombDelay) >= 0 {
+ fakeBlockNumber = fakeBlockNumber.Sub(parent.Number, bombDelay) // Note, parent is 1 less than the actual block number
+ }
+ // for the exponential factor
+ periodCount := fakeBlockNumber
+ periodCount.Div(periodCount, expDiffPeriod)
- // the exponential factor, commonly referred to as "the bomb"
- // diff = diff + 2^(periodCount - 2)
- if periodCount.Cmp(big1) > 0 {
- y.Sub(periodCount, big2)
- y.Exp(big2, y, nil)
- x.Add(x, y)
+ // the exponential factor, commonly referred to as "the bomb"
+ // diff = diff + 2^(periodCount - 2)
+ if periodCount.Cmp(big1) > 0 {
+ y.Sub(periodCount, big2)
+ y.Exp(big2, y, nil)
+ x.Add(x, y)
+ }
+ return x
}
- return x
}
// calcDifficultyHomestead is the difficulty adjustment algorithm. It returns