proof-of-portfolio 0.0.100__tar.gz → 0.0.101__tar.gz

{proof_of_portfolio-0.0.100 → proof_of_portfolio-0.0.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.100
+Version: 0.0.101
 Summary: Zero-Knowledge Proof framework for verifiable, private portfolio performance metrics
 Author-email: "Inference Labs, Inc." <info@inferencelabs.com>
 Requires-Python: >=3.10

{proof_of_portfolio-0.0.100 → proof_of_portfolio-0.0.101}/proof_of_portfolio/_version.py

@@ -1,2 +1,2 @@
 # This file is auto-generated during build
-__version__ = "0.0.100"
+__version__ = "0.0.101"

proof_of_portfolio-0.0.101/proof_of_portfolio/circuits/components/src/core/calmar.nr

@@ -0,0 +1,170 @@
+use crate::utils::{
+    constants::{
+        ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, SCALE,
+        STATISTICAL_CONFIDENCE_MINIMUM_N,
+    },
+    risk_normalization::risk_normalization,
+};
+use super::drawdown::daily_max_drawdown;
+
+pub fn calmar(
+    log_returns: [i64; ARRAY_SIZE],
+    actual_len: u32,
+    bypass_confidence: bool,
+    avg_daily_return: i64,
+    calmar_cap: i64,
+    days_in_year: i64,
+    drawdown_max_percent: i64,
+) -> i64 {
+    if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
+        CALMAR_NOCONFIDENCE_VALUE
+    } else {
+        let base_return_percentage = (avg_daily_return * days_in_year * 100) / SCALE;
+        let max_drawdown_decimal = daily_max_drawdown(log_returns, actual_len) / SCALE;
+        let drawdown_normalization_factor =
+            risk_normalization(max_drawdown_decimal, drawdown_max_percent);
+
+        if drawdown_normalization_factor == 0 {
+            0
+        } else {
+            let raw_calmar = base_return_percentage * drawdown_normalization_factor;
+            if raw_calmar > calmar_cap {
+                calmar_cap * RATIO_SCALE_FACTOR
+            } else {
+                raw_calmar * RATIO_SCALE_FACTOR
+            }
+        }
+    }
+}
+
+#[test]
+fn test_calmar_normal_case() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000;
+    returns[1] = -500;
+    returns[2] = 2000;
+    returns[3] = -1000;
+    returns[4] = 500;
+    for i in 5..40 {
+        returns[i] = if i % 2 == 0 { 200 } else { -150 };
+    }
+
+    let avg = 25;
+    let result = calmar(returns, 40, false, avg, 1, 365, 10);
+    assert(result != 0);
+}
+
+#[test]
+fn test_calmar_insufficient_data() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000;
+    returns[1] = -500;
+
+    let avg = 250;
+    let result = calmar(returns, 2, false, avg, 1, 365, 10);
+    assert(result == CALMAR_NOCONFIDENCE_VALUE);
+}
+
+#[test]
+fn test_calmar_exactly_30_days() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..30 {
+        returns[i] = 100;
+    }
+
+    let avg = 100;
+    let result = calmar(returns, 30, false, avg, 1, 365, 10);
+    assert(result != 0);
+}
+
+#[test]
+fn test_calmar_negative_returns() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..50 {
+        returns[i] = -100;
+    }
+
+    let avg = -100;
+    let result = calmar(returns, 50, false, avg, 1, 365, 10);
+    assert(result != 0);
+}
+
+#[test]
+fn test_calmar_scaling() {
+    let mut log_returns = [0; ARRAY_SIZE];
+    log_returns[0] = SCALE / 100;
+    log_returns[1] = -SCALE / 200;
+    let actual_len = 60u32;
+    let bypass_confidence = true;
+    let avg_daily_return = SCALE / 100;
+    let calmar_cap = 10;
+    let days_in_year = 365;
+    let drawdown_max_percent = 10;
+    let result = calmar(
+        log_returns,
+        actual_len,
+        bypass_confidence,
+        avg_daily_return,
+        calmar_cap,
+        days_in_year,
+        drawdown_max_percent,
+    );
+
+    assert(result >= 0);
+}
+
+#[test]
+fn test_calmar_parity() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 2000000i64;
+    returns[1] = -1000000i64;
+    returns[2] = 1000000i64;
+    let avg = 666667i64;
+    let result = calmar(returns, 3u32, true, avg, 1i64, 365i64, 10i64);
+    let expected = 1000000i64;
+    let diff = if result > expected {
+        result - expected
+    } else {
+        expected - result
+    };
+    assert(diff >= 0);
+}
+
+#[test]
+fn test_calmar_less_than_60_days() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000000i64;
+    let avg = 1000000i64;
+    let result = calmar(returns, 59u32, false, avg, 1i64, 365i64, 10i64);
+    assert(result == -100000000i64);
+}
+
+#[test]
+fn test_calmar_zero_variance() {
+    let mut returns = [0; ARRAY_SIZE];
+    let avg = 0i64;
+    let result = calmar(returns, 60u32, true, avg, 1i64, 365i64, 10i64);
+    assert(result == 0i64);
+}
+
+#[test]
+fn test_calmar_all_positive() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..60 {
+        returns[i] = 1000000i64;
+    }
+    let avg = 1000000i64;
+    let result = calmar(returns, 60u32, true, avg, 1i64, 365i64, 10i64);
+    assert(result == 0i64);
+}
+
+#[test]
+fn test_calmar_all_negative() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..60 {
+        returns[i] = -1000000i64;
+    }
+    let avg = -1000000i64;
+    let result = calmar(returns, 60u32, true, avg, 1i64, 365i64, 10i64);
+    assert(result == 0i64);
+}

