This first one appears to be the best all around:

# Jacob Eliosoff's EMA (exponential moving average) # https://en.wikipedia.org/wiki/Moving_average#Application_to_measuring_computer_performance # ST = solvetime, T=target solvetime # height = most recently solved block # N=70 # MTP should not be used for (i=height - 10 to height) { # check timestamps starting 10 blocks into past) previous_max = max max=timestamp[i] if timestamp[i] > max } ST = max - previous_max ST = max(T/100,min(T*10, ST)) next_D = previous_D * ( T/ST + e^(-ST/T/N) * (1-T/ST) )A word of caution with the above EMA: when converting to and from bits field (aka target) to difficulty, it is important to not make a consistently wrong "rounding" error. For example, if previous difficulty was 100,000, it is important that nothing in the code make it consistently +50 more or consistently -50 less (0.05% error). That would cause the EMA at N=70 to have 3.5% error in solvetime. At 0.5% error per block, there is 35% error in the solvetimes (difficulty is 30% too high or low). The error that develops seems to be based on about 1.005^70 = 41%. If half the time it is +1,000 too high and the other half -1,000 too low, then it's OK. just don't be consistently wrong in the same direction. Error in the value for e=2.7183 does not hurt it.

In an simple average (SMA), a multiplicative error like this only causes a proportional error in solvetime, not a compounded error.

There is a T/solvetime ratio in two places. It must be the same in both places. I don't know how it would be coded to give something different, but it's something to be aware of.

==========

The following attempts to make it smoother while having some ability to respond to faster to big hashrate changes.

# Dynamic EMA difficulty algo (Jacob Eliosoff's EMA and Zawy's adjustable window). # Bitcoin cash dev(?) came up with the median of three to reduce timestamp errors. # For EMA origins see # https://en.wikipedia.org/wiki/Moving_average#Application_to_measuring_computer_performance # "Dynamic" means it triggers to a faster-responding value for N if a substantial change in hashrate # is detected. It increases from that event back to Nmax Nmax=100 # max EMA window Nmin=25 # min EMA window A=10, B=2, C=0.37 # A,B,C = 10,2,37 or 20, 1.65 0.45, # TS=timestamp, T=target solvetime, i.e. 600 seconds # Find the most recent unusual 20-block event for (i=height-Nmax to height) { # height=current block index if ( (median(TS[i],TS[i-1],TS[i-2]) - median(TS[i-20],TS[i-21],TS[i-22]))/T/A > B or (median(TS[i],TS[i-1],TS[i-2]) - median(TS[i-20],TS[i-21],TS[i-22]))/T/A < C ) { unusual_event=height - i + Nmin } } N = min(Nmax, unusual_event)) # now do the EMA shown above with this NHere's another algorithm that seems to be about as good as the EMA

# Weighted-Weighted Harmonic Mean (WWHM) difficulty algorithm # Original idea from Tom Harding (Deger8) called "WT-144" # No limits, filtering, or tempering should be attempted. # MTP should not be used. # set constants # N=60 # See Masari coin for live data with N=60 # T=600 # coin's Target solvetime. If this changes, nothing else needs to be changed. # adjust=0.99 # 0.98 for N=30, 0.99 for N=60 # k = (N+1)/2 *adjust * T # there is not a missing N. # height = most recently solved block # algorithm d=0, t=0, j=0 previous_max=timestamp[height - N] for ( i = height-N+1; i < height+1; i++) { # (N most recent blocks) max_timestamp=max(timestamp[i], previous_max) solvetime = max_timestamp - previous_max solvetime=1 if solvetime < 1 # for N=60, 10*T solvetimes drives difficulty too far down, so: solvetime = 10*T if solvetime > 10*T previous_max=max_timestamp j++ t += solvetime * j d += D[i] # sum the difficulties this is how WWHM is different from Tom's WT. } t=T*N if t < T*N # in case of startup weirdness, keep t reasonable next_D = d * k / t # limits on next_D do not need to be used because of the above solvetime restrictions # but if you still want limits on D's change per block & expect max 5x hash rate # changes or want to replace the solvetime restrictions, use # limit = 5^(3/N) # next_D = previous_D*limit if next_D > previous_D*limit # next_D = previous_D/limit if next_D > previous_D/limit