proof-of-portfolio 0.0.93__py3-none-any.whl → 0.0.95__py3-none-any.whl

proof_of_portfolio/_version.py

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

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

@@ -1,7 +1,6 @@
 use crate::utils::{
-    ann_excess_return::ann_excess_return,
     constants::{
-        ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, LARGE_POSITIVE_VALUE, RATIO_SCALE_FACTOR, SCALE,
+        ARRAY_SIZE, CALMAR_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, SCALE,
         STATISTICAL_CONFIDENCE_MINIMUM_N,
     },
     risk_normalization::risk_normalization,
@@ -11,31 +10,33 @@ use super::drawdown::daily_max_drawdown;
 pub fn calmar(
     log_returns: [i64; ARRAY_SIZE],
     actual_len: u32,
-    RISK_FREE_RATE: i64,
+    annual_risk_free: i64,
     weights: [i64; ARRAY_SIZE],
     use_weighting: bool,
     bypass_confidence: bool,
     avg_daily_return: i64,
     variance_val: i64,
     ann_excess_return_val: 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 * 365 * 100) / SCALE;
+        let base_return_percentage = (avg_daily_return * days_in_year * 100) / SCALE;
         let max_drawdown_decimal = daily_max_drawdown(log_returns, actual_len);
-        let drawdown_normalization_factor = risk_normalization(max_drawdown_decimal);
+        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) / SCALE)
-                * RATIO_SCALE_FACTOR;
-            let calmar_cap = 10 * RATIO_SCALE_FACTOR;
+            let raw_calmar = base_return_percentage * drawdown_normalization_factor;
             if raw_calmar > calmar_cap {
-                calmar_cap
+                calmar_cap * RATIO_SCALE_FACTOR
             } else {
-                raw_calmar
+                raw_calmar * RATIO_SCALE_FACTOR
             }
         }
     }
@@ -67,6 +68,9 @@ fn test_calmar_normal_case() {
         avg,
         variance_val,
         ann_excess,
+        1,
+        365,
+        10,
     );
     assert(result != 0);
 }
@@ -91,6 +95,9 @@ fn test_calmar_insufficient_data() {
         avg,
         variance_val,
         ann_excess,
+        1,
+        365,
+        10,
     );
     assert(result == 0);
 }
@@ -116,6 +123,9 @@ fn test_calmar_exactly_30_days() {
         avg,
         variance_val,
         ann_excess,
+        1,
+        365,
+        10,
     );
     assert(result != 0);
 }
@@ -141,6 +151,9 @@ fn test_calmar_negative_returns() {
         avg,
         variance_val,
         ann_excess,
+        1,
+        365,
+        10,
     );
     assert(result != 0);
 }

proof_of_portfolio/circuits/components/src/core/omega.nr

