mirror of
https://github.com/bitcoinresearchkit/brk.git
synced 2026-04-25 07:09:59 -07:00
895 lines
24 KiB
JavaScript
895 lines
24 KiB
JavaScript
/**
|
|
* Activity section builders
|
|
*
|
|
* Structure:
|
|
* - Volume: Sent volume (Sum, Cumulative, 14d EMA)
|
|
* - SOPR: Spent Output Profit Ratio (30d > 7d > raw)
|
|
* - Sell Side Risk: Risk ratio
|
|
* - Value: Flows, Created & Destroyed, Breakdown
|
|
* - Coins Destroyed: Coinblocks/Coindays (Sum, Cumulative)
|
|
*
|
|
* For cohorts WITH adjusted values: Additional Normal/Adjusted sub-sections
|
|
*/
|
|
|
|
import { Unit } from "../../utils/units.js";
|
|
import { line, baseline, dotsBaseline, dots } from "../series.js";
|
|
import { satsBtcUsd, mapCohortsWithAll, flatMapCohortsWithAll } from "../shared.js";
|
|
import { colors } from "../../utils/colors.js";
|
|
|
|
// ============================================================================
|
|
// Shared Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Create SOPR series from realized pattern (30d > 7d > raw order)
|
|
* @param {{ sopr: AnyMetricPattern, sopr7dEma: AnyMetricPattern, sopr30dEma: AnyMetricPattern }} realized
|
|
* @param {string} rawName - Name for the raw SOPR series
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function soprSeries(realized, rawName = "SOPR") {
|
|
return [
|
|
baseline({
|
|
metric: realized.sopr30dEma,
|
|
name: "30d EMA",
|
|
color: colors.bi.p3,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
baseline({
|
|
metric: realized.sopr7dEma,
|
|
name: "7d EMA",
|
|
color: colors.bi.p2,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
dotsBaseline({
|
|
metric: realized.sopr,
|
|
name: rawName,
|
|
color: colors.bi.p1,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create grouped SOPR chart entries (Raw, 7d EMA, 30d EMA)
|
|
* @template {{ color: Color, name: string }} T
|
|
* @param {readonly T[]} list
|
|
* @param {T} all
|
|
* @param {(item: T) => AnyMetricPattern} getSopr
|
|
* @param {(item: T) => AnyMetricPattern} getSopr7d
|
|
* @param {(item: T) => AnyMetricPattern} getSopr30d
|
|
* @param {(metric: string) => string} title
|
|
* @param {string} titlePrefix
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function groupedSoprCharts(
|
|
list,
|
|
all,
|
|
getSopr,
|
|
getSopr7d,
|
|
getSopr30d,
|
|
title,
|
|
titlePrefix,
|
|
) {
|
|
return [
|
|
{
|
|
name: "Raw",
|
|
title: title(`${titlePrefix}SOPR`),
|
|
bottom: mapCohortsWithAll(list, all, (item) =>
|
|
baseline({
|
|
metric: getSopr(item),
|
|
name: item.name,
|
|
color: item.color,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "7d EMA",
|
|
title: title(`${titlePrefix}SOPR 7d EMA`),
|
|
bottom: mapCohortsWithAll(list, all, (item) =>
|
|
baseline({
|
|
metric: getSopr7d(item),
|
|
name: item.name,
|
|
color: item.color,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "30d EMA",
|
|
title: title(`${titlePrefix}SOPR 30d EMA`),
|
|
bottom: mapCohortsWithAll(list, all, (item) =>
|
|
baseline({
|
|
metric: getSopr30d(item),
|
|
name: item.name,
|
|
color: item.color,
|
|
unit: Unit.ratio,
|
|
base: 1,
|
|
}),
|
|
),
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create value breakdown tree (Profit/Loss Created/Destroyed)
|
|
* @template {{ color: Color, name: string, tree: { realized: AnyRealizedPattern } }} T
|
|
* @param {readonly T[]} list
|
|
* @param {T} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function valueBreakdownTree(list, all, title) {
|
|
return [
|
|
{
|
|
name: "Profit",
|
|
tree: [
|
|
{
|
|
name: "Created",
|
|
title: title("Profit Value Created"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.profitValueCreated,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Destroyed",
|
|
title: title("Profit Value Destroyed"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.profitValueDestroyed,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: "Loss",
|
|
tree: [
|
|
{
|
|
name: "Created",
|
|
title: title("Loss Value Created"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.lossValueCreated,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Destroyed",
|
|
title: title("Loss Value Destroyed"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.lossValueDestroyed,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create coins destroyed tree (Sum/Cumulative with Coinblocks/Coindays)
|
|
* @template {{ color: Color, name: string, tree: { activity: { coinblocksDestroyed: CountPattern<any>, coindaysDestroyed: CountPattern<any> } } }} T
|
|
* @param {readonly T[]} list
|
|
* @param {T} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function coinsDestroyedTree(list, all, title) {
|
|
return [
|
|
{
|
|
name: "Sum",
|
|
title: title("Coins Destroyed"),
|
|
bottom: flatMapCohortsWithAll(list, all, ({ name, color, tree }) => [
|
|
line({
|
|
metric: tree.activity.coinblocksDestroyed.sum,
|
|
name,
|
|
color,
|
|
unit: Unit.coinblocks,
|
|
}),
|
|
line({
|
|
metric: tree.activity.coindaysDestroyed.sum,
|
|
name,
|
|
color,
|
|
unit: Unit.coindays,
|
|
}),
|
|
]),
|
|
},
|
|
{
|
|
name: "Cumulative",
|
|
title: title("Cumulative Coins Destroyed"),
|
|
bottom: flatMapCohortsWithAll(list, all, ({ name, color, tree }) => [
|
|
line({
|
|
metric: tree.activity.coinblocksDestroyed.cumulative,
|
|
name,
|
|
color,
|
|
unit: Unit.coinblocks,
|
|
}),
|
|
line({
|
|
metric: tree.activity.coindaysDestroyed.cumulative,
|
|
name,
|
|
color,
|
|
unit: Unit.coindays,
|
|
}),
|
|
]),
|
|
},
|
|
];
|
|
}
|
|
|
|
// ============================================================================
|
|
// SOPR Helpers
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Create SOPR series for single cohort (30d > 7d > raw order)
|
|
* @param {UtxoCohortObject | CohortWithoutRelative} cohort
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function createSingleSoprSeries(cohort) {
|
|
return soprSeries(cohort.tree.realized);
|
|
}
|
|
|
|
/**
|
|
* Create SOPR tree with normal and adjusted sub-sections
|
|
* @param {CohortAll | CohortFull | CohortWithAdjusted} cohort
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function createSingleSoprTreeWithAdjusted(cohort, title) {
|
|
const { realized } = cohort.tree;
|
|
return [
|
|
{
|
|
name: "Normal",
|
|
title: title("SOPR"),
|
|
bottom: soprSeries(realized),
|
|
},
|
|
{
|
|
name: "Adjusted",
|
|
title: title("Adjusted SOPR"),
|
|
bottom: soprSeries(
|
|
{
|
|
sopr: realized.adjustedSopr,
|
|
sopr7dEma: realized.adjustedSopr7dEma,
|
|
sopr30dEma: realized.adjustedSopr30dEma,
|
|
},
|
|
"Adjusted SOPR",
|
|
),
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create grouped SOPR tree with separate charts for each variant
|
|
* @param {readonly (UtxoCohortObject | CohortWithoutRelative)[]} list
|
|
* @param {CohortAll} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function createGroupedSoprTree(list, all, title) {
|
|
return groupedSoprCharts(
|
|
list,
|
|
all,
|
|
(c) => c.tree.realized.sopr,
|
|
(c) => c.tree.realized.sopr7dEma,
|
|
(c) => c.tree.realized.sopr30dEma,
|
|
title,
|
|
"",
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Create grouped SOPR tree with Normal and Adjusted sub-sections
|
|
* @param {readonly (CohortAll | CohortFull | CohortWithAdjusted)[]} list
|
|
* @param {CohortAll | CohortFull | CohortWithAdjusted} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function createGroupedSoprTreeWithAdjusted(list, all, title) {
|
|
return [
|
|
{
|
|
name: "Normal",
|
|
tree: groupedSoprCharts(
|
|
list,
|
|
all,
|
|
(c) => c.tree.realized.sopr,
|
|
(c) => c.tree.realized.sopr7dEma,
|
|
(c) => c.tree.realized.sopr30dEma,
|
|
title,
|
|
"",
|
|
),
|
|
},
|
|
{
|
|
name: "Adjusted",
|
|
tree: groupedSoprCharts(
|
|
list,
|
|
all,
|
|
(c) => c.tree.realized.adjustedSopr,
|
|
(c) => c.tree.realized.adjustedSopr7dEma,
|
|
(c) => c.tree.realized.adjustedSopr30dEma,
|
|
title,
|
|
"Adjusted ",
|
|
),
|
|
},
|
|
];
|
|
}
|
|
|
|
// ============================================================================
|
|
// Single Cohort Activity Section
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Base activity section builder for single cohorts
|
|
* @param {Object} args
|
|
* @param {UtxoCohortObject | CohortWithoutRelative} args.cohort
|
|
* @param {(metric: string) => string} args.title
|
|
* @param {AnyFetchedSeriesBlueprint[]} [args.valueMetrics] - Optional additional value metrics
|
|
* @param {PartialOptionsTree} [args.soprTree] - Optional SOPR tree override
|
|
* @returns {PartialOptionsGroup}
|
|
*/
|
|
export function createActivitySection({
|
|
cohort,
|
|
title,
|
|
valueMetrics = [],
|
|
soprTree,
|
|
}) {
|
|
const { tree, color } = cohort;
|
|
|
|
return {
|
|
name: "Activity",
|
|
tree: [
|
|
{
|
|
name: "Volume",
|
|
tree: [
|
|
{
|
|
name: "Sum",
|
|
title: title("Sent Volume"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.activity.sent14dEma.sats,
|
|
name: "14d EMA",
|
|
color: colors.indicator.main,
|
|
unit: Unit.sats,
|
|
defaultActive: false,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent14dEma.bitcoin,
|
|
name: "14d EMA",
|
|
color: colors.indicator.main,
|
|
unit: Unit.btc,
|
|
defaultActive: false,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent14dEma.dollars,
|
|
name: "14d EMA",
|
|
color: colors.indicator.main,
|
|
unit: Unit.usd,
|
|
defaultActive: false,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent.sats.sum,
|
|
name: "sum",
|
|
color,
|
|
unit: Unit.sats,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent.bitcoin.sum,
|
|
name: "sum",
|
|
color,
|
|
unit: Unit.btc,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent.dollars.sum,
|
|
name: "sum",
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
name: "Cumulative",
|
|
title: title("Sent Volume (Total)"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.activity.sent.sats.cumulative,
|
|
name: "all-time",
|
|
color,
|
|
unit: Unit.sats,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent.bitcoin.cumulative,
|
|
name: "all-time",
|
|
color,
|
|
unit: Unit.btc,
|
|
}),
|
|
line({
|
|
metric: tree.activity.sent.dollars.cumulative,
|
|
name: "all-time",
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
soprTree
|
|
? { name: "SOPR", tree: soprTree }
|
|
: {
|
|
name: "SOPR",
|
|
title: title("SOPR"),
|
|
bottom: createSingleSoprSeries(cohort),
|
|
},
|
|
{
|
|
name: "Sell Side Risk",
|
|
title: title("Sell Side Risk Ratio"),
|
|
bottom: createSingleSellSideRiskSeries(tree),
|
|
},
|
|
{
|
|
name: "Value",
|
|
tree: [
|
|
{
|
|
name: "Flows",
|
|
title: title("Profit & Capitulation Flows"),
|
|
bottom: createSingleCapitulationProfitFlowSeries(tree),
|
|
},
|
|
{
|
|
name: "Created & Destroyed",
|
|
title: title("Value Created & Destroyed"),
|
|
bottom: [
|
|
...createSingleValueCreatedDestroyedSeries(tree),
|
|
...valueMetrics,
|
|
],
|
|
},
|
|
{
|
|
name: "Breakdown",
|
|
tree: [
|
|
{
|
|
name: "Profit",
|
|
title: title("Profit Value Created & Destroyed"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.realized.profitValueCreated,
|
|
name: "Created",
|
|
color: colors.profit,
|
|
unit: Unit.usd,
|
|
}),
|
|
line({
|
|
metric: tree.realized.profitValueDestroyed,
|
|
name: "Destroyed",
|
|
color: colors.loss,
|
|
unit: Unit.usd,
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
name: "Loss",
|
|
title: title("Loss Value Created & Destroyed"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.realized.lossValueCreated,
|
|
name: "Created",
|
|
color: colors.profit,
|
|
unit: Unit.usd,
|
|
}),
|
|
line({
|
|
metric: tree.realized.lossValueDestroyed,
|
|
name: "Destroyed",
|
|
color: colors.loss,
|
|
unit: Unit.usd,
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: "Coins Destroyed",
|
|
tree: [
|
|
{
|
|
name: "Sum",
|
|
title: title("Coins Destroyed"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.activity.coinblocksDestroyed.sum,
|
|
name: "Coinblocks",
|
|
color,
|
|
unit: Unit.coinblocks,
|
|
}),
|
|
line({
|
|
metric: tree.activity.coindaysDestroyed.sum,
|
|
name: "Coindays",
|
|
color,
|
|
unit: Unit.coindays,
|
|
}),
|
|
],
|
|
},
|
|
{
|
|
name: "Cumulative",
|
|
title: title("Cumulative Coins Destroyed"),
|
|
bottom: [
|
|
line({
|
|
metric: tree.activity.coinblocksDestroyed.cumulative,
|
|
name: "Coinblocks",
|
|
color,
|
|
unit: Unit.coinblocks,
|
|
}),
|
|
line({
|
|
metric: tree.activity.coindaysDestroyed.cumulative,
|
|
name: "Coindays",
|
|
color,
|
|
unit: Unit.coindays,
|
|
}),
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Activity section with adjusted values (for cohorts with RealizedPattern3/4)
|
|
* @param {{ cohort: CohortAll | CohortFull | CohortWithAdjusted, title: (metric: string) => string }} args
|
|
* @returns {PartialOptionsGroup}
|
|
*/
|
|
export function createActivitySectionWithAdjusted({ cohort, title }) {
|
|
const { tree } = cohort;
|
|
return createActivitySection({
|
|
cohort,
|
|
title,
|
|
soprTree: createSingleSoprTreeWithAdjusted(cohort, title),
|
|
valueMetrics: [
|
|
line({
|
|
metric: tree.realized.adjustedValueCreated,
|
|
name: "Adjusted Created",
|
|
color: colors.adjustedCreated,
|
|
unit: Unit.usd,
|
|
defaultActive: false,
|
|
}),
|
|
line({
|
|
metric: tree.realized.adjustedValueDestroyed,
|
|
name: "Adjusted Destroyed",
|
|
color: colors.adjustedDestroyed,
|
|
unit: Unit.usd,
|
|
defaultActive: false,
|
|
}),
|
|
],
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// Grouped Cohort Activity Section
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Create grouped flows tree (Profit Flow, Capitulation Flow)
|
|
* @template {{ color: Color, name: string, tree: { realized: AnyRealizedPattern } }} T
|
|
* @param {readonly T[]} list
|
|
* @param {T} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function groupedFlowsTree(list, all, title) {
|
|
return [
|
|
{
|
|
name: "Profit",
|
|
title: title("Profit Flow"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.profitFlow,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Capitulation",
|
|
title: title("Capitulation Flow"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.capitulationFlow,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create grouped value tree (Flows, Created, Destroyed, Breakdown)
|
|
* @template {{ color: Color, name: string, tree: { realized: AnyRealizedPattern } }} T
|
|
* @param {readonly T[]} list
|
|
* @param {T} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function createGroupedValueTree(list, all, title) {
|
|
return [
|
|
{ name: "Flows", tree: groupedFlowsTree(list, all, title) },
|
|
{
|
|
name: "Created",
|
|
title: title("Value Created"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.valueCreated,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Destroyed",
|
|
title: title("Value Destroyed"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.valueDestroyed,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{ name: "Breakdown", tree: valueBreakdownTree(list, all, title) },
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Grouped activity section builder
|
|
* @param {{ list: readonly (UtxoCohortObject | CohortWithoutRelative)[], all: CohortAll, title: (metric: string) => string, soprTree?: PartialOptionsTree, valueTree?: PartialOptionsTree }} args
|
|
* @returns {PartialOptionsGroup}
|
|
*/
|
|
export function createGroupedActivitySection({
|
|
list,
|
|
all,
|
|
title,
|
|
soprTree,
|
|
valueTree,
|
|
}) {
|
|
return {
|
|
name: "Activity",
|
|
tree: [
|
|
{
|
|
name: "Volume",
|
|
tree: [
|
|
{
|
|
name: "14d EMA",
|
|
title: title("Sent Volume 14d EMA"),
|
|
bottom: flatMapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
satsBtcUsd({ pattern: tree.activity.sent14dEma, name, color }),
|
|
),
|
|
},
|
|
{
|
|
name: "Sum",
|
|
title: title("Sent Volume"),
|
|
bottom: flatMapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
satsBtcUsd({
|
|
pattern: {
|
|
sats: tree.activity.sent.sats.sum,
|
|
bitcoin: tree.activity.sent.bitcoin.sum,
|
|
dollars: tree.activity.sent.dollars.sum,
|
|
},
|
|
name,
|
|
color,
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: "SOPR",
|
|
tree: soprTree ?? createGroupedSoprTree(list, all, title),
|
|
},
|
|
{
|
|
name: "Sell Side Risk",
|
|
title: title("Sell Side Risk Ratio"),
|
|
bottom: createGroupedSellSideRiskSeries(list, all),
|
|
},
|
|
{
|
|
name: "Value",
|
|
tree: valueTree ?? createGroupedValueTree(list, all, title),
|
|
},
|
|
{ name: "Coins Destroyed", tree: coinsDestroyedTree(list, all, title) },
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Create grouped value tree with adjusted values (Flows, Normal, Adjusted, Breakdown)
|
|
* @param {readonly (CohortAll | CohortFull | CohortWithAdjusted)[]} list
|
|
* @param {CohortAll | CohortFull | CohortWithAdjusted} all
|
|
* @param {(metric: string) => string} title
|
|
* @returns {PartialOptionsTree}
|
|
*/
|
|
function createGroupedValueTreeWithAdjusted(list, all, title) {
|
|
return [
|
|
{ name: "Flows", tree: groupedFlowsTree(list, all, title) },
|
|
{
|
|
name: "Normal",
|
|
tree: [
|
|
{
|
|
name: "Created",
|
|
title: title("Value Created"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.valueCreated,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Destroyed",
|
|
title: title("Value Destroyed"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.valueDestroyed,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
name: "Adjusted",
|
|
tree: [
|
|
{
|
|
name: "Created",
|
|
title: title("Adjusted Value Created"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.adjustedValueCreated,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
{
|
|
name: "Destroyed",
|
|
title: title("Adjusted Value Destroyed"),
|
|
bottom: mapCohortsWithAll(list, all, ({ name, color, tree }) =>
|
|
line({
|
|
metric: tree.realized.adjustedValueDestroyed,
|
|
name,
|
|
color,
|
|
unit: Unit.usd,
|
|
}),
|
|
),
|
|
},
|
|
],
|
|
},
|
|
{ name: "Breakdown", tree: valueBreakdownTree(list, all, title) },
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Grouped activity section with adjusted values (for cohorts with RealizedPattern3/4)
|
|
* @param {{ list: readonly (CohortAll | CohortFull | CohortWithAdjusted)[], all: CohortAll, title: (metric: string) => string }} args
|
|
* @returns {PartialOptionsGroup}
|
|
*/
|
|
export function createGroupedActivitySectionWithAdjusted({ list, all, title }) {
|
|
return createGroupedActivitySection({
|
|
list,
|
|
all,
|
|
title,
|
|
soprTree: createGroupedSoprTreeWithAdjusted(list, all, title),
|
|
valueTree: createGroupedValueTreeWithAdjusted(list, all, title),
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create sell side risk ratio series for single cohort
|
|
* @param {{ realized: AnyRealizedPattern }} tree
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function createSingleSellSideRiskSeries(tree) {
|
|
return [
|
|
line({
|
|
metric: tree.realized.sellSideRiskRatio30dEma,
|
|
name: "30d EMA",
|
|
color: colors.time._1m,
|
|
unit: Unit.ratio,
|
|
}),
|
|
line({
|
|
metric: tree.realized.sellSideRiskRatio7dEma,
|
|
name: "7d EMA",
|
|
color: colors.time._1w,
|
|
unit: Unit.ratio,
|
|
}),
|
|
dots({
|
|
metric: tree.realized.sellSideRiskRatio,
|
|
name: "Raw",
|
|
color: colors.bitcoin,
|
|
unit: Unit.ratio,
|
|
}),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create sell side risk ratio series for grouped cohorts
|
|
* @param {readonly CohortObject[]} list
|
|
* @param {CohortObject} all
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function createGroupedSellSideRiskSeries(list, all) {
|
|
return flatMapCohortsWithAll(list, all, ({ name, color, tree }) => [
|
|
line({
|
|
metric: tree.realized.sellSideRiskRatio,
|
|
name,
|
|
color,
|
|
unit: Unit.ratio,
|
|
}),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Create value created & destroyed series for single cohort
|
|
* @param {{ realized: AnyRealizedPattern }} tree
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function createSingleValueCreatedDestroyedSeries(tree) {
|
|
return [
|
|
line({
|
|
metric: tree.realized.valueCreated,
|
|
name: "Created",
|
|
color: colors.usd,
|
|
unit: Unit.usd,
|
|
}),
|
|
line({
|
|
metric: tree.realized.valueDestroyed,
|
|
name: "Destroyed",
|
|
color: colors.loss,
|
|
unit: Unit.usd,
|
|
}),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Create capitulation & profit flow series for single cohort
|
|
* @param {{ realized: AnyRealizedPattern }} tree
|
|
* @returns {AnyFetchedSeriesBlueprint[]}
|
|
*/
|
|
function createSingleCapitulationProfitFlowSeries(tree) {
|
|
return [
|
|
line({
|
|
metric: tree.realized.profitFlow,
|
|
name: "Profit Flow",
|
|
color: colors.profit,
|
|
unit: Unit.usd,
|
|
}),
|
|
line({
|
|
metric: tree.realized.capitulationFlow,
|
|
name: "Capitulation Flow",
|
|
color: colors.loss,
|
|
unit: Unit.usd,
|
|
}),
|
|
];
|
|
}
|