proof-of-portfolio 0.0.94__tar.gz → 0.0.96__tar.gz

{proof_of_portfolio-0.0.94 → proof_of_portfolio-0.0.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.94
+Version: 0.0.96
 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.94 → proof_of_portfolio-0.0.96}/proof_of_portfolio/__init__.py

@@ -54,9 +54,21 @@ def requires_dependencies(func):
 
 def _prove_worker(
     miner_data,
-    hotkey,
+    daily_pnl=None,
+    hotkey=None,
     verbose=False,
     annual_risk_free_percentage=4.19,
+    calmar_ratio_cap=10,
+    days_in_year_crypto=365,
+    weighted_average_decay_max=1.0,
+    weighted_average_decay_min=0.15,
+    weighted_average_decay_rate=0.075,
+    omega_loss_minimum=0.01,
+    sharpe_stddev_minimum=0.01,
+    sortino_downside_minimum=0.01,
+    statistical_confidence_minimum_n_ceil=60,
+    annual_risk_free_decimal=0.0419,
+    drawdown_maxvalue_percentage=10,
     use_weighting=False,
     bypass_confidence=False,
     daily_checkpoints=2,
@@ -69,10 +81,22 @@ def _prove_worker(
         from .proof_generator import generate_proof
 
         result = generate_proof(
-            miner_data,
-            hotkey,
+            data=miner_data,
+            daily_pnl=daily_pnl,
+            miner_hotkey=hotkey,
             verbose=verbose,
             annual_risk_free_percentage=annual_risk_free_percentage,
+            calmar_ratio_cap=calmar_ratio_cap,
+            days_in_year_crypto=days_in_year_crypto,
+            weighted_average_decay_max=weighted_average_decay_max,
+            weighted_average_decay_min=weighted_average_decay_min,
+            weighted_average_decay_rate=weighted_average_decay_rate,
+            omega_loss_minimum=omega_loss_minimum,
+            sharpe_stddev_minimum=sharpe_stddev_minimum,
+            sortino_downside_minimum=sortino_downside_minimum,
+            statistical_confidence_minimum_n_ceil=statistical_confidence_minimum_n_ceil,
+            annual_risk_free_decimal=annual_risk_free_decimal,
+            drawdown_maxvalue_percentage=drawdown_maxvalue_percentage,
             use_weighting=use_weighting,
             bypass_confidence=bypass_confidence,
             daily_checkpoints=daily_checkpoints,
@@ -151,9 +175,21 @@ async def prove(
 
 def prove_sync(
     miner_data,
-    hotkey,
+    daily_pnl=None,
+    hotkey=None,
     verbose=False,
     annual_risk_free_percentage=4.19,
+    calmar_ratio_cap=10,
+    days_in_year_crypto=365,
+    weighted_average_decay_max=1.0,
+    weighted_average_decay_min=0.15,
+    weighted_average_decay_rate=0.075,
+    omega_loss_minimum=0.01,
+    sharpe_stddev_minimum=0.01,
+    sortino_downside_minimum=0.01,
+    statistical_confidence_minimum_n_ceil=60,
+    annual_risk_free_decimal=0.0419,
+    drawdown_maxvalue_percentage=10,
     use_weighting=False,
     bypass_confidence=False,
     daily_checkpoints=2,
@@ -172,11 +208,23 @@ def prove_sync(
     """
     return _prove_worker(
         miner_data,
-        hotkey,
-        verbose,
-        annual_risk_free_percentage,
-        use_weighting,
-        bypass_confidence,
-        daily_checkpoints,
-        account_size,
+        daily_pnl=daily_pnl,
+        hotkey=hotkey,
+        verbose=verbose,
+        annual_risk_free_percentage=annual_risk_free_percentage,
+        calmar_ratio_cap=calmar_ratio_cap,
+        days_in_year_crypto=days_in_year_crypto,
+        weighted_average_decay_max=weighted_average_decay_max,
+        weighted_average_decay_min=weighted_average_decay_min,
+        weighted_average_decay_rate=weighted_average_decay_rate,
+        omega_loss_minimum=omega_loss_minimum,
+        sharpe_stddev_minimum=sharpe_stddev_minimum,
+        sortino_downside_minimum=sortino_downside_minimum,
+        statistical_confidence_minimum_n_ceil=statistical_confidence_minimum_n_ceil,
+        annual_risk_free_decimal=annual_risk_free_decimal,
+        drawdown_maxvalue_percentage=drawdown_maxvalue_percentage,
+        use_weighting=use_weighting,
+        bypass_confidence=bypass_confidence,
+        daily_checkpoints=daily_checkpoints,
+        account_size=account_size,
     )

{proof_of_portfolio-0.0.94 → proof_of_portfolio-0.0.96}/proof_of_portfolio/_version.py

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

{proof_of_portfolio-0.0.94 → proof_of_portfolio-0.0.96}/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,7 +10,7 @@ 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,
@@ -19,18 +18,21 @@ pub fn calmar(
     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;
+            let raw_calmar = base_return_percentage * drawdown_normalization_factor;
             if raw_calmar > calmar_cap {
                 calmar_cap * RATIO_SCALE_FACTOR
             } else {
@@ -67,6 +69,8 @@ fn test_calmar_normal_case() {
         variance_val,
         ann_excess,
         1,
+        365,
+        10,
     );
     assert(result != 0);
 }
@@ -92,6 +96,8 @@ fn test_calmar_insufficient_data() {
         variance_val,
         ann_excess,
         1,
+        365,
+        10,
     );
     assert(result == 0);
 }
@@ -118,6 +124,8 @@ fn test_calmar_exactly_30_days() {
         variance_val,
         ann_excess,
         1,
+        365,
+        10,
     );
     assert(result != 0);
 }
@@ -144,6 +152,8 @@ fn test_calmar_negative_returns() {
         variance_val,
         ann_excess,
         1,
+        365,
+        10,
     );
     assert(result != 0);
 }

{proof_of_portfolio-0.0.94 → proof_of_portfolio-0.0.96}/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
@@ -44,10 +44,10 @@ pub fn omega(
                 0
             };
 
-            let effective_denominator = if mean_neg >= OMEGA_LOSS_MINIMUM {
+            let effective_denominator = if mean_neg >= omega_loss_min {
                 mean_neg
             } else {
-                OMEGA_LOSS_MINIMUM
+                omega_loss_min
             };
             (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
         } else {
@@ -79,10 +79,10 @@ pub fn omega(
                 0
             };
 
-            let effective_denominator = if mean_neg >= OMEGA_LOSS_MINIMUM {
+            let effective_denominator = if mean_neg >= omega_loss_min {
                 mean_neg
             } else {
-                OMEGA_LOSS_MINIMUM
+                omega_loss_min
             };
             (mean_pos * RATIO_SCALE_FACTOR) / effective_denominator
         }
@@ -97,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);
 }
 
@@ -109,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);
 }
 
@@ -122,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);
 }
 
@@ -134,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-0.0.94 → proof_of_portfolio-0.0.96}/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-0.0.94 → proof_of_portfolio-0.0.96}/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-0.0.94 → proof_of_portfolio-0.0.96}/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-0.0.94 → proof_of_portfolio-0.0.96}/proof_of_portfolio/circuits/src/main.nr

@@ -8,25 +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;
@@ -93,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,
@@ -135,7 +119,7 @@ fn main(
     let calmar_ratio = calmar(
         returns_array,
         n_returns,
-        risk_free_rate,
+        annual_risk_free,
         weights,
         use_weighting,
         bypass_confidence,
@@ -143,6 +127,8 @@ fn main(
         variance_val,
         ann_excess_return_val,
         calmar_cap,
+        days_in_year,
+        drawdown_max_percent,
     );
     let omega_ratio = omega(
         returns_array,
@@ -150,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,