391 lines
14 KiB
TypeScript
391 lines
14 KiB
TypeScript
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Inject, Input, LOCALE_ID, NgZone, OnInit } from '@angular/core';
|
|
import { echarts, EChartsOption } from '@app/graphs/echarts';
|
|
import { Observable, combineLatest, of } from 'rxjs';
|
|
import { map, share, startWith, switchMap, tap } from 'rxjs/operators';
|
|
import { ApiService } from '@app/services/api.service';
|
|
import { SeoService } from '@app/services/seo.service';
|
|
import { formatNumber } from '@angular/common';
|
|
import { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
|
|
import { download, formatterXAxis, formatterXAxisLabel, formatterXAxisTimeCategory } from '@app/shared/graphs.utils';
|
|
import { StorageService } from '@app/services/storage.service';
|
|
import { MiningService } from '@app/services/mining.service';
|
|
import { selectPowerOfTen } from '@app/bitcoin.utils';
|
|
import { RelativeUrlPipe } from '@app/shared/pipes/relative-url/relative-url.pipe';
|
|
import { StateService } from '@app/services/state.service';
|
|
import { ActivatedRoute, Router } from '@angular/router';
|
|
|
|
@Component({
|
|
selector: 'app-block-fee-rates-graph',
|
|
templateUrl: './block-fee-rates-graph.component.html',
|
|
styleUrls: ['./block-fee-rates-graph.component.scss'],
|
|
styles: [`
|
|
.loadingGraphs {
|
|
position: absolute;
|
|
top: 50%;
|
|
left: calc(50% - 15px);
|
|
z-index: 99;
|
|
}
|
|
`],
|
|
changeDetection: ChangeDetectionStrategy.OnPush,
|
|
})
|
|
export class BlockFeeRatesGraphComponent implements OnInit {
|
|
@Input() widget = false;
|
|
@Input() right: number | string = 45;
|
|
@Input() left: number | string = 75;
|
|
|
|
miningWindowPreference: string;
|
|
radioGroupForm: UntypedFormGroup;
|
|
|
|
chartOptions: EChartsOption = {};
|
|
chartInitOptions = {
|
|
renderer: 'svg',
|
|
};
|
|
|
|
hrStatsObservable$: Observable<any>;
|
|
statsObservable$: Observable<any>;
|
|
isLoading = true;
|
|
formatNumber = formatNumber;
|
|
timespan = '';
|
|
chartInstance: any = undefined;
|
|
|
|
constructor(
|
|
@Inject(LOCALE_ID) public locale: string,
|
|
private seoService: SeoService,
|
|
private apiService: ApiService,
|
|
private formBuilder: UntypedFormBuilder,
|
|
private storageService: StorageService,
|
|
private miningService: MiningService,
|
|
public stateService: StateService,
|
|
private router: Router,
|
|
private zone: NgZone,
|
|
private route: ActivatedRoute,
|
|
private cd: ChangeDetectorRef,
|
|
) {
|
|
this.radioGroupForm = this.formBuilder.group({ dateSpan: '1y' });
|
|
this.radioGroupForm.controls.dateSpan.setValue('1y');
|
|
}
|
|
|
|
ngOnInit(): void {
|
|
if (this.widget) {
|
|
this.miningWindowPreference = '1m';
|
|
} else {
|
|
this.seoService.setTitle($localize`:@@ed8e33059967f554ff06b4f5b6049c465b92d9b3:Block Fee Rates`);
|
|
this.seoService.setDescription($localize`:@@meta.description.bitcoin.graphs.block-fee-rates:See Bitcoin feerates visualized over time, including minimum and maximum feerates per block along with feerates at various percentiles.`);
|
|
this.miningWindowPreference = this.miningService.getDefaultTimespan('24h');
|
|
}
|
|
this.radioGroupForm = this.formBuilder.group({ dateSpan: this.miningWindowPreference });
|
|
this.radioGroupForm.controls.dateSpan.setValue(this.miningWindowPreference);
|
|
|
|
if (!this.widget) {
|
|
this.route
|
|
.fragment
|
|
.subscribe((fragment) => {
|
|
if (['24h', '3d', '1w', '1m', '3m', '6m', '1y', '2y', '3y', 'all'].indexOf(fragment) > -1) {
|
|
this.radioGroupForm.controls.dateSpan.setValue(fragment, { emitEvent: false });
|
|
}
|
|
});
|
|
}
|
|
|
|
this.hrStatsObservable$ = combineLatest([
|
|
this.apiService.getHistoricalBlockFeeRates$('24h'),
|
|
this.stateService.rateUnits$
|
|
]).pipe(
|
|
map(([response, rateUnits]) => {
|
|
return {
|
|
blockCount: parseInt(response.headers.get('x-total-count'), 10),
|
|
avgMedianRate: response.body.length ? response.body.reduce((acc, rate) => acc + rate.avgFee_50, 0) / response.body.length : 0,
|
|
};
|
|
}),
|
|
share(),
|
|
);
|
|
|
|
this.statsObservable$ = combineLatest([
|
|
this.widget ? of(this.miningWindowPreference) : this.radioGroupForm.get('dateSpan').valueChanges.pipe(startWith(this.radioGroupForm.controls.dateSpan.value)),
|
|
this.stateService.rateUnits$
|
|
]).pipe(
|
|
switchMap(([timespan, rateUnits]) => {
|
|
if (!this.widget) {
|
|
this.storageService.setValue('miningWindowPreference', timespan);
|
|
}
|
|
this.timespan = timespan;
|
|
this.isLoading = true;
|
|
return this.apiService.getHistoricalBlockFeeRates$(timespan)
|
|
.pipe(
|
|
tap((response) => {
|
|
// Group by percentile
|
|
const seriesData = this.widget ? { 'Median': [] } : {
|
|
'Min': [],
|
|
'10th': [],
|
|
'25th': [],
|
|
'Median': [],
|
|
'75th': [],
|
|
'90th': [],
|
|
'Max': []
|
|
};
|
|
for (const rate of response.body) {
|
|
const timestamp = rate.timestamp * 1000;
|
|
if (this.widget) {
|
|
seriesData['Median'].push([timestamp, rate.avgFee_50, rate.avgHeight]);
|
|
} else {
|
|
seriesData['Min'].push([timestamp, rate.avgFee_0, rate.avgHeight]);
|
|
seriesData['10th'].push([timestamp, rate.avgFee_10, rate.avgHeight]);
|
|
seriesData['25th'].push([timestamp, rate.avgFee_25, rate.avgHeight]);
|
|
seriesData['Median'].push([timestamp, rate.avgFee_50, rate.avgHeight]);
|
|
seriesData['75th'].push([timestamp, rate.avgFee_75, rate.avgHeight]);
|
|
seriesData['90th'].push([timestamp, rate.avgFee_90, rate.avgHeight]);
|
|
seriesData['Max'].push([timestamp, rate.avgFee_100, rate.avgHeight]);
|
|
}
|
|
}
|
|
|
|
// Prepare chart
|
|
const series = [];
|
|
const legends = [];
|
|
for (const percentile in seriesData) {
|
|
series.push({
|
|
zlevel: 0,
|
|
stack: 'Total',
|
|
name: percentile,
|
|
data: seriesData[percentile],
|
|
type: 'bar',
|
|
barWidth: '100%',
|
|
large: true,
|
|
});
|
|
|
|
legends.push({
|
|
name: percentile,
|
|
inactiveColor: 'rgb(110, 112, 121)',
|
|
textStyle: {
|
|
color: 'white',
|
|
},
|
|
icon: 'roundRect',
|
|
enabled: false,
|
|
selected: false,
|
|
});
|
|
}
|
|
|
|
if (this.widget) {
|
|
let maResolution = 30;
|
|
const medianMa = [];
|
|
for (let i = maResolution - 1; i < seriesData['Median'].length; ++i) {
|
|
let avg = 0;
|
|
for (let y = maResolution - 1; y >= 0; --y) {
|
|
avg += seriesData['Median'][i - y][1];
|
|
}
|
|
avg /= maResolution;
|
|
medianMa.push([seriesData['Median'][i][0], avg, seriesData['Median'][i][2]]);
|
|
}
|
|
series.push({
|
|
zlevel: 1,
|
|
name: 'Moving average',
|
|
data: medianMa,
|
|
type: 'line',
|
|
showSymbol: false,
|
|
symbol: 'none',
|
|
lineStyle: {
|
|
width: 3,
|
|
}
|
|
});
|
|
}
|
|
|
|
this.prepareChartOptions({
|
|
legends: legends,
|
|
series: series
|
|
}, rateUnits === 'wu');
|
|
|
|
this.isLoading = false;
|
|
this.cd.markForCheck();
|
|
}),
|
|
map((response) => {
|
|
return {
|
|
blockCount: parseInt(response.headers.get('x-total-count'), 10),
|
|
avgMedianRate: response.body.length ? response.body.reduce((acc, rate) => acc + rate.avgFee_50, 0) / response.body.length : 0,
|
|
};
|
|
}),
|
|
);
|
|
}),
|
|
share()
|
|
);
|
|
}
|
|
|
|
prepareChartOptions(data, weightMode) {
|
|
this.chartOptions = {
|
|
color: this.widget ? ['#6b6b6b', new echarts.graphic.LinearGradient(0, 0, 0, 0.65, [
|
|
{ offset: 0, color: '#F4511E' },
|
|
{ offset: 0.25, color: '#FB8C00' },
|
|
{ offset: 0.5, color: '#FFB300' },
|
|
{ offset: 0.75, color: '#FDD835' },
|
|
{ offset: 1, color: '#7CB342' }
|
|
])] : ['#D81B60', '#8E24AA', '#1E88E5', '#7CB342', '#FDD835', '#6D4C41', '#546E7A'],
|
|
animation: false,
|
|
grid: {
|
|
right: this.right,
|
|
left: this.left,
|
|
bottom: this.widget ? 30 : 80,
|
|
top: this.widget ? 20 : (this.isMobile() ? 10 : 50),
|
|
},
|
|
tooltip: {
|
|
show: !this.isMobile(),
|
|
trigger: 'axis',
|
|
axisPointer: {
|
|
type: 'line'
|
|
},
|
|
backgroundColor: 'rgba(17, 19, 31, 1)',
|
|
borderRadius: 4,
|
|
shadowColor: 'rgba(0, 0, 0, 0.5)',
|
|
textStyle: {
|
|
color: 'var(--tooltip-grey)',
|
|
align: 'left',
|
|
},
|
|
borderColor: '#000',
|
|
formatter: function(data) {
|
|
if (data.length <= 0) {
|
|
return '';
|
|
}
|
|
let tooltip = `<b style="color: white; margin-left: 2px">${formatterXAxis(this.locale, this.timespan, parseInt(data[0].axisValue, 10))}</b><br>`;
|
|
|
|
for (const rate of data.reverse()) {
|
|
if (weightMode) {
|
|
tooltip += `${rate.marker} ${rate.seriesName}: ${(rate.data[1] / 4).toFixed(2)} sats/WU<br>`;
|
|
} else {
|
|
tooltip += `${rate.marker} ${rate.seriesName}: ${rate.data[1].toFixed(2)} sats/vByte<br>`;
|
|
}
|
|
}
|
|
|
|
if (['24h', '3d'].includes(this.timespan)) {
|
|
tooltip += `<small>` + $localize`At block: ${data[0].data[2]}` + `</small>`;
|
|
} else {
|
|
tooltip += `<small>` + $localize`Around block: ${data[0].data[2]}` + `</small>`;
|
|
}
|
|
|
|
return tooltip;
|
|
}.bind(this)
|
|
},
|
|
xAxis: data.series.length === 0 ? undefined :
|
|
{
|
|
name: this.widget ? undefined : formatterXAxisLabel(this.locale, this.timespan),
|
|
nameLocation: 'middle',
|
|
nameTextStyle: {
|
|
padding: [10, 0, 0, 0],
|
|
},
|
|
type: 'category',
|
|
boundaryGap: false,
|
|
axisLine: { onZero: true },
|
|
axisLabel: {
|
|
formatter: val => formatterXAxisTimeCategory(this.locale, this.timespan, parseInt(val, 10)),
|
|
align: 'center',
|
|
fontSize: 11,
|
|
lineHeight: 12,
|
|
hideOverlap: true,
|
|
padding: [0, 5],
|
|
},
|
|
},
|
|
legend: (this.widget || data.series.length === 0) ? undefined : {
|
|
padding: [10, 75],
|
|
data: data.legends,
|
|
selected: JSON.parse(this.storageService.getValue('fee_rates_legend') || 'null') ?? {
|
|
'Min': true,
|
|
'10th': true,
|
|
'25th': true,
|
|
'Median': true,
|
|
'75th': true,
|
|
'90th': true,
|
|
'Max': false,
|
|
},
|
|
id: 4242,
|
|
},
|
|
yAxis: data.series.length === 0 ? undefined : {
|
|
position: 'left',
|
|
axisLabel: {
|
|
color: 'rgb(110, 112, 121)',
|
|
formatter: (val) => {
|
|
if (weightMode) {
|
|
val /= 4;
|
|
}
|
|
const selectedPowerOfTen: any = selectPowerOfTen(val);
|
|
const newVal = Math.round(val / selectedPowerOfTen.divider);
|
|
return `${newVal}${selectedPowerOfTen.unit} s/${weightMode ? 'WU': 'vB'}`;
|
|
},
|
|
},
|
|
splitLine: {
|
|
lineStyle: {
|
|
type: 'dotted',
|
|
color: 'var(--transparent-fg)',
|
|
opacity: 0.25,
|
|
}
|
|
},
|
|
type: 'value',
|
|
max: (val) => this.timespan === 'all' ? Math.min(val.max, 5000) : undefined,
|
|
},
|
|
series: data.series,
|
|
dataZoom: this.widget ? null : [{
|
|
type: 'inside',
|
|
realtime: true,
|
|
zoomLock: true,
|
|
maxSpan: 100,
|
|
minSpan: 5,
|
|
moveOnMouseMove: false,
|
|
}, {
|
|
showDetail: false,
|
|
show: true,
|
|
type: 'slider',
|
|
brushSelect: false,
|
|
realtime: true,
|
|
left: 20,
|
|
right: 15,
|
|
selectedDataBackground: {
|
|
lineStyle: {
|
|
color: '#fff',
|
|
opacity: 0.45,
|
|
},
|
|
areaStyle: {
|
|
opacity: 0,
|
|
}
|
|
},
|
|
}],
|
|
};
|
|
}
|
|
|
|
onChartInit(ec) {
|
|
if (this.chartInstance !== undefined) {
|
|
return;
|
|
}
|
|
|
|
this.chartInstance = ec;
|
|
|
|
this.chartInstance.on('click', (e) => {
|
|
this.zone.run(() => {
|
|
if (['24h', '3d'].includes(this.timespan)) {
|
|
const url = new RelativeUrlPipe(this.stateService).transform(`/block/${e.data[2]}`);
|
|
this.router.navigate([url]);
|
|
}
|
|
});
|
|
});
|
|
|
|
this.chartInstance.on('legendselectchanged', (e) => {
|
|
this.storageService.setValue('fee_rates_legend', JSON.stringify(e.selected));
|
|
});
|
|
}
|
|
|
|
isMobile() {
|
|
return (window.innerWidth <= 767.98);
|
|
}
|
|
|
|
onSaveChart() {
|
|
// @ts-ignore
|
|
const prevBottom = this.chartOptions.grid.bottom;
|
|
const now = new Date();
|
|
// @ts-ignore
|
|
this.chartOptions.grid.bottom = 40;
|
|
this.chartOptions.backgroundColor = 'var(--active-bg)';
|
|
this.chartInstance.setOption(this.chartOptions);
|
|
download(this.chartInstance.getDataURL({
|
|
pixelRatio: 2,
|
|
excludeComponents: ['dataZoom'],
|
|
}), `block-fee-rates-${this.timespan}-${Math.round(now.getTime() / 1000)}.svg`);
|
|
// @ts-ignore
|
|
this.chartOptions.grid.bottom = prevBottom;
|
|
this.chartOptions.backgroundColor = 'none';
|
|
this.chartInstance.setOption(this.chartOptions);
|
|
}
|
|
}
|