forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

consensus/ubqhash: merge calcDifficultyOrig and calcDifficulty2 into calcDifficultyDigishieldV3

Browse source
This commit is contained in:
Luke Williams 2019-12-21 12:06:59 +01:00
parent b17e25f2db
commit 8b2745314d
1 changed files with 36 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
consensus/ubqhash/consensus.go
View file

@ -312,52 +312,27 @@ func (ubqhash *Ubqhash) verifyHeader(chain consensus.ChainReader, header, parent
} }
// Difficulty timespans // Difficulty timespans
func averagingWindowTimespan() *big.Int { func averagingWindowTimespan(config *diffConfig) *big.Int {
x := new(big.Int) x := new(big.Int)
return x.Mul(digishieldV3Config.AveragingWindow, big88) return x.Mul(config.AveragingWindow, big88)
} }
func minActualTimespan() *big.Int { func minActualTimespan(config *diffConfig) *big.Int {
x := new(big.Int) x := new(big.Int)
y := new(big.Int) y := new(big.Int)
z := new(big.Int) z := new(big.Int)
x.Sub(big.NewInt(100), digishieldV3Config.MaxAdjustUp) x.Sub(big.NewInt(100), config.MaxAdjustUp)
y.Mul(averagingWindowTimespan(), x) y.Mul(averagingWindowTimespan(config), x)
z.Div(y, big.NewInt(100)) z.Div(y, big.NewInt(100))
return z return z
} }
func maxActualTimespan() *big.Int { func maxActualTimespan(config *diffConfig) *big.Int {
x := new(big.Int) x := new(big.Int)
y := new(big.Int) y := new(big.Int)
z := new(big.Int) z := new(big.Int)
x.Add(big.NewInt(100), digishieldV3Config.MaxAdjustDown) x.Add(big.NewInt(100), config.MaxAdjustDown)
y.Mul(averagingWindowTimespan(), x) y.Mul(averagingWindowTimespan(config), x)
z.Div(y, big.NewInt(100))
return z
}
func averagingWindowTimespan88() *big.Int {
x := new(big.Int)
return x.Mul(digishieldV3ModConfig.AveragingWindow, big88)
}
func minActualTimespan2() *big.Int {
x := new(big.Int)
y := new(big.Int)
z := new(big.Int)
x.Sub(big.NewInt(100), digishieldV3ModConfig.MaxAdjustUp)
y.Mul(averagingWindowTimespan88(), x)
z.Div(y, big.NewInt(100))
return z
}
func maxActualTimespan2() *big.Int {
x := new(big.Int)
y := new(big.Int)
z := new(big.Int)
x.Add(big.NewInt(100), digishieldV3ModConfig.MaxAdjustDown)
y.Mul(averagingWindowTimespan88(), x)
z.Div(y, big.NewInt(100)) z.Div(y, big.NewInt(100))
return z return z
} }
@ -368,11 +343,11 @@ func minActualTimespanFlux(dampen bool) *big.Int {
z := new(big.Int) z := new(big.Int)
if dampen { if dampen {
x.Sub(big.NewInt(1000), fluxConfig.Dampen) x.Sub(big.NewInt(1000), fluxConfig.Dampen)
y.Mul(averagingWindowTimespan88(), x) y.Mul(averagingWindowTimespan(fluxConfig), x)
z.Div(y, big.NewInt(1000)) z.Div(y, big.NewInt(1000))
} else { } else {
x.Sub(big.NewInt(1000), fluxConfig.MaxAdjustUp) x.Sub(big.NewInt(1000), fluxConfig.MaxAdjustUp)
y.Mul(averagingWindowTimespan88(), x) y.Mul(averagingWindowTimespan(fluxConfig), x)
z.Div(y, big.NewInt(1000)) z.Div(y, big.NewInt(1000))
} }
return z return z
@ -384,11 +359,11 @@ func maxActualTimespanFlux(dampen bool) *big.Int {
z := new(big.Int) z := new(big.Int)
if dampen { if dampen {
x.Add(big.NewInt(1000), fluxConfig.Dampen) x.Add(big.NewInt(1000), fluxConfig.Dampen)
y.Mul(averagingWindowTimespan88(), x) y.Mul(averagingWindowTimespan(fluxConfig), x)
z.Div(y, big.NewInt(1000)) z.Div(y, big.NewInt(1000))
} else { } else {
x.Add(big.NewInt(1000), fluxConfig.MaxAdjustDown) x.Add(big.NewInt(1000), fluxConfig.MaxAdjustDown)
y.Mul(averagingWindowTimespan88(), x) y.Mul(averagingWindowTimespan(fluxConfig), x)
z.Div(y, big.NewInt(1000)) z.Div(y, big.NewInt(1000))
} }
return z return z
@ -409,15 +384,17 @@ func CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Head
config := chain.Config() config := chain.Config()
ubqhashConfig := config.Ubqhash ubqhashConfig := config.Ubqhash
if parentNumber.Cmp(ubqhashConfig.DigishieldModBlock) < 0 {
return calcDifficultyOrig(chain, parentNumber, parentDiff, parent)
}
if parentNumber.Cmp(ubqhashConfig.FluxBlock) < 0 { if parentNumber.Cmp(ubqhashConfig.FluxBlock) < 0 {
// (chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header) if parentNumber.Cmp(ubqhashConfig.DigishieldModBlock) < 0 {
return calcDifficulty2(chain, parentNumber, parentDiff, parent) // Original DigishieldV3
return calcDifficultyDigishieldV3(chain, parentNumber, parentDiff, parent, digishieldV3Config)
} else { } else {
// (chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header) // Modified DigishieldV3
return fluxDifficulty(chain, big.NewInt(int64(time)), big.NewInt(int64(parentTime)), parentNumber, parentDiff, parent) return calcDifficultyDigishieldV3(chain, parentNumber, parentDiff, parent, digishieldV3ModConfig)
}
} else {
// Flux
return calcDifficultyFlux(chain, big.NewInt(int64(time)), big.NewInt(int64(parentTime)), parentNumber, parentDiff, parent)
} }
} }
@ -464,17 +441,17 @@ func CalcDifficultyLegacy(time, parentTime uint64, parentNumber, parentDiff *big
// the difficulty that a new block should have when created at time // the difficulty that a new block should have when created at time
// given the parent block's time and difficulty. // given the parent block's time and difficulty.
// Rewritten to be based on Digibyte's Digishield v3 retargeting // Rewritten to be based on Digibyte's Digishield v3 retargeting
func calcDifficultyOrig(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int { func calcDifficultyDigishieldV3(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header, digishield *diffConfig) *big.Int {
// holds intermediate values to make the algo easier to read & audit // holds intermediate values to make the algo easier to read & audit
x := new(big.Int) x := new(big.Int)
nFirstBlock := new(big.Int) nFirstBlock := new(big.Int)
nFirstBlock.Sub(parentNumber, digishieldV3Config.AveragingWindow) nFirstBlock.Sub(parentNumber, digishield.AveragingWindow)
log.Debug(fmt.Sprintf("CalcDifficulty parentNumber: %v parentDiff: %v", parentNumber, parentDiff)) log.Debug(fmt.Sprintf("CalcDifficulty parentNumber: %v parentDiff: %v", parentNumber, parentDiff))
// Check we have enough blocks // Check we have enough blocks
if parentNumber.Cmp(digishieldV3Config.AveragingWindow) < 1 { if parentNumber.Cmp(digishield.AveragingWindow) < 1 {
log.Debug(fmt.Sprintf("CalcDifficulty: parentNumber(%+x) < digishieldV3Config.AveragingWindow(%+x)", parentNumber, digishieldV3Config.AveragingWindow)) log.Debug(fmt.Sprintf("CalcDifficulty: parentNumber(%+x) < digishieldV3Config.AveragingWindow(%+x)", parentNumber, digishield.AveragingWindow))
x.Set(parentDiff) x.Set(parentDiff)
return x return x
} }
@ -490,56 +467,28 @@ func calcDifficultyOrig(chain consensus.ChainReader, parentNumber, parentDiff *b
// nActualTimespan = AveragingWindowTimespan() + (nActualTimespan-AveragingWindowTimespan())/4 // nActualTimespan = AveragingWindowTimespan() + (nActualTimespan-AveragingWindowTimespan())/4
y := new(big.Int) y := new(big.Int)
y.Sub(nActualTimespan, averagingWindowTimespan()) y.Sub(nActualTimespan, averagingWindowTimespan(digishield))
y.Div(y, big.NewInt(4)) y.Div(y, big.NewInt(4))
nActualTimespan.Add(y, averagingWindowTimespan()) nActualTimespan.Add(y, averagingWindowTimespan(digishield))
log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v before bounds", nActualTimespan)) log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v before bounds", nActualTimespan))
if nActualTimespan.Cmp(minActualTimespan()) < 0 { if nActualTimespan.Cmp(minActualTimespan(digishield)) < 0 {
nActualTimespan.Set(minActualTimespan()) nActualTimespan.Set(minActualTimespan(digishield))
log.Debug("CalcDifficulty Minimum Timespan set") log.Debug("CalcDifficulty Minimum Timespan set")
} else if nActualTimespan.Cmp(maxActualTimespan()) > 0 { } else if nActualTimespan.Cmp(maxActualTimespan(digishield)) > 0 {
nActualTimespan.Set(maxActualTimespan()) nActualTimespan.Set(maxActualTimespan(digishield))
log.Debug("CalcDifficulty Maximum Timespan set") log.Debug("CalcDifficulty Maximum Timespan set")
} }
log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v final\n", nActualTimespan)) log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v final\n", nActualTimespan))
// Retarget // Retarget
x.Mul(parentDiff, averagingWindowTimespan()) x.Mul(parentDiff, averagingWindowTimespan(digishield))
log.Debug(fmt.Sprintf("CalcDifficulty parentDiff * AveragingWindowTimespan: %v", x)) log.Debug(fmt.Sprintf("CalcDifficulty parentDiff * AveragingWindowTimespan: %v", x))
x.Div(x, nActualTimespan) x.Div(x, nActualTimespan)
log.Debug(fmt.Sprintf("CalcDifficulty x / nActualTimespan: %v", x)) log.Debug(fmt.Sprintf("CalcDifficulty x / nActualTimespan: %v", x))
return x
}
func calcDifficulty2(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
x := new(big.Int)
nFirstBlock := new(big.Int)
nFirstBlock.Sub(parentNumber, digishieldV3ModConfig.AveragingWindow)
nLastBlockTime := chain.CalcPastMedianTime(parentNumber.Uint64(), parent)
nFirstBlockTime := chain.CalcPastMedianTime(nFirstBlock.Uint64(), parent)
nActualTimespan := new(big.Int)
nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime)
y := new(big.Int)
y.Sub(nActualTimespan, averagingWindowTimespan88())
y.Div(y, big.NewInt(4))
nActualTimespan.Add(y, averagingWindowTimespan88())
if nActualTimespan.Cmp(minActualTimespan2()) < 0 {
nActualTimespan.Set(minActualTimespan2())
} else if nActualTimespan.Cmp(maxActualTimespan2()) > 0 {
nActualTimespan.Set(maxActualTimespan2())
}
x.Mul(parentDiff, averagingWindowTimespan88())
x.Div(x, nActualTimespan)
if x.Cmp(params.MinimumDifficulty) < 0 { if x.Cmp(params.MinimumDifficulty) < 0 {
x.Set(params.MinimumDifficulty) x.Set(params.MinimumDifficulty)
} }
@ -547,7 +496,7 @@ func calcDifficulty2(chain consensus.ChainReader, parentNumber, parentDiff *big.
return x return x
} }
func fluxDifficulty(chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int { func calcDifficultyFlux(chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
x := new(big.Int) x := new(big.Int)
nFirstBlock := new(big.Int) nFirstBlock := new(big.Int)
nFirstBlock.Sub(parentNumber, fluxConfig.AveragingWindow) nFirstBlock.Sub(parentNumber, fluxConfig.AveragingWindow)
@ -561,9 +510,9 @@ func fluxDifficulty(chain consensus.ChainReader, time, parentTime, parentNumber,
nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime) nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime)
y := new(big.Int) y := new(big.Int)
y.Sub(nActualTimespan, averagingWindowTimespan88()) y.Sub(nActualTimespan, averagingWindowTimespan(fluxConfig))
y.Div(y, big.NewInt(4)) y.Div(y, big.NewInt(4))
nActualTimespan.Add(y, averagingWindowTimespan88()) nActualTimespan.Add(y, averagingWindowTimespan(fluxConfig))
if nActualTimespan.Cmp(minActualTimespanFlux(false)) < 0 { if nActualTimespan.Cmp(minActualTimespanFlux(false)) < 0 {
doubleBig88 := new(big.Int) doubleBig88 := new(big.Int)
@ -583,7 +532,7 @@ func fluxDifficulty(chain consensus.ChainReader, time, parentTime, parentNumber,
} }
} }
x.Mul(parentDiff, averagingWindowTimespan88()) x.Mul(parentDiff, averagingWindowTimespan(fluxConfig))
x.Div(x, nActualTimespan) x.Div(x, nActualTimespan)
if x.Cmp(params.MinimumDifficulty) < 0 { if x.Cmp(params.MinimumDifficulty) < 0 {