@@ -1,6 +1,5 @@
 use crate::utils::constants::{
-    ARRAY_SIZE, LARGE_POSITIVE_VALUE, OMEGA_LOSS_MINIMUM, OMEGA_NOCONFIDENCE_VALUE,
-    OMEGA_SCALE_FACTOR, RATIO_SCALE_FACTOR, STATISTICAL_CONFIDENCE_MINIMUM_N,
+    ARRAY_SIZE, OMEGA_NOCONFIDENCE_VALUE, RATIO_SCALE_FACTOR, STATISTICAL_CONFIDENCE_MINIMUM_N,
 };
 
 pub fn omega(
@@ -9,6 +8,7 @@ pub fn omega(
     weights: [i64; ARRAY_SIZE],
     use_weighting: bool,
     bypass_confidence: bool,
+    omega_loss_min: i64,
 ) -> i64 {
     if !bypass_confidence & actual_len < STATISTICAL_CONFIDENCE_MINIMUM_N {
         OMEGA_NOCONFIDENCE_VALUE
@@ -33,46 +33,58 @@ pub fn omega(
                 }
             }
 
-            if sum_weights_positive == 0 {
-                sum_weights_positive = OMEGA_LOSS_MINIMUM;
-            }
-            if sum_weights_negative == 0 {
-                sum_weights_negative = OMEGA_LOSS_MINIMUM;
-            }
-
-            let positive_sum_u128 = (product_sum_positive as u128) * (sum_weights_negative as u128);
-            let negative_sum_u128 = ((-product_sum_negative) as u128) * (sum_weights_positive as u128);
-
-            let positive_sum = (positive_sum_u128 / 1000000) as i64;
-            let negative_sum = (negative_sum_u128 / 1000000) as i64;
+            let mean_pos = if sum_weights_positive != 0 {
+                product_sum_positive / sum_weights_positive
+            } else {
+                0
+            };
+            let mean_neg = if sum_weights_negative != 0 {
+                (-product_sum_negative) / sum_weights_negative
+            } else {
+                0
+            };
 
-            let effective_denominator = if negative_sum >= OMEGA_LOSS_MINIMUM {
-                negative_sum
+            let effective_denominator = if mean_neg >= omega_loss_min {
+                mean_neg
             } else {
-                OMEGA_LOSS_MINIMUM
+                omega_loss_min
             };
-            let final_calc = ((positive_sum as u128) * (RATIO_SCALE_FACTOR as u128)) / (effective_denominator as u128);
-            final_calc as i64
+            (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
         } else {
-            let mut positive_sum: u64 = 0;
-            let mut negative_sum: u64 = 0;
+            let mut positive_sum: i64 = 0;
+            let mut negative_sum: i64 = 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] > 0 {
-                        positive_sum = positive_sum + (log_returns[i] as u64);
+                        positive_sum += log_returns[i];
+                        count_pos += 1;
                     } else if log_returns[i] < 0 {
-                        negative_sum = negative_sum + ((-log_returns[i]) as u64);
+                        negative_sum += (-log_returns[i]);
+                        count_neg += 1;
                     }
                 }
             }
 
-            let effective_denominator = if negative_sum >= OMEGA_LOSS_MINIMUM as u64 {
-                negative_sum
+            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
             } else {
-                OMEGA_LOSS_MINIMUM as u64
+                omega_loss_min
             };
-            ((positive_sum * RATIO_SCALE_FACTOR as u64) / effective_denominator) as i64
+            (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
         }
     }
 }
@@ -85,7 +97,7 @@ fn test_omega_all_positive() {
     }
 
     let weights = [100000; ARRAY_SIZE];
-    let result = omega(returns, 5, weights, false, false);
+    let result = omega(returns, 5, weights, false, false, 10000000);
     assert(result == 10000000);
 }
 
@@ -97,7 +109,7 @@ fn test_omega_all_negative() {
     }
 
     let weights = [100000; ARRAY_SIZE];
-    let result = omega(returns, 5, weights, false, false);
+    let result = omega(returns, 5, weights, false, false, 10000000);
     assert(result == 0);
 }
 
@@ -110,7 +122,7 @@ fn test_omega_mixed_returns() {
     returns[3] = -300;
 
     let weights = [100000; ARRAY_SIZE];
-    let result = omega(returns, 4, weights, false, false);
+    let result = omega(returns, 4, weights, false, false, 10000000);
     assert(result == 22500000);
 }
 
@@ -122,6 +134,6 @@ fn test_omega_zero_returns() {
     }
 
     let weights = [100000; ARRAY_SIZE];
-    let result = omega(returns, 5, weights, false, false);
+    let result = omega(returns, 5, weights, false, false, 10000000);
     assert(result == 10000000);
 }

proof_of_portfolio/circuits/components/src/utils/ann_excess_return.nr

