101 lines
3.4 KiB
TypeScript
101 lines
3.4 KiB
TypeScript
import config from '../config';
|
|
import { IDifficultyAdjustment } from '../mempool.interfaces';
|
|
import blocks from './blocks';
|
|
|
|
export interface DifficultyAdjustment {
|
|
progressPercent: number; // Percent: 0 to 100
|
|
difficultyChange: number; // Percent: -75 to 300
|
|
estimatedRetargetDate: number; // Unix time in ms
|
|
remainingBlocks: number; // Block count
|
|
remainingTime: number; // Duration of time in ms
|
|
previousRetarget: number; // Percent: -75 to 300
|
|
nextRetargetHeight: number; // Block Height
|
|
timeAvg: number; // Duration of time in ms
|
|
timeOffset: number; // (Testnet) Time since last block (cap @ 20min) in ms
|
|
}
|
|
|
|
export function calcDifficultyAdjustment(
|
|
DATime: number,
|
|
nowSeconds: number,
|
|
blockHeight: number,
|
|
previousRetarget: number,
|
|
network: string,
|
|
latestBlockTimestamp: number,
|
|
): DifficultyAdjustment {
|
|
const ESTIMATE_LAG_BLOCKS = 146; // For first 7.2% of epoch, don't estimate.
|
|
const EPOCH_BLOCK_LENGTH = 2016; // Bitcoin mainnet
|
|
const BLOCK_SECONDS_TARGET = 600; // Bitcoin mainnet
|
|
|
|
const diffSeconds = nowSeconds - DATime;
|
|
const blocksInEpoch = (blockHeight >= 0) ? blockHeight % EPOCH_BLOCK_LENGTH : 0;
|
|
const progressPercent = (blockHeight >= 0) ? blocksInEpoch / EPOCH_BLOCK_LENGTH * 100 : 100;
|
|
const remainingBlocks = EPOCH_BLOCK_LENGTH - blocksInEpoch;
|
|
const nextRetargetHeight = (blockHeight >= 0) ? blockHeight + remainingBlocks : 0;
|
|
|
|
let difficultyChange = 0;
|
|
let timeAvgMins = 10;
|
|
// Only calculate the estimate once we have 7.2% of blocks in current epoch
|
|
if (blocksInEpoch >= ESTIMATE_LAG_BLOCKS) {
|
|
const secondsPerBlock = diffSeconds / blocksInEpoch;
|
|
timeAvgMins = secondsPerBlock / 60;
|
|
difficultyChange = (BLOCK_SECONDS_TARGET / secondsPerBlock - 1) * 100;
|
|
// Max increase is x4 (+300%)
|
|
if (difficultyChange > 300) {
|
|
difficultyChange = 300;
|
|
}
|
|
// Max decrease is /4 (-75%)
|
|
if (difficultyChange < -75) {
|
|
difficultyChange = -75;
|
|
}
|
|
}
|
|
|
|
// Testnet difficulty is set to 1 after 20 minutes of no blocks,
|
|
// therefore the time between blocks will always be below 20 minutes (1200s).
|
|
let timeOffset = 0;
|
|
if (network === 'testnet') {
|
|
if (timeAvgMins > 20) {
|
|
timeAvgMins = 20;
|
|
}
|
|
|
|
if (nowSeconds - latestBlockTimestamp + timeAvgMins * 60 > 1200) {
|
|
timeOffset = -Math.min(nowSeconds - latestBlockTimestamp, 1200) * 1000;
|
|
}
|
|
}
|
|
|
|
const timeAvg = Math.floor(timeAvgMins * 60 * 1000);
|
|
const remainingTime = remainingBlocks * timeAvg;
|
|
const estimatedRetargetDate = remainingTime + nowSeconds * 1000;
|
|
|
|
return {
|
|
progressPercent,
|
|
difficultyChange,
|
|
estimatedRetargetDate,
|
|
remainingBlocks,
|
|
remainingTime,
|
|
previousRetarget,
|
|
nextRetargetHeight,
|
|
timeAvg,
|
|
timeOffset,
|
|
};
|
|
}
|
|
|
|
class DifficultyAdjustmentApi {
|
|
constructor() { }
|
|
|
|
public getDifficultyAdjustment(): IDifficultyAdjustment {
|
|
const DATime = blocks.getLastDifficultyAdjustmentTime();
|
|
const previousRetarget = blocks.getPreviousDifficultyRetarget();
|
|
const blockHeight = blocks.getCurrentBlockHeight();
|
|
const blocksCache = blocks.getBlocks();
|
|
const latestBlock = blocksCache[blocksCache.length - 1];
|
|
const nowSeconds = Math.floor(new Date().getTime() / 1000);
|
|
|
|
return calcDifficultyAdjustment(
|
|
DATime, nowSeconds, blockHeight, previousRetarget,
|
|
config.MEMPOOL.NETWORK, latestBlock.timestamp
|
|
);
|
|
}
|
|
}
|
|
|
|
export default new DifficultyAdjustmentApi();
|