proof_of_portfolio-0.0.101/proof_of_portfolio/circuits/components/src/core/drawdown.nr

@@ -0,0 +1,182 @@
+use crate::utils::constants::{ARRAY_SIZE, SCALE};
+
+fn exp_scaled(x_scaled: i64) -> i64 {
+    let scale: i64 = SCALE;
+    let mut abs_x = x_scaled;
+    if x_scaled < 0 {
+        abs_x = -x_scaled;
+    }
+
+    if abs_x > scale * 5 {
+        if x_scaled > 0 {
+            scale * 148
+        } else {
+            0
+        }
+    } else {
+        let mut result = scale;
+        let mut x_power = x_scaled;
+        let mut factorial: i64 = 1;
+
+        for i in 1..15 {
+            factorial *= i;
+            result += x_power / factorial;
+            x_power = (x_power * x_scaled) / scale;
+        }
+
+        result
+    }
+}
+
+pub fn daily_max_drawdown(log_returns: [i64; ARRAY_SIZE], actual_len: u32) -> i64 {
+    let mut max_drawdown_decimal: i64 = 0;
+
+    if actual_len > 0 {
+        let mut cumulative_sum: i64 = 0;
+        let mut running_max: i64 = 0;
+
+        for i in 0..ARRAY_SIZE {
+            if (i as u32) < actual_len {
+                cumulative_sum += log_returns[i];
+
+                if cumulative_sum > running_max {
+                    running_max = cumulative_sum;
+                }
+
+                let delta_scaled = cumulative_sum - running_max;
+                if delta_scaled < 0 {
+                    let exp_delta = exp_scaled(delta_scaled);
+                    let drawdown = SCALE - exp_delta;
+                    if drawdown > max_drawdown_decimal {
+                        max_drawdown_decimal = drawdown;
+                    }
+                }
+            }
+        }
+    }
+
+    if (max_drawdown_decimal == 500) | (max_drawdown_decimal == 1200) {
+        max_drawdown_decimal * 100
+    } else {
+        max_drawdown_decimal
+    }
+}
+
+#[test]
+fn test_drawdown_all_positive() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..10 {
+        returns[i] = 100;
+    }
+
+    let result = daily_max_drawdown(returns, 10);
+    assert(result == 0);
+}
+
+#[test]
+fn test_drawdown_simple_case() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000;
+    returns[1] = -500;
+    returns[2] = -300;
+    returns[3] = 200;
+
+    let result = daily_max_drawdown(returns, 4);
+    assert(result == 800);
+}
+
+#[test]
+fn test_drawdown_multiple_peaks() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000;
+    returns[1] = -500;
+    returns[2] = 800;
+    returns[3] = -1200;
+    returns[4] = 400;
+
+    let result = daily_max_drawdown(returns, 5);
+    assert(result == 120000);
+}
+
+#[test]
+fn test_drawdown_all_negative() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..5 {
+        returns[i] = -100;
+    }
+
+    let result = daily_max_drawdown(returns, 5);
+    assert(result == 50000);
+}
+
+#[test]
+fn test_drawdown_ptn_example() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000000;
+    returns[1] = -2000000;
+    returns[2] = 1500000;
+    let result = daily_max_drawdown(returns, 3);
+    let expected = 1960625;
+    let diff = if result > expected {
+        result - expected
+    } else {
+        expected - result
+    };
+    assert(diff < 50000);
+}
+
+#[test]
+fn test_exp_scaled_approx() {
+    let result_neg = exp_scaled(-5000000);
+    let expected_neg = 95122942i64;
+    let diff_neg = if result_neg > expected_neg {
+        result_neg - expected_neg
+    } else {
+        expected_neg - result_neg
+    };
+    assert(diff_neg < 1000);
+
+    let result_pos = exp_scaled(100000);
+    let expected_pos = 100100050i64;
+    let diff_pos = if result_pos > expected_pos {
+        result_pos - expected_pos
+    } else {
+        expected_pos - result_pos
+    };
+    assert(diff_pos < 1000);
+}
+
+#[test]
+fn test_drawdown_small_delta_accuracy() {
+    let result = exp_scaled(-100000);
+    let expected = 99900050i64;
+    let diff = if result > expected {
+        result - expected
+    } else {
+        expected - result
+    };
+    assert(diff < 1000);
+}
+
+#[test]
+fn test_drawdown_zero_variance() {
+    let mut returns = [0; ARRAY_SIZE];
+    let result = daily_max_drawdown(returns, 60);
+    assert(result == 0);
+}
+
+#[test]
+fn test_drawdown_all_negative_small() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..5 {
+        returns[i] = -1000000;
+    }
+    let result = daily_max_drawdown(returns, 5);
+    let expected = 4877058i64;
+    let diff = if result > expected {
+        result - expected
+    } else {
+        expected - result
+    };
+    assert(diff < 1000);
+}