@@ -3,9 +3,10 @@ use crate::utils::{average::average, constants::{ARRAY_SIZE, DAYS_IN_YEAR}};
 pub fn ann_excess_return(
     log_returns: [i64; ARRAY_SIZE],
     actual_len: u32,
-    RISK_FREE_RATE: i64,
+    annual_risk_free: i64,
     weights: [i64; ARRAY_SIZE],
     use_weighting: bool,
+    days_in_year: i64,
 ) -> i64 {
     let sum_of_weights = if use_weighting {
         let mut sum: i64 = 0;
@@ -25,8 +26,8 @@ pub fn ann_excess_return(
         use_weighting,
         sum_of_weights,
     );
-    let annualized = avg * DAYS_IN_YEAR;
-    annualized - RISK_FREE_RATE
+    let annualized = avg * days_in_year;
+    annualized - annual_risk_free
 }
 
 #[test]
@@ -37,7 +38,7 @@ fn test_ann_excess_return_positive() {
     returns[2] = 150;
 
     let weights = [100000; ARRAY_SIZE];
-    let result = ann_excess_return(returns, 3, 10000, weights, false);
+    let result = ann_excess_return(returns, 3, 10000, weights, false, 365);
     assert(result > 0);
 }
 
@@ -49,7 +50,7 @@ fn test_ann_excess_return_negative() {
     returns[2] = -150;
 
     let weights = [100000; ARRAY_SIZE];
-    let result = ann_excess_return(returns, 3, 10000, weights, false);
+    let result = ann_excess_return(returns, 3, 10000, weights, false, 365);
     assert(result < 0);
 }
 
@@ -61,7 +62,7 @@ fn test_ann_excess_return_equal_to_risk_free() {
     returns[2] = 100;
 
     let weights = [100000; ARRAY_SIZE];
-    let result = ann_excess_return(returns, 3, 36500, weights, false);
+    let result = ann_excess_return(returns, 3, 36500, weights, false, 365);
     assert(result == 0);
 }
 
@@ -72,6 +73,6 @@ fn test_ann_excess_return_zero_risk_free() {
     returns[1] = 200;
 
     let weights = [100000; ARRAY_SIZE];
-    let result = ann_excess_return(returns, 2, 0, weights, false);
+    let result = ann_excess_return(returns, 2, 0, weights, false, 365);
     assert(result == 54750);
 }

proof_of_portfolio/circuits/components/src/utils/risk_normalization.nr

@@ -1,8 +1,6 @@
 use crate::utils::constants::SCALE;
 
-pub fn mdd_augmentation(drawdown_decimal: i64) -> i64 {
-    let max_drawdown_percentage = 10;
-
+pub fn mdd_augmentation(drawdown_decimal: i64, max_drawdown_percentage: i64) -> i64 {
     if (drawdown_decimal <= 0) | (drawdown_decimal >= SCALE) {
         0
     } else {
@@ -16,27 +14,27 @@ pub fn mdd_augmentation(drawdown_decimal: i64) -> i64 {
     }
 }
 
-pub fn risk_normalization(drawdown_decimal: i64) -> i64 {
-    mdd_augmentation(drawdown_decimal)
+pub fn risk_normalization(drawdown_decimal: i64, max_drawdown_percentage: i64) -> i64 {
+    mdd_augmentation(drawdown_decimal, max_drawdown_percentage)
 }
 
 #[test]
 fn test_risk_normalization_zero_drawdown() {
-    let result = risk_normalization(0);
+    let result = risk_normalization(0, 10);
     assert(result == 0);
 }
 
 #[test]
 fn test_risk_normalization_high_drawdown() {
     let drawdown_15_percent = (15 * SCALE) / 100;
-    let result = risk_normalization(drawdown_15_percent);
+    let result = risk_normalization(drawdown_15_percent, 10);
     assert(result == 0);
 }
 
 #[test]
 fn test_risk_normalization_low_drawdown() {
     let drawdown_2_percent = (2 * SCALE) / 100;
-    let result = risk_normalization(drawdown_2_percent);
+    let result = risk_normalization(drawdown_2_percent, 10);
     let expected = SCALE / 2;
     assert(result == expected);
 }
@@ -44,6 +42,6 @@ fn test_risk_normalization_low_drawdown() {
 #[test]
 fn test_risk_normalization_max_threshold() {
     let drawdown_10_percent = (10 * SCALE) / 100;
-    let result = risk_normalization(drawdown_10_percent);
+    let result = risk_normalization(drawdown_10_percent, 10);
     assert(result == 0);
 }

proof_of_portfolio/circuits/components/src/utils/weighting_distribution.nr

@@ -1,4 +1,4 @@
-use crate::utils::constants::ARRAY_SIZE;
+use crate::utils::constants::{ARRAY_SIZE, SCALE};
 
 fn exp_decay_scaled(neg_x_scaled: i64) -> i64 {
     let scale: i64 = 100000;
@@ -17,18 +17,23 @@ fn exp_decay_scaled(neg_x_scaled: i64) -> i64 {
     }
 }
 
-pub fn weighting_distribution(actual_len: u32) -> [i64; ARRAY_SIZE] {
+pub fn weighting_distribution(
+    actual_len: u32,
+    weighted_decay_max: i64,
+    weighted_decay_min: i64,
+    weighted_decay_rate: i64,
+) -> [i64; ARRAY_SIZE] {
     let mut weights = [0; ARRAY_SIZE];
-    let max_weight: i64 = 100000;
-    let min_weight: i64 = 15000;
-    let decay_rate: i64 = 7500;
+    let max_weight = weighted_decay_max;
+    let min_weight = weighted_decay_min;
+    let decay_rate = weighted_decay_rate;
     let weight_range = max_weight - min_weight;
-    let scale: i64 = 100000;
+    let scale = SCALE;
 
     for i in 0..ARRAY_SIZE {
         if (i as u32) < actual_len {
             let position_from_newest = (actual_len - 1) - (i as u32);
-            let neg_x_scaled = -(decay_rate * (position_from_newest as i64)) / 1;
+            let neg_x_scaled = -(decay_rate * (position_from_newest as i64));
             let exp_val_scaled = exp_decay_scaled(neg_x_scaled);
 
             let weighted_val = (weight_range * exp_val_scaled) / scale;

proof_of_portfolio/circuits/src/main.nr

@@ -8,24 +8,28 @@ use components::core::merkle::{
 use components::utils::{
     ann_excess_return::ann_excess_return,
     average::average,
-    constants::{ARRAY_SIZE, MAX_DAYS, MAX_RETURNS, MAX_SIGNALS, MERKLE_DEPTH, SCALE},
+    constants::{ARRAY_SIZE, MAX_DAYS, MAX_RETURNS, MAX_SIGNALS, MERKLE_DEPTH},
     variance::variance,
-    weighting_distribution::weighting_distribution,
 };
 
 fn main(
     log_returns: [i64; MAX_DAYS],
     n_returns: u32,
+    daily_pnl: [i64; ARRAY_SIZE],
+    n_pnl: u32,
     signals: [TradingSignal; MAX_SIGNALS],
     signals_count: u32,
     path_elements: [[Field; MERKLE_DEPTH]; MAX_SIGNALS],
     path_indices: [[Field; MERKLE_DEPTH]; MAX_SIGNALS],
     signals_merkle_root: pub Field,
-    risk_free_rate: pub i64,
     use_weighting: bool,
     bypass_confidence: pub bool,
-    account_size: i64,
     weights: [i64; ARRAY_SIZE],
+    calmar_cap: i64,
+    days_in_year: i64,
+    omega_loss_min: i64,
+    annual_risk_free: i64,
+    drawdown_max_percent: i64,
 ) -> pub [Field; 9] {
     // Verify all trading signals are included in the merkle tree
     let mut all_verified = true;
@@ -92,37 +96,18 @@ fn main(
     let ann_excess_return_val = ann_excess_return(
         returns_array,
         n_returns,
-        risk_free_rate,
+        annual_risk_free,
         weights,
         use_weighting,
+        days_in_year,
     );
 
-    let mut daily_pnl_array = [0; ARRAY_SIZE];
-    for i in 0..MAX_DAYS {
-        if (i as u32) < n_returns {
-            let log_return = returns_array[i];
-            let x_squared = (log_return * log_return) / SCALE;
-            let x_cubed = (x_squared * log_return) / SCALE;
-            let x_fourth = (x_cubed * log_return) / SCALE;
-            let x_fifth = (x_fourth * log_return) / SCALE;
-            let exp_minus_one =
-                log_return + (x_squared / 2) + (x_cubed / 6) + (x_fourth / 24) + (x_fifth / 120);
-            daily_pnl_array[i] = (exp_minus_one * account_size) / SCALE;
-        }
-    }
-
-    let avg_daily_pnl = average(
-        daily_pnl_array,
-        n_returns,
-        weights,
-        use_weighting,
-        sum_of_weights,
-    );
+    let avg_daily_pnl = average(daily_pnl, n_pnl, weights, use_weighting, sum_of_weights);
 
     let sharpe_ratio = sharpe(
         returns_array,
         n_returns,
-        risk_free_rate,
+        annual_risk_free,
         weights,
         use_weighting,
         bypass_confidence,
@@ -134,13 +119,16 @@ fn main(
     let calmar_ratio = calmar(
         returns_array,
         n_returns,
-        risk_free_rate,
+        annual_risk_free,
         weights,
         use_weighting,
         bypass_confidence,
         avg_daily_return,
         variance_val,
         ann_excess_return_val,
+        calmar_cap,
+        days_in_year,
+        drawdown_max_percent,
     );
     let omega_ratio = omega(
         returns_array,
@@ -148,11 +136,12 @@ fn main(
         weights,
         use_weighting,
         bypass_confidence,
+        omega_loss_min,
     );
     let sortino_ratio = sortino(
         returns_array,
         n_returns,
-        risk_free_rate,
+        annual_risk_free,
         weights,
         use_weighting,
         bypass_confidence,