691 lines
26 KiB
TypeScript
691 lines
26 KiB
TypeScript
import { BlockPrice, PoolInfo, PoolStats, RewardStats } from '../../mempool.interfaces';
|
|
import BlocksRepository from '../../repositories/BlocksRepository';
|
|
import PoolsRepository from '../../repositories/PoolsRepository';
|
|
import HashratesRepository from '../../repositories/HashratesRepository';
|
|
import bitcoinClient from '../bitcoin/bitcoin-client';
|
|
import logger from '../../logger';
|
|
import { Common } from '../common';
|
|
import loadingIndicators from '../loading-indicators';
|
|
import { escape } from 'mysql2';
|
|
import DifficultyAdjustmentsRepository from '../../repositories/DifficultyAdjustmentsRepository';
|
|
import config from '../../config';
|
|
import BlocksAuditsRepository from '../../repositories/BlocksAuditsRepository';
|
|
import PricesRepository from '../../repositories/PricesRepository';
|
|
import bitcoinApi from '../bitcoin/bitcoin-api-factory';
|
|
import { IEsploraApi } from '../bitcoin/esplora-api.interface';
|
|
import database from '../../database';
|
|
|
|
interface DifficultyBlock {
|
|
timestamp: number,
|
|
height: number,
|
|
bits: number,
|
|
difficulty: number,
|
|
}
|
|
|
|
class Mining {
|
|
private blocksPriceIndexingRunning = false;
|
|
public lastHashrateIndexingDate: number | null = null;
|
|
public lastWeeklyHashrateIndexingDate: number | null = null;
|
|
|
|
public reindexHashrateRequested = false;
|
|
public reindexDifficultyAdjustmentRequested = false;
|
|
|
|
/**
|
|
* Get historical blocks health
|
|
*/
|
|
public async $getBlocksHealthHistory(interval: string | null = null): Promise<any> {
|
|
return await BlocksAuditsRepository.$getBlocksHealthHistory(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get historical block total fee
|
|
*/
|
|
public async $getHistoricalBlockFees(interval: string | null = null): Promise<any> {
|
|
return await BlocksRepository.$getHistoricalBlockFees(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get timespan block total fees
|
|
*/
|
|
public async $getBlockFeesTimespan(from: number, to: number): Promise<number> {
|
|
return await BlocksRepository.$getHistoricalBlockFees(
|
|
this.getTimeRangeFromTimespan(from, to),
|
|
null,
|
|
{from, to}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get historical block rewards
|
|
*/
|
|
public async $getHistoricalBlockRewards(interval: string | null = null): Promise<any> {
|
|
return await BlocksRepository.$getHistoricalBlockRewards(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get historical block fee rates percentiles
|
|
*/
|
|
public async $getHistoricalBlockFeeRates(interval: string | null = null): Promise<any> {
|
|
return await BlocksRepository.$getHistoricalBlockFeeRates(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get historical block sizes
|
|
*/
|
|
public async $getHistoricalBlockSizes(interval: string | null = null): Promise<any> {
|
|
return await BlocksRepository.$getHistoricalBlockSizes(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get historical block weights
|
|
*/
|
|
public async $getHistoricalBlockWeights(interval: string | null = null): Promise<any> {
|
|
return await BlocksRepository.$getHistoricalBlockWeights(
|
|
this.getTimeRange(interval),
|
|
Common.getSqlInterval(interval)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Generate high level overview of the pool ranks and general stats
|
|
*/
|
|
public async $getPoolsStats(interval: string | null): Promise<object> {
|
|
const poolsStatistics = {};
|
|
|
|
const poolsInfo: PoolInfo[] = await PoolsRepository.$getPoolsInfo(interval);
|
|
const emptyBlocks: any[] = await BlocksRepository.$countEmptyBlocks(null, interval);
|
|
|
|
const poolsStats: PoolStats[] = [];
|
|
let rank = 1;
|
|
|
|
poolsInfo.forEach((poolInfo: PoolInfo) => {
|
|
const emptyBlocksCount = emptyBlocks.filter((emptyCount) => emptyCount.poolId === poolInfo.poolId);
|
|
const poolStat: PoolStats = {
|
|
poolId: poolInfo.poolId, // mysql row id
|
|
name: poolInfo.name,
|
|
link: poolInfo.link,
|
|
blockCount: poolInfo.blockCount,
|
|
rank: rank++,
|
|
emptyBlocks: emptyBlocksCount.length > 0 ? emptyBlocksCount[0]['count'] : 0,
|
|
slug: poolInfo.slug,
|
|
avgMatchRate: poolInfo.avgMatchRate !== null ? Math.round(100 * poolInfo.avgMatchRate) / 100 : null,
|
|
avgFeeDelta: poolInfo.avgFeeDelta,
|
|
poolUniqueId: poolInfo.poolUniqueId
|
|
};
|
|
poolsStats.push(poolStat);
|
|
});
|
|
|
|
poolsStatistics['pools'] = poolsStats;
|
|
|
|
const blockCount: number = await BlocksRepository.$blockCount(null, interval);
|
|
poolsStatistics['blockCount'] = blockCount;
|
|
|
|
const totalBlock24h: number = await BlocksRepository.$blockCount(null, '24h');
|
|
|
|
try {
|
|
poolsStatistics['lastEstimatedHashrate'] = await bitcoinClient.getNetworkHashPs(totalBlock24h);
|
|
} catch (e) {
|
|
poolsStatistics['lastEstimatedHashrate'] = 0;
|
|
logger.debug('Bitcoin Core is not available, using zeroed value for current hashrate', logger.tags.mining);
|
|
}
|
|
|
|
return poolsStatistics;
|
|
}
|
|
|
|
/**
|
|
* Get all mining pool stats for a pool
|
|
*/
|
|
public async $getPoolStat(slug: string): Promise<object> {
|
|
const pool = await PoolsRepository.$getPool(slug);
|
|
if (!pool) {
|
|
throw new Error('This mining pool does not exist');
|
|
}
|
|
|
|
const blockCount: number = await BlocksRepository.$blockCount(pool.id);
|
|
const totalBlock: number = await BlocksRepository.$blockCount(null, null);
|
|
|
|
const blockCount24h: number = await BlocksRepository.$blockCount(pool.id, '24h');
|
|
const totalBlock24h: number = await BlocksRepository.$blockCount(null, '24h');
|
|
|
|
const blockCount1w: number = await BlocksRepository.$blockCount(pool.id, '1w');
|
|
const totalBlock1w: number = await BlocksRepository.$blockCount(null, '1w');
|
|
|
|
const avgHealth = await BlocksRepository.$getAvgBlockHealthPerPoolId(pool.id);
|
|
const totalReward = await BlocksRepository.$getTotalRewardForPoolId(pool.id);
|
|
|
|
let currentEstimatedHashrate = 0;
|
|
try {
|
|
currentEstimatedHashrate = await bitcoinClient.getNetworkHashPs(totalBlock24h);
|
|
} catch (e) {
|
|
logger.debug('Bitcoin Core is not available, using zeroed value for current hashrate', logger.tags.mining);
|
|
}
|
|
|
|
return {
|
|
pool: pool,
|
|
blockCount: {
|
|
'all': blockCount,
|
|
'24h': blockCount24h,
|
|
'1w': blockCount1w,
|
|
},
|
|
blockShare: {
|
|
'all': blockCount / totalBlock,
|
|
'24h': blockCount24h / totalBlock24h,
|
|
'1w': blockCount1w / totalBlock1w,
|
|
},
|
|
estimatedHashrate: currentEstimatedHashrate * (blockCount24h / totalBlock24h),
|
|
reportedHashrate: null,
|
|
avgBlockHealth: avgHealth,
|
|
totalReward: totalReward,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get miner reward stats
|
|
*/
|
|
public async $getRewardStats(blockCount: number): Promise<RewardStats> {
|
|
return await BlocksRepository.$getBlockStats(blockCount);
|
|
}
|
|
|
|
/**
|
|
* Generate weekly mining pool hashrate history
|
|
*/
|
|
public async $generatePoolHashrateHistory(): Promise<void> {
|
|
const now = new Date();
|
|
|
|
// Run only if:
|
|
// * this.lastWeeklyHashrateIndexingDate is set to null (node backend restart, reorg)
|
|
// * we started a new week (around Monday midnight)
|
|
const runIndexing = this.lastWeeklyHashrateIndexingDate === null ||
|
|
now.getUTCDay() === 1 && this.lastWeeklyHashrateIndexingDate !== now.getUTCDate();
|
|
if (!runIndexing) {
|
|
logger.debug(`Pool hashrate history indexing is up to date, nothing to do`, logger.tags.mining);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const oldestConsecutiveBlockTimestamp = 1000 * (await BlocksRepository.$getOldestConsecutiveBlock()).timestamp;
|
|
|
|
const genesisBlock: IEsploraApi.Block = await bitcoinApi.$getBlock(await bitcoinApi.$getBlockHash(0));
|
|
const genesisTimestamp = genesisBlock.timestamp * 1000;
|
|
|
|
const indexedTimestamp = await HashratesRepository.$getWeeklyHashrateTimestamps();
|
|
const hashrates: any[] = [];
|
|
|
|
const lastMonday = new Date(now.setDate(now.getDate() - (now.getDay() + 6) % 7));
|
|
const lastMondayMidnight = this.getDateMidnight(lastMonday);
|
|
let toTimestamp = lastMondayMidnight.getTime();
|
|
|
|
const totalWeekIndexed = (await BlocksRepository.$blockCount(null, null)) / 1008;
|
|
let indexedThisRun = 0;
|
|
let totalIndexed = 0;
|
|
let newlyIndexed = 0;
|
|
const startedAt = new Date().getTime() / 1000;
|
|
let timer = new Date().getTime() / 1000;
|
|
|
|
logger.debug(`Indexing weekly mining pool hashrate`, logger.tags.mining);
|
|
loadingIndicators.setProgress('weekly-hashrate-indexing', 0);
|
|
|
|
while (toTimestamp > genesisTimestamp && toTimestamp > oldestConsecutiveBlockTimestamp) {
|
|
const fromTimestamp = toTimestamp - 604800000;
|
|
|
|
// Skip already indexed weeks
|
|
if (indexedTimestamp.includes(toTimestamp / 1000)) {
|
|
toTimestamp -= 604800000;
|
|
++totalIndexed;
|
|
continue;
|
|
}
|
|
|
|
const blockStats: any = await BlocksRepository.$blockCountBetweenTimestamp(
|
|
null, fromTimestamp / 1000, toTimestamp / 1000);
|
|
const lastBlockHashrate = await bitcoinClient.getNetworkHashPs(blockStats.blockCount,
|
|
blockStats.lastBlockHeight);
|
|
|
|
let pools = await PoolsRepository.$getPoolsInfoBetween(fromTimestamp / 1000, toTimestamp / 1000);
|
|
const totalBlocks = pools.reduce((acc, pool) => acc + pool.blockCount, 0);
|
|
if (totalBlocks > 0) {
|
|
pools = pools.map((pool: any) => {
|
|
pool.hashrate = (pool.blockCount / totalBlocks) * lastBlockHashrate;
|
|
pool.share = (pool.blockCount / totalBlocks);
|
|
return pool;
|
|
});
|
|
|
|
for (const pool of pools) {
|
|
hashrates.push({
|
|
hashrateTimestamp: toTimestamp / 1000,
|
|
avgHashrate: pool['hashrate'] ,
|
|
poolId: pool.poolId,
|
|
share: pool['share'],
|
|
type: 'weekly',
|
|
});
|
|
}
|
|
|
|
newlyIndexed += hashrates.length / Math.max(1, pools.length);
|
|
await HashratesRepository.$saveHashrates(hashrates);
|
|
hashrates.length = 0;
|
|
}
|
|
|
|
const elapsedSeconds = Math.max(1, Math.round((new Date().getTime() / 1000) - timer));
|
|
if (elapsedSeconds > 1) {
|
|
const runningFor = Math.max(1, Math.round((new Date().getTime() / 1000) - startedAt));
|
|
const weeksPerSeconds = Math.max(1, Math.round(indexedThisRun / elapsedSeconds));
|
|
const progress = Math.round(totalIndexed / totalWeekIndexed * 10000) / 100;
|
|
const formattedDate = new Date(fromTimestamp).toUTCString();
|
|
logger.debug(`Getting weekly pool hashrate for ${formattedDate} | ~${weeksPerSeconds.toFixed(2)} weeks/sec | total: ~${totalIndexed}/${Math.round(totalWeekIndexed)} (${progress}%) | elapsed: ${runningFor} seconds`, logger.tags.mining);
|
|
timer = new Date().getTime() / 1000;
|
|
indexedThisRun = 0;
|
|
loadingIndicators.setProgress('weekly-hashrate-indexing', progress, false);
|
|
}
|
|
|
|
toTimestamp -= 604800000;
|
|
++indexedThisRun;
|
|
++totalIndexed;
|
|
}
|
|
this.lastWeeklyHashrateIndexingDate = new Date().getUTCDate();
|
|
if (newlyIndexed > 0) {
|
|
logger.info(`Weekly mining pools hashrates indexing completed: indexed ${newlyIndexed} weeks`, logger.tags.mining);
|
|
} else {
|
|
logger.debug(`Weekly mining pools hashrates indexing completed: indexed ${newlyIndexed} weeks`, logger.tags.mining);
|
|
}
|
|
loadingIndicators.setProgress('weekly-hashrate-indexing', 100);
|
|
} catch (e) {
|
|
loadingIndicators.setProgress('weekly-hashrate-indexing', 100);
|
|
logger.err(`Weekly mining pools hashrates indexing failed. Trying again in 10 seconds. Reason: ${(e instanceof Error ? e.message : e)}`, logger.tags.mining);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate daily hashrate data
|
|
*/
|
|
public async $generateNetworkHashrateHistory(): Promise<void> {
|
|
// If a re-index was requested, truncate first
|
|
if (this.reindexHashrateRequested === true) {
|
|
logger.notice(`hashrates will now be re-indexed`);
|
|
await database.query(`TRUNCATE hashrates`);
|
|
this.lastHashrateIndexingDate = 0;
|
|
this.reindexHashrateRequested = false;
|
|
}
|
|
|
|
// We only run this once a day around midnight
|
|
const today = new Date().getUTCDate();
|
|
if (today === this.lastHashrateIndexingDate) {
|
|
logger.debug(`Network hashrate history indexing is up to date, nothing to do`, logger.tags.mining);
|
|
return;
|
|
}
|
|
|
|
const oldestConsecutiveBlockTimestamp = 1000 * (await BlocksRepository.$getOldestConsecutiveBlock()).timestamp;
|
|
|
|
try {
|
|
const genesisBlock: IEsploraApi.Block = await bitcoinApi.$getBlock(await bitcoinApi.$getBlockHash(0));
|
|
const genesisTimestamp = genesisBlock.timestamp * 1000;
|
|
const indexedTimestamp = (await HashratesRepository.$getRawNetworkDailyHashrate(null)).map(hashrate => hashrate.timestamp);
|
|
const lastMidnight = this.getDateMidnight(new Date());
|
|
let toTimestamp = Math.round(lastMidnight.getTime());
|
|
const hashrates: any[] = [];
|
|
|
|
const totalDayIndexed = (await BlocksRepository.$blockCount(null, null)) / 144;
|
|
let indexedThisRun = 0;
|
|
let totalIndexed = 0;
|
|
let newlyIndexed = 0;
|
|
const startedAt = new Date().getTime() / 1000;
|
|
let timer = new Date().getTime() / 1000;
|
|
|
|
logger.debug(`Indexing daily network hashrate`, logger.tags.mining);
|
|
loadingIndicators.setProgress('daily-hashrate-indexing', 0);
|
|
|
|
while (toTimestamp > genesisTimestamp && toTimestamp > oldestConsecutiveBlockTimestamp) {
|
|
const fromTimestamp = toTimestamp - 86400000;
|
|
|
|
// Skip already indexed days
|
|
if (indexedTimestamp.includes(toTimestamp / 1000)) {
|
|
toTimestamp -= 86400000;
|
|
++totalIndexed;
|
|
continue;
|
|
}
|
|
|
|
const blockStats: any = await BlocksRepository.$blockCountBetweenTimestamp(
|
|
null, fromTimestamp / 1000, toTimestamp / 1000);
|
|
const lastBlockHashrate = blockStats.blockCount === 0 ? 0 : await bitcoinClient.getNetworkHashPs(blockStats.blockCount,
|
|
blockStats.lastBlockHeight);
|
|
|
|
hashrates.push({
|
|
hashrateTimestamp: toTimestamp / 1000,
|
|
avgHashrate: lastBlockHashrate,
|
|
poolId: 0,
|
|
share: 1,
|
|
type: 'daily',
|
|
});
|
|
|
|
if (hashrates.length > 10) {
|
|
newlyIndexed += hashrates.length;
|
|
await HashratesRepository.$saveHashrates(hashrates);
|
|
hashrates.length = 0;
|
|
}
|
|
|
|
const elapsedSeconds = Math.max(1, Math.round((new Date().getTime() / 1000) - timer));
|
|
if (elapsedSeconds > 1) {
|
|
const runningFor = Math.max(1, Math.round((new Date().getTime() / 1000) - startedAt));
|
|
const daysPerSeconds = Math.max(1, Math.round(indexedThisRun / elapsedSeconds));
|
|
const progress = Math.round(totalIndexed / totalDayIndexed * 10000) / 100;
|
|
const formattedDate = new Date(fromTimestamp).toUTCString();
|
|
logger.debug(`Getting network daily hashrate for ${formattedDate} | ~${daysPerSeconds.toFixed(2)} days/sec | total: ~${totalIndexed}/${Math.round(totalDayIndexed)} (${progress}%) | elapsed: ${runningFor} seconds`, logger.tags.mining);
|
|
timer = new Date().getTime() / 1000;
|
|
indexedThisRun = 0;
|
|
loadingIndicators.setProgress('daily-hashrate-indexing', progress);
|
|
}
|
|
|
|
toTimestamp -= 86400000;
|
|
++indexedThisRun;
|
|
++totalIndexed;
|
|
}
|
|
|
|
// Add genesis block manually
|
|
if (config.MEMPOOL.INDEXING_BLOCKS_AMOUNT === -1 && !indexedTimestamp.includes(genesisTimestamp / 1000)) {
|
|
hashrates.push({
|
|
hashrateTimestamp: genesisTimestamp / 1000,
|
|
avgHashrate: await bitcoinClient.getNetworkHashPs(1, 1),
|
|
poolId: 0,
|
|
share: 1,
|
|
type: 'daily',
|
|
});
|
|
}
|
|
|
|
newlyIndexed += hashrates.length;
|
|
await HashratesRepository.$saveHashrates(hashrates);
|
|
|
|
this.lastHashrateIndexingDate = new Date().getUTCDate();
|
|
if (newlyIndexed > 0) {
|
|
logger.info(`Daily network hashrate indexing completed: indexed ${newlyIndexed} days`, logger.tags.mining);
|
|
} else {
|
|
logger.debug(`Daily network hashrate indexing completed: indexed ${newlyIndexed} days`, logger.tags.mining);
|
|
}
|
|
loadingIndicators.setProgress('daily-hashrate-indexing', 100);
|
|
} catch (e) {
|
|
loadingIndicators.setProgress('daily-hashrate-indexing', 100);
|
|
logger.err(`Daily network hashrate indexing failed. Trying again later. Reason: ${(e instanceof Error ? e.message : e)}`, logger.tags.mining);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Index difficulty adjustments
|
|
*/
|
|
public async $indexDifficultyAdjustments(): Promise<void> {
|
|
// If a re-index was requested, truncate first
|
|
if (this.reindexDifficultyAdjustmentRequested === true) {
|
|
logger.notice(`difficulty_adjustments will now be re-indexed`);
|
|
await database.query(`TRUNCATE difficulty_adjustments`);
|
|
this.reindexDifficultyAdjustmentRequested = false;
|
|
}
|
|
|
|
const indexedHeightsArray = await DifficultyAdjustmentsRepository.$getAdjustmentsHeights();
|
|
const indexedHeights = {};
|
|
for (const height of indexedHeightsArray) {
|
|
indexedHeights[height] = true;
|
|
}
|
|
|
|
// gets {time, height, difficulty, bits} of blocks in ascending order of height
|
|
const blocks: any = await BlocksRepository.$getBlocksDifficulty();
|
|
const genesisBlock: IEsploraApi.Block = await bitcoinApi.$getBlock(await bitcoinApi.$getBlockHash(0));
|
|
let currentDifficulty = genesisBlock.difficulty;
|
|
let currentBits = genesisBlock.bits;
|
|
let totalIndexed = 0;
|
|
|
|
if (config.MEMPOOL.INDEXING_BLOCKS_AMOUNT === -1 && indexedHeights[0] !== true) {
|
|
await DifficultyAdjustmentsRepository.$saveAdjustments({
|
|
time: genesisBlock.timestamp,
|
|
height: 0,
|
|
difficulty: currentDifficulty,
|
|
adjustment: 0.0,
|
|
});
|
|
}
|
|
|
|
if (!blocks?.length) {
|
|
// no blocks in database yet
|
|
return;
|
|
}
|
|
|
|
const oldestConsecutiveBlock = this.getOldestConsecutiveBlock(blocks);
|
|
|
|
currentBits = oldestConsecutiveBlock.bits;
|
|
currentDifficulty = oldestConsecutiveBlock.difficulty;
|
|
|
|
let totalBlockChecked = 0;
|
|
let timer = new Date().getTime() / 1000;
|
|
|
|
for (const block of blocks) {
|
|
// skip until the first block after the oldest consecutive block
|
|
if (block.height <= oldestConsecutiveBlock.height) {
|
|
continue;
|
|
}
|
|
|
|
// difficulty has changed between two consecutive blocks!
|
|
if (block.bits !== currentBits) {
|
|
// skip if already indexed
|
|
if (indexedHeights[block.height] !== true) {
|
|
let adjustment = block.difficulty / currentDifficulty;
|
|
adjustment = Math.round(adjustment * 1000000) / 1000000; // Remove float point noise
|
|
|
|
await DifficultyAdjustmentsRepository.$saveAdjustments({
|
|
time: block.time,
|
|
height: block.height,
|
|
difficulty: block.difficulty,
|
|
adjustment: adjustment,
|
|
});
|
|
|
|
totalIndexed++;
|
|
}
|
|
// update the current difficulty
|
|
currentDifficulty = block.difficulty;
|
|
currentBits = block.bits;
|
|
}
|
|
|
|
totalBlockChecked++;
|
|
const elapsedSeconds = Math.max(1, Math.round((new Date().getTime() / 1000) - timer));
|
|
if (elapsedSeconds > 5) {
|
|
const progress = Math.round(totalBlockChecked / blocks.length * 100);
|
|
logger.debug(`Indexing difficulty adjustment at block #${block.height} | Progress: ${progress}%`, logger.tags.mining);
|
|
timer = new Date().getTime() / 1000;
|
|
}
|
|
}
|
|
|
|
if (totalIndexed > 0) {
|
|
logger.info(`Indexed ${totalIndexed} difficulty adjustments`, logger.tags.mining);
|
|
} else {
|
|
logger.debug(`Indexed ${totalIndexed} difficulty adjustments`, logger.tags.mining);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a link between blocks and the latest price at when they were mined
|
|
*/
|
|
public async $indexBlockPrices(): Promise<void> {
|
|
if (this.blocksPriceIndexingRunning === true) {
|
|
return;
|
|
}
|
|
this.blocksPriceIndexingRunning = true;
|
|
|
|
let totalInserted = 0;
|
|
try {
|
|
const prices: any[] = await PricesRepository.$getPricesTimesAndId();
|
|
const blocksWithoutPrices: any[] = await BlocksRepository.$getBlocksWithoutPrice();
|
|
|
|
const blocksPrices: BlockPrice[] = [];
|
|
|
|
for (const block of blocksWithoutPrices) {
|
|
// Quick optimisation, out mtgox feed only goes back to 2010-07-19 02:00:00, so skip the first 68951 blocks
|
|
if (['mainnet', 'testnet'].includes(config.MEMPOOL.NETWORK) && block.height < 68951) {
|
|
blocksPrices.push({
|
|
height: block.height,
|
|
priceId: prices[0].id,
|
|
});
|
|
continue;
|
|
}
|
|
for (const price of prices) {
|
|
if (block.timestamp < price.time) {
|
|
blocksPrices.push({
|
|
height: block.height,
|
|
priceId: price.id,
|
|
});
|
|
break;
|
|
};
|
|
}
|
|
|
|
if (blocksPrices.length >= 100000) {
|
|
totalInserted += blocksPrices.length;
|
|
let logStr = `Linking ${blocksPrices.length} blocks to their closest price`;
|
|
if (blocksWithoutPrices.length > 200000) {
|
|
logStr += ` | Progress ${Math.round(totalInserted / blocksWithoutPrices.length * 100)}%`;
|
|
}
|
|
logger.debug(logStr, logger.tags.mining);
|
|
await BlocksRepository.$saveBlockPrices(blocksPrices);
|
|
blocksPrices.length = 0;
|
|
}
|
|
}
|
|
|
|
if (blocksPrices.length > 0) {
|
|
totalInserted += blocksPrices.length;
|
|
let logStr = `Linking ${blocksPrices.length} blocks to their closest price`;
|
|
if (blocksWithoutPrices.length > 200000) {
|
|
logStr += ` | Progress ${Math.round(totalInserted / blocksWithoutPrices.length * 100)}%`;
|
|
}
|
|
logger.debug(logStr, logger.tags.mining);
|
|
await BlocksRepository.$saveBlockPrices(blocksPrices);
|
|
}
|
|
} catch (e) {
|
|
this.blocksPriceIndexingRunning = false;
|
|
logger.err(`Cannot index block prices. ${e}`);
|
|
}
|
|
|
|
if (totalInserted > 0) {
|
|
logger.info(`Indexing blocks prices completed. Indexed ${totalInserted}`, logger.tags.mining);
|
|
} else {
|
|
logger.debug(`Indexing blocks prices completed. Indexed 0.`, logger.tags.mining);
|
|
}
|
|
|
|
this.blocksPriceIndexingRunning = false;
|
|
}
|
|
|
|
/**
|
|
* Index core coinstatsindex
|
|
*/
|
|
public async $indexCoinStatsIndex(): Promise<void> {
|
|
let timer = new Date().getTime() / 1000;
|
|
let totalIndexed = 0;
|
|
|
|
const blockchainInfo = await bitcoinClient.getBlockchainInfo();
|
|
let currentBlockHeight = blockchainInfo.blocks;
|
|
|
|
while (currentBlockHeight > 0) {
|
|
const indexedBlocks = await BlocksRepository.$getBlocksMissingCoinStatsIndex(
|
|
currentBlockHeight, currentBlockHeight - 10000);
|
|
|
|
for (const block of indexedBlocks) {
|
|
const txoutset = await bitcoinClient.getTxoutSetinfo('none', block.height);
|
|
await BlocksRepository.$updateCoinStatsIndexData(block.hash, txoutset.txouts,
|
|
Math.round(txoutset.block_info.prevout_spent * 100000000));
|
|
++totalIndexed;
|
|
|
|
const elapsedSeconds = Math.max(1, new Date().getTime() / 1000 - timer);
|
|
if (elapsedSeconds > 5) {
|
|
logger.info(`Indexing coinstatsindex data for block #${block.height}. Indexed ${totalIndexed} blocks.`, logger.tags.mining);
|
|
timer = new Date().getTime() / 1000;
|
|
}
|
|
}
|
|
|
|
currentBlockHeight -= 10000;
|
|
}
|
|
|
|
if (totalIndexed > 0) {
|
|
logger.info(`Indexing missing coinstatsindex data completed. Indexed ${totalIndexed}`, logger.tags.mining);
|
|
} else {
|
|
logger.debug(`Indexing missing coinstatsindex data completed. Indexed 0.`, logger.tags.mining);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* List existing mining pools
|
|
*/
|
|
public async $listPools(): Promise<{name: string, slug: string, unique_id: number}[] | null> {
|
|
const [rows] = await database.query(`
|
|
SELECT
|
|
name,
|
|
slug,
|
|
unique_id
|
|
FROM pools`
|
|
);
|
|
return rows as {name: string, slug: string, unique_id: number}[];
|
|
}
|
|
|
|
private getDateMidnight(date: Date): Date {
|
|
date.setUTCHours(0);
|
|
date.setUTCMinutes(0);
|
|
date.setUTCSeconds(0);
|
|
date.setUTCMilliseconds(0);
|
|
|
|
return date;
|
|
}
|
|
|
|
private getTimeRange(interval: string | null, scale = 1): number {
|
|
switch (interval) {
|
|
case '4y': return 43200 * scale; // 12h
|
|
case '3y': return 43200 * scale; // 12h
|
|
case '2y': return 28800 * scale; // 8h
|
|
case '1y': return 28800 * scale; // 8h
|
|
case '6m': return 10800 * scale; // 3h
|
|
case '3m': return 7200 * scale; // 2h
|
|
case '1m': return 1800 * scale; // 30min
|
|
case '1w': return 300 * scale; // 5min
|
|
case '3d': return 1 * scale;
|
|
case '24h': return 1 * scale;
|
|
default: return 86400 * scale;
|
|
}
|
|
}
|
|
|
|
private getTimeRangeFromTimespan(from: number, to: number, scale = 1): number {
|
|
const timespan = to - from;
|
|
switch (true) {
|
|
case timespan > 3600 * 24 * 365 * 4: return 86400 * scale; // 24h
|
|
case timespan > 3600 * 24 * 365 * 3: return 43200 * scale; // 12h
|
|
case timespan > 3600 * 24 * 365 * 2: return 43200 * scale; // 12h
|
|
case timespan > 3600 * 24 * 365: return 28800 * scale; // 8h
|
|
case timespan > 3600 * 24 * 30 * 6: return 28800 * scale; // 8h
|
|
case timespan > 3600 * 24 * 30 * 3: return 10800 * scale; // 3h
|
|
case timespan > 3600 * 24 * 30: return 7200 * scale; // 2h
|
|
case timespan > 3600 * 24 * 7: return 1800 * scale; // 30min
|
|
case timespan > 3600 * 24 * 3: return 300 * scale; // 5min
|
|
case timespan > 3600 * 24: return 1 * scale;
|
|
default: return 1 * scale;
|
|
}
|
|
}
|
|
|
|
|
|
// Finds the oldest block in a consecutive chain back from the tip
|
|
// assumes `blocks` is sorted in ascending height order
|
|
private getOldestConsecutiveBlock(blocks: DifficultyBlock[]): DifficultyBlock {
|
|
for (let i = blocks.length - 1; i > 0; i--) {
|
|
if ((blocks[i].height - blocks[i - 1].height) > 1) {
|
|
return blocks[i];
|
|
}
|
|
}
|
|
return blocks[0];
|
|
}
|
|
}
|
|
|
|
export default new Mining();
|