+145 -25

abciapp/tx_epoch.go

··· 12 12 "github.com/cometbft/cometbft/crypto/ed25519" 13 13 protocrypto "github.com/cometbft/cometbft/proto/tendermint/crypto" 14 14 "github.com/gbl08ma/stacktrace" 15 15 + "github.com/govalues/decimal" 15 16 cbornode "github.com/ipfs/go-ipld-cbor" 17 17 + "github.com/samber/lo" 16 18 "tangled.org/gbl08ma.com/didplcbft/store" 17 19 ) 18 20 19 21 const UpdateValidatorsBlockInterval = 10000 20 22 const MaxActiveValidators = 50 21 21 - const MinReputationForBecomingValidator = 20000 23 23 + const MinReputationForBecomingValidator = (ReputationGainPerProvenBlock - ReputationEntropyLossPerBlock) * 60 * 60 * 24 // must solve challenges for about one day, assuming one block per second 22 24 23 25 func init() { 24 26 store.Consensus.ConfigureEpochSize(UpdateValidatorsBlockInterval) ··· 41 43 cbornode.RegisterCborType(Transaction[UpdateValidatorsArguments]{}) 42 44 } 43 45 44 44 - func computeVotingPowerFromReputation(reputation uint64) uint64 { 46 46 + var LogisticL = decimal.MustNew(10000000000000, 0) 47 47 + var LogisticNegK = lo.Must(decimal.NewFromInt64(0, 2, 8)).Neg() // -0.00000002 (already negated!) 48 48 + var LogisticX0 = lo.Must(decimal.New(60*60*24*365*8, 0)) // LogisticNegK and LogisticX0 were obtained based on vibes; for a target block interval of 1s, validator voting power is expected to plateau after about 1.5 years 49 49 + var LogisticOne = decimal.MustNew(1, 0) 50 50 + var LogisticZeroAdjust = decimal.MustNew(63954022804, 0) 51 51 + 52 52 + func computeVotingPowerFromReputation(reputation uint64) (uint64, error) { 45 53 if reputation < MinReputationForBecomingValidator { 46 46 - return 0 54 54 + return 0, nil 55 55 + } 56 56 + 57 57 + reputation = reputation - MinReputationForBecomingValidator 58 58 + 59 59 + rep, err := decimal.New(int64(reputation), 0) 60 60 + if err != nil { 61 61 + return 0, stacktrace.Propagate(err) 62 62 + } 63 63 + paren, err := rep.Sub(LogisticX0) 64 64 + if err != nil { 65 65 + return 0, stacktrace.Propagate(err) 66 66 + } 67 67 + exponent, err := paren.Mul(LogisticNegK) 68 68 + if err != nil { 69 69 + return 0, stacktrace.Propagate(err) 70 70 + } 71 71 + exponent, err = exponent.Exp() 72 72 + if err != nil { 73 73 + return 0, stacktrace.Propagate(err) 74 74 + } 75 75 + 76 76 + denominator, err := exponent.Add(LogisticOne) 77 77 + if err != nil { 78 78 + return 0, stacktrace.Propagate(err) 79 79 + } 80 80 + 81 81 + votingPower, err := LogisticL.Quo(denominator) 82 82 + if err != nil { 83 83 + return 0, stacktrace.Propagate(err) 84 84 + } 85 85 + 86 86 + votingPower, err = votingPower.Sub(LogisticZeroAdjust) 87 87 + if err != nil { 88 88 + return 0, stacktrace.Propagate(err) 89 89 + } 90 90 + 91 91 + // just for the voting power values to continue to see some insignificant movement after the top of the logistical curve is reached 92 92 + votingPower, err = votingPower.Add(rep) 93 93 + if err != nil { 94 94 + return 0, stacktrace.Propagate(err) 95 95 + } 96 96 + 97 97 + whole, _, ok := votingPower.Int64(0) 98 98 + if !ok { 99 99 + return 0, stacktrace.NewError("voting power can't be represented as a pair of int64") 47 100 } 48 48 - return reputation - MinReputationForBecomingValidator // TODO design and apply S-curve 101 101 + 102 102 + return uint64(whole), nil 49 103 } 104 104 + 105 105 + var updateValidatorsBlockIntervalDecimal = decimal.MustNew(UpdateValidatorsBlockInterval, 0) 50 106 51 107 func processUpdateValidatorsTx(ctx context.Context, deps TransactionProcessorDependencies, txBytes []byte) (*processResult, error) { 52 108 _, err := UnmarshalTransaction[UpdateValidatorsArguments](txBytes) ··· 96 152 } 97 153 98 154 voteCount, hasVotingPower := oldActiveValidatorSet[[store.PublicKeyLength]byte(validatorPubKey)] 99 99 - votesIncludedInFraction := float64(voteCount) / float64(UpdateValidatorsBlockInterval) 100 155 101 101 - decrease := computeReputationDecrease(uint64(deps.workingHeight), reputation, rangeChallengeCompletion, votesIncludedInFraction, hasVotingPower) 156 156 + decrease, err := computeReputationDecrease(uint64(deps.workingHeight), reputation, rangeChallengeCompletion, voteCount, hasVotingPower) 157 157 + if err != nil { 158 158 + return 0, stacktrace.Propagate(err) 159 159 + } 160 160 + 102 161 if decrease > reputation { 103 162 reputation = 0 104 163 } else { 105 164 reputation -= decrease 106 165 } 107 166 108 108 - votingPower := computeVotingPowerFromReputation(reputation) 167 167 + votingPower, err := computeVotingPowerFromReputation(reputation) 168 168 + if err != nil { 169 169 + return 0, stacktrace.Propagate(err) 170 170 + } 171 171 + 109 172 if votingPower > 0 { 110 173 vwvp := validatorWithVotingPower{ 111 174 validatorPubKey: validatorPubKey, ··· 114 177 115 178 if valHeap.Len() < MaxActiveValidators { 116 179 heap.Push(&valHeap, vwvp) 117 117 - } else if votingPower > valHeap[0].votingPower { 180 180 + } else if valHeap[0].less(vwvp) { 118 181 heap.Pop(&valHeap) 119 182 heap.Push(&valHeap, vwvp) 120 183 } ··· 194 257 votingPower uint64 195 258 } 196 259 260 260 + func (v1 validatorWithVotingPower) less(v2 validatorWithVotingPower) bool { 261 261 + if v1.votingPower == v2.votingPower { 262 262 + return bytes.Compare(v1.validatorPubKey, v2.validatorPubKey) < 0 263 263 + } 264 264 + return v1.votingPower < v2.votingPower 265 265 + } 266 266 + 197 267 type validatorHeap []validatorWithVotingPower 198 268 199 199 - func (h validatorHeap) Len() int { return len(h) } 200 200 - func (h validatorHeap) Less(i, j int) bool { return h[i].votingPower < h[j].votingPower } 201 201 - func (h validatorHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 269 269 + func (h validatorHeap) Len() int { return len(h) } 270 270 + func (h validatorHeap) Less(i, j int) bool { 271 271 + return h[i].less(h[j]) 272 272 + } 273 273 + func (h validatorHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } 202 274 203 275 func (h *validatorHeap) Push(x any) { 204 276 *h = append(*h, x.(validatorWithVotingPower)) ··· 229 301 return out, nil 230 302 } 231 303 232 232 - func computeReputationDecrease(workingHeight uint64, reputation uint64, rangeChallengeCompletion uint64, voteInclusionFrequency float64, validatorHasVotingPower bool) uint64 { 304 304 + var pointZero3 = decimal.MustNew(3, 2) 305 305 + var maxMissedRangeChallengePenaltyMul = decimal.MustNew(15, 2) 306 306 + 307 307 + var pointOne = decimal.MustNew(1, 1) 308 308 + var pointSeven = decimal.MustNew(7, 1) 309 309 + 310 310 + func computeReputationDecrease(workingHeight uint64, reputation uint64, rangeChallengeCompletion uint64, voteCount uint64, validatorHasVotingPower bool) (uint64, error) { 233 311 const expectedGainForCompletelyActiveValidator = ReputationGainPerProvenBlock * UpdateValidatorsBlockInterval 234 312 entropyLoss := ReputationEntropyLossPerBlock * UpdateValidatorsBlockInterval 235 313 ··· 243 321 244 322 rangeChallengeMissedEpochs := (workingHeight - rangeChallengeCompletion) / UpdateValidatorsBlockInterval 245 323 // allow for missing one epoch without penalty 246 246 - missedRangeChallengePenalty := float64(max(0, int64(rangeChallengeMissedEpochs)-1)) * 0.03 247 247 - if missedRangeChallengePenalty > 0.15 { 248 248 - // avoid a too sharp drop off 249 249 - missedRangeChallengePenalty = 0.15 324 324 + missedRangeChallengePenalty, err := decimal.MustNew(max(0, int64(rangeChallengeMissedEpochs)-1), 0).Mul(pointZero3) 325 325 + if err != nil { 326 326 + return 0, stacktrace.Propagate(err) 250 327 } 251 251 - if missedRangeChallengePenalty > 0 { 252 252 - penaltyInt := uint64(float64(reputation) * missedRangeChallengePenalty) 253 253 - if reputation < penaltyInt { 254 254 - return 0 328 328 + // avoid a too sharp drop off 329 329 + missedRangeChallengePenalty = missedRangeChallengePenalty.Min(maxMissedRangeChallengePenaltyMul) 330 330 + 331 331 + if missedRangeChallengePenalty.IsPos() { 332 332 + rep, err := decimal.New(int64(reputation), 0) 333 333 + if err != nil { 334 334 + return 0, stacktrace.Propagate(err) 335 335 + } 336 336 + 337 337 + penalty, err := rep.Mul(missedRangeChallengePenalty) 338 338 + if err != nil { 339 339 + return 0, stacktrace.Propagate(err) 340 340 + } 341 341 + 342 342 + penaltyInt, _, ok := penalty.Int64(0) 343 343 + if !ok { 344 344 + return 0, stacktrace.NewError("penalty not representable as an int64") 345 345 + } 346 346 + if reputation < uint64(penaltyInt) { 347 347 + return 0, nil 255 348 } 256 256 - decrease += penaltyInt 349 349 + decrease += uint64(penaltyInt) 257 350 } 258 351 259 352 // penalize active validators that haven't been voting ··· 263 356 // 2. MarkValidatorVote only runs on FinalizeBlock, which is called after the epoch transaction has been processed 264 357 // 3. Validator updates take a few blocks to fully take effect, meaning validators might only become (in)active after the epoch transaction has been processed 265 358 if validatorHasVotingPower { 359 359 + voteCountDecimal := decimal.MustNew(int64(voteCount), 0) 360 360 + voteInclusionFrequency, err := voteCountDecimal.Quo(updateValidatorsBlockIntervalDecimal) 361 361 + if err != nil { 362 362 + return 0, stacktrace.Propagate(err) 363 363 + } 364 364 + 266 365 switch { 267 267 - case voteInclusionFrequency < 0.1: 366 366 + case voteInclusionFrequency.Less(pointOne): 268 367 decrease += 5 * expectedGainForCompletelyActiveValidator 269 269 - case voteInclusionFrequency < 0.7: 270 270 - decrease += uint64(5 * float64(expectedGainForCompletelyActiveValidator) * (0.7 - voteInclusionFrequency) / 0.7) 368 368 + case voteInclusionFrequency.Less(pointSeven): 369 369 + dec, err := decimal.New(5*expectedGainForCompletelyActiveValidator, 0) 370 370 + if err != nil { 371 371 + return 0, stacktrace.Propagate(err) 372 372 + } 373 373 + 374 374 + penaltyFrac, err := pointSeven.Sub(voteInclusionFrequency) 375 375 + if err != nil { 376 376 + return 0, stacktrace.Propagate(err) 377 377 + } 378 378 + penaltyFrac, err = penaltyFrac.Quo(pointSeven) 379 379 + if err != nil { 380 380 + return 0, stacktrace.Propagate(err) 381 381 + } 382 382 + 383 383 + dec, err = dec.Mul(penaltyFrac) 384 384 + if err != nil { 385 385 + return 0, stacktrace.Propagate(err) 386 386 + } 387 387 + 388 388 + decInt, _, _ := dec.Int64(0) 389 389 + 390 390 + decrease += uint64(decInt) 271 391 } 272 392 } 273 393 274 274 - return decrease 394 394 + return decrease, nil 275 395 }

+1

go.mod

··· 69 69 github.com/google/orderedcode v0.0.1 // indirect 70 70 github.com/google/pprof v0.0.0-20250820193118-f64d9cf942d6 // indirect 71 71 github.com/gorilla/websocket v1.5.3 // indirect 72 72 + github.com/govalues/decimal v0.1.36 // indirect 72 73 github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect 73 74 github.com/hashicorp/hcl v1.0.0 // indirect 74 75 github.com/ingonyama-zk/icicle-gnark/v3 v3.2.2 // indirect

+2

go.sum

··· 151 151 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= 152 152 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= 153 153 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= 154 154 + github.com/govalues/decimal v0.1.36 h1:dojDpsSvrk0ndAx8+saW5h9WDIHdWpIwrH/yhl9olyU= 155 155 + github.com/govalues/decimal v0.1.36/go.mod h1:Ee7eI3Llf7hfqDZtpj8Q6NCIgJy1iY3kH1pSwDrNqlM= 154 156 github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= 155 157 github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= 156 158 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=