brk: first commit

_src/structs/liquidity.rs

@@ -0,0 +1,103 @@
+use std::f64::consts::E;
+
+use super::{AddressLiquidity, Amount};
+
+#[derive(Debug)]
+pub struct LiquidityClassification {
+    illiquid: f64,
+    liquid: f64,
+}
+
+impl LiquidityClassification {
+    /// Following this:
+    /// https://insights.glassnode.com/bitcoin-liquid-supply/
+    /// https://www.desmos.com/calculator/dutgni5rtj
+    pub fn new(sent: Amount, received: Amount) -> Self {
+        if received == Amount::ZERO {
+            dbg!(sent, received);
+            panic!()
+        }
+
+        let liquidity = {
+            if sent > received {
+                panic!("Shouldn't be possible");
+            }
+
+            if sent == Amount::ZERO {
+                0.0
+            } else {
+                let liquidity = sent.to_sat() as f64 / received.to_sat() as f64;
+
+                if liquidity.is_nan() {
+                    dbg!(sent, received);
+                    unreachable!()
+                } else {
+                    liquidity
+                }
+            }
+        };
+
+        let illiquid_line = Self::compute_illiquid_line(liquidity);
+        let liquid_line = Self::compute_liquid_line(liquidity);
+
+        let illiquid = illiquid_line;
+        let liquid = liquid_line - illiquid_line;
+        let highly_liquid = 1.0 - liquid_line;
+
+        if illiquid < 0.0 || liquid < 0.0 || highly_liquid < 0.0 {
+            unreachable!()
+        }
+
+        Self { illiquid, liquid }
+    }
+
+    #[inline(always)]
+    pub fn split(&self, value: f64) -> LiquiditySplitResult {
+        let illiquid = value * self.illiquid;
+        let liquid = value * self.liquid;
+        let highly_liquid = value - illiquid - liquid;
+
+        LiquiditySplitResult {
+            illiquid,
+            liquid,
+            highly_liquid,
+        }
+    }
+
+    /// Returns value in range 0.0..1.0
+    #[inline(always)]
+    fn compute_illiquid_line(x: f64) -> f64 {
+        Self::compute_ratio(x, 0.25)
+    }
+
+    /// Returns value in range 0.0..1.0
+    #[inline(always)]
+    fn compute_liquid_line(x: f64) -> f64 {
+        Self::compute_ratio(x, 0.75)
+    }
+
+    #[inline(always)]
+    fn compute_ratio(x: f64, x0: f64) -> f64 {
+        let l = 1.0;
+        let k = 25.0;
+
+        l / (1.0 + E.powf(k * (x - x0)))
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct LiquiditySplitResult {
+    pub illiquid: f64,
+    pub liquid: f64,
+    pub highly_liquid: f64,
+}
+
+impl LiquiditySplitResult {
+    pub fn from(&self, address_liquidity: AddressLiquidity) -> f64 {
+        match address_liquidity {
+            AddressLiquidity::Illiquid => self.illiquid,
+            AddressLiquidity::Liquid => self.liquid,
+            AddressLiquidity::HighlyLiquid => self.highly_liquid,
+        }
+    }
+}