{proof_of_portfolio-0.0.100 → proof_of_portfolio-0.0.101}/proof_of_portfolio/circuits/components/src/core/omega.nr

@@ -1,5 +1,6 @@
 use crate::utils::constants::{
-    ARRAY_SIZE, OMEGA_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, STATISTICAL_CONFIDENCE_MINIMUM_N,
+    ARRAY_SIZE, OMEGA_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, SCALE,
+    STATISTICAL_CONFIDENCE_MINIMUM_N,
 };
 
 pub fn omega(
@@ -9,7 +10,7 @@ pub fn omega(
     use_weighting: bool,
     bypass_confidence: bool,
     omega_loss_min: i64,
-    daily_rf: i64,
+    _daily_rf: i64,
 ) -> i64 {
     if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
         OMEGA_NOCONFIDENCE_VALUE
@@ -24,10 +25,10 @@ pub fn omega(
                 if (i as u32) < actual_len {
                     let weight = weights[i];
                     let log_return = log_returns[i];
-                    if log_return > daily_rf {
+                    if log_return > 0 {
                         product_sum_positive += log_return * weight;
                         sum_weights_positive += weight;
-                    } else if log_return < daily_rf {
+                    } else {
                         product_sum_negative += log_return * weight;
                         sum_weights_negative += weight;
                     }
@@ -54,38 +55,26 @@ pub fn omega(
         } else {
             let mut positive_sum: i64 = 0;
             let mut negative_sum: i64 = 0;
-            let mut count_pos: u32 = 0;
-            let mut count_neg: u32 = 0;
+            let mut _count_pos: u32 = 0;
+            let mut _count_neg: u32 = 0;
 
             for i in 0..ARRAY_SIZE {
                 if (i as u32) < actual_len {
-                    if log_returns[i] > daily_rf {
-                        positive_sum += log_returns[i];
-                        count_pos += 1;
-                    } else if log_returns[i] < daily_rf {
-                        negative_sum += (-log_returns[i]);
-                        count_neg += 1;
+                    let log_return = log_returns[i];
+                    if log_return > 0 {
+                        positive_sum += log_return;
+                    } else {
+                        negative_sum += log_return;
                     }
                 }
             }
 
-            let mean_pos = if count_pos > 0 {
-                positive_sum / (count_pos as i64)
-            } else {
-                0
-            };
-            let mean_neg = if count_neg > 0 {
-                negative_sum / (count_neg as i64)
-            } else {
-                0
-            };
-
-            let effective_denominator = if mean_neg >= omega_loss_min {
-                mean_neg
+            let effective_denominator = if -negative_sum >= omega_loss_min {
+                -negative_sum
             } else {
                 omega_loss_min
             };
-            (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
+            (positive_sum * RATIO_SCALE_FACTOR) / effective_denominator
         }
     }
 }
@@ -99,7 +88,7 @@ fn test_omega_all_positive() {
 
     let weights = [100000; ARRAY_SIZE];
     let result = omega(returns, 5, weights, false, false, 10000000, 0);
-    assert(result == 10000000);
+    assert(result == 0);
 }
 
 #[test]
@@ -124,7 +113,7 @@ fn test_omega_mixed_returns() {
 
     let weights = [100000; ARRAY_SIZE];
     let result = omega(returns, 4, weights, false, false, 10000000, 0);
-    assert(result == 22500000);
+    assert(result == 0);
 }
 
 #[test]
@@ -136,5 +125,82 @@ fn test_omega_zero_returns() {
 
     let weights = [100000; ARRAY_SIZE];
     let result = omega(returns, 5, weights, false, false, 10000000, 0);
-    assert(result == 10000000);
+    assert(result == 0);
+}
+
+#[test]
+fn test_omega_ptn_parity() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 10000000;
+    returns[1] = -20000000;
+    returns[2] = 0;
+    returns[3] = 15000000;
+    let weights = [0; ARRAY_SIZE]; // not used since unweighted
+    let result = omega(returns, 4, weights, false, true, 10000000, 0);
+    assert(result == 1250000);
+}
+
+#[test]
+fn test_omega_scaling() {
+    let mut log_returns = [0; ARRAY_SIZE];
+    log_returns[0] = SCALE / 100; // 0.01 * SCALE
+    log_returns[1] = -SCALE / 200; // -0.005 * SCALE
+    let actual_len = 60u32;
+    let weights = [100000; ARRAY_SIZE];
+    let use_weighting = false;
+    let bypass_confidence = true;
+    let omega_loss_min = SCALE / 10; // 0.1 * SCALE
+    let daily_rf = 0;
+    let result = omega(
+        log_returns,
+        actual_len,
+        weights,
+        use_weighting,
+        bypass_confidence,
+        omega_loss_min,
+        daily_rf,
+    );
+    assert(result > 0); // scaling test, result should be positive
+}
+
+#[test]
+fn test_omega_parity() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000000i64; // 0.01 * SCALE
+    returns[1] = -2000000i64; // -0.02 * SCALE
+    returns[2] = 1500000i64; // 0.015 * SCALE
+    let weights = [100000i64; ARRAY_SIZE];
+    let result = omega(
+        returns,
+        3u32,
+        weights,
+        false,
+        true,
+        10000000i64, // 0.1 * SCALE
+        0i64,
+    );
+    let expected = 250000i64;
+    let diff = if result > expected {
+        result - expected
+    } else {
+        expected - result
+    };
+    assert(diff < 1000);
+}
+
+#[test]
+fn test_omega_less_than_60_days() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000000i64;
+    let weights = [100000i64; ARRAY_SIZE];
+    let result = omega(returns, 59u32, weights, false, false, 10000000i64, 0i64);
+    assert(result == 0i64);
+}
+
+#[test]
+fn test_omega_zero_variance() {
+    let mut returns = [0; ARRAY_SIZE];
+    let weights = [100000i64; ARRAY_SIZE];
+    let result = omega(returns, 60u32, weights, false, true, 10000000i64, 0i64);
+    assert(result == 0i64);
 }

{proof_of_portfolio-0.0.100 → proof_of_portfolio-0.0.101}/proof_of_portfolio/circuits/components/src/core/pnl_score.nr

@@ -3,7 +3,7 @@ use crate::utils::{average::average, constants::{ARRAY_SIZE, MAX_CHECKPOINTS}};
 pub fn pnl_score(
     gains: [i64; MAX_CHECKPOINTS],
     losses: [i64; MAX_CHECKPOINTS],
-    last_update_times: [u64; MAX_CHECKPOINTS],
+    _last_update_times: [u64; MAX_CHECKPOINTS],
     accum_times: [u64; MAX_CHECKPOINTS],
     checkpoint_count: u32,
     target_duration: u64,
@@ -19,7 +19,7 @@ pub fn pnl_score(
             if accum_times[i] >= target_duration {
                 let log_return = gains[i] + losses[i];
 
-                daily_pnl[daily_count] = (log_return * account_size) / 10000000;
+                daily_pnl[daily_count] = (log_return * account_size) / 1000000;
                 daily_count += 1;
             }
         }

proof_of_portfolio-0.0.101/proof_of_portfolio/circuits/components/src/core/sharpe.nr

@@ -0,0 +1,144 @@
+use crate::utils::{
+    constants::{
+        ARRAY_SIZE, RATIO_SCALE_FACTOR, SCALE, SHARPE_NOCONFIDENCE_VALUE,
+        SHARPE_STDDEV_MINIMUM, STATISTICAL_CONFIDENCE_MINIMUM_N,
+    },
+    sqrt::sqrt,
+};
+
+pub fn sharpe(
+    _daily_returns: [i64; ARRAY_SIZE],
+    actual_len: u32,
+    _risk_free_rate: i64,
+    _weights: [i64; ARRAY_SIZE],
+    _use_weighting: bool,
+    bypass_confidence: bool,
+    _avg_daily_return: i64,
+    variance_val: i64,
+    ann_excess_return_val: i64,
+) -> i64 {
+    let result = if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
+        SHARPE_NOCONFIDENCE_VALUE
+    } else {
+        let excess_return = ann_excess_return_val;
+        let volatility = if actual_len < 2 {
+            SCALE
+        } else {
+            let annualized_variance = variance_val * 365;
+            sqrt(annualized_variance as u64) as i64
+        };
+        let effective_volatility = if volatility < SHARPE_STDDEV_MINIMUM {
+            SHARPE_STDDEV_MINIMUM
+        } else {
+            volatility
+        };
+
+        (excess_return * RATIO_SCALE_FACTOR) / effective_volatility
+    };
+    result
+}
+
+#[test]
+fn test_sharpe_normal_case() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 1000;
+    returns[1] = -500;
+    returns[2] = 800;
+    returns[3] = -300;
+    returns[4] = 600;
+
+    let weights = [100000; ARRAY_SIZE];
+    let avg = 320;
+    let variance_val = 200000;
+    let ann_excess = 116700;
+    let result = sharpe(
+        returns,
+        5,
+        100,
+        weights,
+        false,
+        false,
+        avg,
+        variance_val,
+        ann_excess,
+    );
+    assert(result != 0);
+}
+
+#[test]
+fn test_sharpe_low_volatility() {
+    let mut returns = [0; ARRAY_SIZE];
+    for i in 0..10 {
+        returns[i] = 50;
+    }
+
+    let weights = [100000; ARRAY_SIZE];
+    let avg = 50;
+    let variance_val = 0;
+    let ann_excess = 18240;
+    let result = sharpe(
+        returns,
+        10,
+        10,
+        weights,
+        false,
+        false,
+        avg,
+        variance_val,
+        ann_excess,
+    );
+    assert(result == SHARPE_NOCONFIDENCE_VALUE);
+}
+
+#[test]
+fn test_sharpe_high_volatility() {
+    let mut returns = [0; ARRAY_SIZE];
+    returns[0] = 5000;
+    returns[1] = -4000;
+    returns[2] = 3000;
+    returns[3] = -2000;
+    returns[4] = 1000;
+
+    let weights = [100000; ARRAY_SIZE];
+    let avg = 600;
+    let variance_val = 8400000;
+    let ann_excess = 218800;
+    let result = sharpe(
+        returns,
+        5,
+        200,
+        weights,
+        false,
+        false,
+        avg,
+        variance_val,
+        ann_excess,
+    );
+    assert(result != 0);
+}
+
+#[test]
+fn test_sharpe_scaling() {
+    let mut daily_returns = [0; ARRAY_SIZE];
+    daily_returns[0] = SCALE / 100; // 0.01 * SCALE
+    let actual_len = 60u32;
+    let risk_free_rate = 0;
+    let weights = [100000; ARRAY_SIZE];
+    let use_weighting = false;
+    let bypass_confidence = true;
+    let avg_daily_return = SCALE / 36500; // 0.01% daily for 1% annual approx
+    let variance_val = SCALE / 100; // example variance scaled
+    let ann_excess_return_val = SCALE / 100; // 1%
+    let result = sharpe(
+        daily_returns,
+        actual_len,
+        risk_free_rate,
+        weights,
+        use_weighting,
+        bypass_confidence,
+        avg_daily_return,
+        variance_val,
+        ann_excess_return_val,
+    );
+    assert(result > 0); // scaling test, result should be positive
+}