proof-of-portfolio 0.0.44__tar.gz → 0.0.46__tar.gz

{proof_of_portfolio-0.0.44 → proof_of_portfolio-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.44
+Version: 0.0.46
 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.44 → proof_of_portfolio-0.0.46}/proof_of_portfolio/_version.py

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

proof_of_portfolio-0.0.46/proof_of_portfolio/min_metrics.py

@@ -0,0 +1,390 @@
+import math
+import numpy as np
+from scipy.stats import ttest_1samp
+from typing import Union
+
+
+class MinMetrics:
+    """
+    Minimal metrics implementation that matches the proprietary trading network
+    validator metrics calculations exactly. Used for comparing ZK circuit outputs
+    against Python calculations on the same input data.
+    """
+
+    # Constants from ValiConfig
+    WEIGHTED_AVERAGE_DECAY_RATE = 0.075
+    WEIGHTED_AVERAGE_DECAY_MIN = 0.15
+    WEIGHTED_AVERAGE_DECAY_MAX = 1.0
+    ANNUAL_RISK_FREE_PERCENTAGE = 4.19
+    ANNUAL_RISK_FREE_DECIMAL = ANNUAL_RISK_FREE_PERCENTAGE / 100
+    DAYS_IN_YEAR_CRYPTO = 365
+    DAYS_IN_YEAR_FOREX = 252
+
+    # Metric-specific constants
+    SHARPE_STDDEV_MINIMUM = 0.01
+    STATISTICAL_CONFIDENCE_MINIMUM_N = 60
+    SHARPE_NOCONFIDENCE_VALUE = -100
+    OMEGA_LOSS_MINIMUM = 0.01
+    OMEGA_NOCONFIDENCE_VALUE = -100
+    SORTINO_DOWNSIDE_MINIMUM = 0.01
+    SORTINO_NOCONFIDENCE_VALUE = -100
+    CALMAR_RATIO_CAP = 1000
+    CALMAR_NOCONFIDENCE_VALUE = -100
+    STATISTICAL_CONFIDENCE_NOCONFIDENCE_VALUE = -100
+
+    @staticmethod
+    def log_risk_free_rate(days_in_year: int) -> float:
+        if days_in_year is None or days_in_year <= 0:
+            return np.inf
+        return math.log(1 + MinMetrics.ANNUAL_RISK_FREE_DECIMAL) / days_in_year
+
+    @staticmethod
+    def weighting_distribution(
+        log_returns: Union[list[float], np.ndarray]
+    ) -> np.ndarray:
+        """
+        Returns the weighting distribution that decays from max_weight to min_weight
+        using the configured decay rate
+        """
+        max_weight = MinMetrics.WEIGHTED_AVERAGE_DECAY_MAX
+        min_weight = MinMetrics.WEIGHTED_AVERAGE_DECAY_MIN
+        decay_rate = MinMetrics.WEIGHTED_AVERAGE_DECAY_RATE
+
+        if len(log_returns) < 1:
+            return np.ones(0)
+
+        weighting_distribution_days = np.arange(0, len(log_returns))
+
+        # Calculate decay from max to min
+        weight_range = max_weight - min_weight
+        decay_values = min_weight + (
+            weight_range * np.exp(-decay_rate * weighting_distribution_days)
+        )
+
+        return decay_values[::-1][-len(log_returns) :]
+
+    @staticmethod
+    def average(
+        log_returns: Union[list[float], np.ndarray],
+        weighting=False,
+        indices: Union[list[int], None] = None,
+    ) -> float:
+        """
+        Returns the mean of the log returns
+        """
+        if len(log_returns) == 0:
+            return 0.0
+
+        weighting_distribution = MinMetrics.weighting_distribution(log_returns)
+
+        if indices is not None and len(indices) != 0:
+            indices = [i for i in indices if i in range(len(log_returns))]
+            log_returns = [log_returns[i] for i in indices]
+            weighting_distribution = [weighting_distribution[i] for i in indices]
+
+        if weighting:
+            avg_value = np.average(log_returns, weights=weighting_distribution)
+        else:
+            avg_value = np.mean(log_returns)
+
+        return float(avg_value)
+
+    @staticmethod
+    def variance(
+        log_returns: list[float],
+        ddof: int = 1,
+        weighting=False,
+        indices: Union[list[int], None] = None,
+    ) -> float:
+        """
+        Returns the variance of the log returns
+        """
+        if len(log_returns) == 0:
+            return 0.0
+
+        window = len(indices) if indices is not None else len(log_returns)
+        if window < ddof + 1:
+            return np.inf
+
+        return MinMetrics.average(
+            (
+                np.array(log_returns)
+                - MinMetrics.average(log_returns, weighting=weighting, indices=indices)
+            )
+            ** 2,
+            weighting=weighting,
+            indices=indices,
+        )
+
+    @staticmethod
+    def ann_excess_return(
+        log_returns: list[float],
+        weighting=False,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+    ) -> float:
+        """
+        Calculates annualized excess return using mean daily log returns and mean daily 1yr risk free rate.
+        """
+        annual_risk_free_rate = MinMetrics.ANNUAL_RISK_FREE_DECIMAL
+
+        if len(log_returns) == 0:
+            return 0.0
+
+        # Annualize the mean daily excess returns
+        annualized_excess_return = (
+            MinMetrics.average(log_returns, weighting=weighting) * days_in_year
+        ) - annual_risk_free_rate
+        return annualized_excess_return
+
+    @staticmethod
+    def ann_volatility(
+        log_returns: list[float],
+        ddof: int = 1,
+        weighting=False,
+        indices: list[int] = None,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+    ) -> float:
+        """
+        Calculates annualized volatility ASSUMING DAILY OBSERVATIONS
+        """
+        if indices is None:
+            indices = list(range(len(log_returns)))
+
+        # Annualize volatility of the daily log returns assuming sample variance
+        window = len(indices)
+        if window < ddof + 1:
+            return np.inf
+
+        annualized_volatility = np.sqrt(
+            MinMetrics.variance(
+                log_returns, ddof=ddof, weighting=weighting, indices=indices
+            )
+            * days_in_year
+        )
+
+        return float(annualized_volatility)
+
+    @staticmethod
+    def ann_downside_volatility(
+        log_returns: list[float],
+        target: int = None,
+        weighting=False,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+    ) -> float:
+        """
+        Calculates annualized downside volatility
+        """
+        if target is None:
+            target = MinMetrics.log_risk_free_rate(days_in_year=days_in_year)
+
+        indices = [i for i, log_return in enumerate(log_returns) if log_return < target]
+        return MinMetrics.ann_volatility(
+            log_returns, weighting=weighting, indices=indices, days_in_year=days_in_year
+        )
+
+    @staticmethod
+    def daily_max_drawdown(log_returns: list[float]) -> float:
+        """
+        Calculates the daily maximum drawdown
+        """
+        if len(log_returns) == 0:
+            return 0.0
+
+        # More efficient implementation using cumulative sum of log returns
+        cumulative_log_returns = np.cumsum(log_returns)
+
+        # Maximum cumulative log return at each point
+        running_max_log = np.maximum.accumulate(cumulative_log_returns)
+
+        # Drawdown = 1 - exp(current - peak)
+        # This gives us the percentage decline from the peak
+        drawdowns = 1 - np.exp(cumulative_log_returns - running_max_log)
+
+        # Find the maximum drawdown
+        max_drawdown = np.max(drawdowns)
+
+        return max_drawdown
+
+    @staticmethod
+    def sharpe(
+        log_returns: list[float],
+        bypass_confidence: bool = False,
+        weighting: bool = False,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+        **kwargs,
+    ) -> float:
+        """
+        Calculates the Sharpe ratio
+        """
+        # Need a large enough sample size
+        if len(log_returns) < MinMetrics.STATISTICAL_CONFIDENCE_MINIMUM_N:
+            if not bypass_confidence:
+                return MinMetrics.SHARPE_NOCONFIDENCE_VALUE
+
+        # Hyperparameter
+        min_std_dev = MinMetrics.SHARPE_STDDEV_MINIMUM
+
+        excess_return = MinMetrics.ann_excess_return(
+            log_returns, weighting=weighting, days_in_year=days_in_year
+        )
+        volatility = MinMetrics.ann_volatility(
+            log_returns, weighting=weighting, days_in_year=days_in_year
+        )
+
+        return float(excess_return / max(volatility, min_std_dev))
+
+    @staticmethod
+    def omega(
+        log_returns: list[float],
+        bypass_confidence: bool = False,
+        weighting: bool = False,
+        **kwargs,
+    ) -> float:
+        """
+        Calculates the Omega ratio
+        """
+        # Need a large enough sample size
+        if len(log_returns) < MinMetrics.STATISTICAL_CONFIDENCE_MINIMUM_N:
+            if not bypass_confidence:
+                return MinMetrics.OMEGA_NOCONFIDENCE_VALUE
+
+        if weighting:
+            weighing_array = MinMetrics.weighting_distribution(log_returns)
+
+            positive_indices = []
+            negative_indices = []
+            product_sum_positive = product_sum_negative = 0
+            sum_of_weights_positive = sum_of_weights_negative = (
+                MinMetrics.OMEGA_LOSS_MINIMUM
+            )
+
+            for c, log_return in enumerate(log_returns):
+                if log_return > 0:
+                    positive_indices.append(c)
+                else:
+                    negative_indices.append(c)
+
+            log_return_arr = np.array(log_returns)
+
+            if len(positive_indices) > 0:
+                positive_indices_arr = np.array(positive_indices)
+                sum_of_weights_positive = max(
+                    np.sum(weighing_array[positive_indices_arr]),
+                    MinMetrics.OMEGA_LOSS_MINIMUM,
+                )
+
+                product_sum_positive = np.sum(
+                    np.multiply(
+                        log_return_arr[positive_indices_arr],
+                        weighing_array[positive_indices_arr],
+                    )
+                )
+
+            if len(negative_indices) > 0:
+                negative_indices_arr = np.array(negative_indices)
+                sum_of_weights_negative = max(
+                    np.sum(weighing_array[negative_indices_arr]),
+                    MinMetrics.OMEGA_LOSS_MINIMUM,
+                )
+                product_sum_negative = np.sum(
+                    np.multiply(
+                        log_return_arr[negative_indices_arr],
+                        weighing_array[negative_indices_arr],
+                    )
+                )
+
+            positive_sum = product_sum_positive * sum_of_weights_negative
+            negative_sum = product_sum_negative * sum_of_weights_positive
+
+        else:
+            positive_sum = 0
+            negative_sum = 0
+
+            for log_return in log_returns:
+                if log_return > 0:
+                    positive_sum += log_return
+                else:
+                    negative_sum += log_return
+
+        numerator = positive_sum
+        denominator = max(abs(negative_sum), MinMetrics.OMEGA_LOSS_MINIMUM)
+
+        return float(numerator / denominator)
+
+    @staticmethod
+    def statistical_confidence(
+        log_returns: list[float], bypass_confidence: bool = False, **kwargs
+    ) -> float:
+        """
+        Calculates statistical confidence using t-test
+        """
+        # Impose a minimum sample size on the miner
+        if len(log_returns) < MinMetrics.STATISTICAL_CONFIDENCE_MINIMUM_N:
+            if not bypass_confidence or len(log_returns) < 2:
+                return MinMetrics.STATISTICAL_CONFIDENCE_NOCONFIDENCE_VALUE
+
+        # Also now check for zero variance condition
+        zero_variance_condition = bool(np.isclose(np.var(log_returns), 0))
+        if zero_variance_condition:
+            return MinMetrics.STATISTICAL_CONFIDENCE_NOCONFIDENCE_VALUE
+
+        res = ttest_1samp(log_returns, 0, alternative="greater")
+        return float(res.statistic)
+
+    @staticmethod
+    def sortino(
+        log_returns: list[float],
+        bypass_confidence: bool = False,
+        weighting: bool = False,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+        **kwargs,
+    ) -> float:
+        """
+        Calculates the Sortino ratio
+        """
+        # Need a large enough sample size
+        if len(log_returns) < MinMetrics.STATISTICAL_CONFIDENCE_MINIMUM_N:
+            if not bypass_confidence:
+                return MinMetrics.SORTINO_NOCONFIDENCE_VALUE
+
+        # Hyperparameter
+        min_downside = MinMetrics.SORTINO_DOWNSIDE_MINIMUM
+
+        # Sortino ratio is calculated as the mean of the returns divided by the standard deviation of the negative returns
+        excess_return = MinMetrics.ann_excess_return(
+            log_returns, weighting=weighting, days_in_year=days_in_year
+        )
+        downside_volatility = MinMetrics.ann_downside_volatility(
+            log_returns, weighting=weighting, days_in_year=days_in_year
+        )
+
+        return float(excess_return / max(downside_volatility, min_downside))
+
+    @staticmethod
+    def calmar(
+        log_returns: list[float],
+        bypass_confidence: bool = False,
+        weighting: bool = False,
+        days_in_year: int = DAYS_IN_YEAR_CRYPTO,
+        **kwargs,
+    ) -> float:
+        """
+        Calculates the Calmar ratio (simplified version without ledger dependency)
+        """
+        # Positional Component
+        if len(log_returns) < 30:  # Simplified confidence check
+            if not bypass_confidence:
+                return MinMetrics.CALMAR_NOCONFIDENCE_VALUE
+
+        base_return_percentage = (
+            MinMetrics.average(log_returns, weighting=weighting) * days_in_year * 100
+        )
+        max_drawdown = MinMetrics.daily_max_drawdown(log_returns)
+
+        # Simplified risk normalization factor (without full ledger context)
+        drawdown_normalization_factor = 1.0 / max(max_drawdown, 0.01)
+
+        raw_calmar = float(base_return_percentage * drawdown_normalization_factor)
+        return min(
+            raw_calmar, MinMetrics.CALMAR_RATIO_CAP
+        )  # Cap the Calmar ratio to prevent extreme values

{proof_of_portfolio-0.0.44 → proof_of_portfolio-0.0.46}/proof_of_portfolio/proof_generator.py

@@ -3,6 +3,8 @@ import toml
 import re
 import os
 import time
+from .min_metrics import MinMetrics
+import math
 
 # Constants for the circuit
 MAX_CHECKPOINTS = 200
@@ -185,10 +187,10 @@ def field_to_toml_value(f):
     return str(f)
 
 
-def run_bb_prove_and_verify(circuit_dir, circuit_name="main"):
+def run_bb_prove(circuit_dir):
     """
-    Runs barretenberg proving and verification.
-    Returns proof generation time and verification status.
+    Runs barretenberg proving.
+    Returns proof generation time and status.
     """
     print("\n--- Running Barretenberg Proof Generation ---")
 
@@ -212,7 +214,6 @@ def run_bb_prove_and_verify(circuit_dir, circuit_name="main"):
         circuit_file = os.path.join(target_dir, "circuits.json")
 
         proof_file = proof_dir
-        vk_file = os.path.join(vk_dir, "vk")
 
         prove_start = time.time()
         prove_result = subprocess.run(
@@ -242,25 +243,7 @@ def run_bb_prove_and_verify(circuit_dir, circuit_name="main"):
             return None, False
 
         print(f"Proof generated in {prove_time:.3f}s")
-
-        public_inputs_file = os.path.join(proof_dir, "public_inputs")
-        verify_result = subprocess.run(
-            ["bb", "verify", "-p", proof_file, "-k", vk_file, "-i", public_inputs_file],
-            capture_output=True,
-            text=True,
-            cwd=circuit_dir,
-        )
-
-        verification_success = verify_result.returncode == 0
-
-        if verification_success:
-            print("✅ Proof verification: PASSED")
-        else:
-            print("❌ Proof verification: FAILED")
-            print(verify_result.stdout)
-            print(verify_result.stderr)
-
-        return prove_time, verification_success
+        return prove_time, True
 
     except Exception as e:
         print(f"Error during proof generation/verification: {e}")
@@ -587,7 +570,47 @@ def generate_proof(data=None, miner_hotkey=None, verbose=None):
     sortino_ratio_scaled = sortino_ratio_raw / SCALING_FACTOR
     stat_confidence_scaled = stat_confidence_raw / SCALING_FACTOR
 
-    prove_time, verification_success = run_bb_prove_and_verify(main_circuit_dir)
+    prove_time, verification_success = run_bb_prove(main_circuit_dir)
+
+    # Calculate MinMetrics (Python) for comparison with ZK circuit
+    try:
+
+        # Extract daily log returns from checkpoint data (same as ZK circuit)
+        daily_log_returns = []
+        for cp in cps:
+            if cp["gain"] > 0:
+                daily_log_returns.append(math.log(1 + cp["gain"]))
+            elif cp["loss"] > 0:
+                daily_log_returns.append(math.log(1 - cp["loss"]))
+            else:
+                daily_log_returns.append(0.0)
+
+        if len(daily_log_returns) > 0:
+            python_avg_daily_pnl = MinMetrics.average(daily_log_returns)
+            python_sharpe = MinMetrics.sharpe(daily_log_returns, bypass_confidence=True)
+            python_max_drawdown = MinMetrics.daily_max_drawdown(daily_log_returns)
+            python_calmar = MinMetrics.calmar(daily_log_returns, bypass_confidence=True)
+            python_omega = MinMetrics.omega(daily_log_returns, bypass_confidence=True)
+            python_sortino = MinMetrics.sortino(
+                daily_log_returns, bypass_confidence=True
+            )
+            python_stat_confidence = MinMetrics.statistical_confidence(
+                daily_log_returns, bypass_confidence=True
+            )
+        else:
+            python_avg_daily_pnl = python_sharpe = python_max_drawdown = (
+                python_calmar
+            ) = python_omega = python_sortino = python_stat_confidence = 0.0
+
+    except Exception as e:
+        if verbose:
+            print(f"Warning: Could not calculate Python MinMetrics: {e}")
+            import traceback
+
+            print(f"Traceback: {traceback.format_exc()}")
+        python_avg_daily_pnl = python_sharpe = python_max_drawdown = python_calmar = (
+            python_omega
+        ) = python_sortino = python_stat_confidence = "N/A"
 
     # Always print key production info: hotkey and verification status
     print(f"Hotkey: {miner_hotkey}")
@@ -601,10 +624,41 @@ def generate_proof(data=None, miner_hotkey=None, verbose=None):
     print(f"Omega Ratio: {omega_ratio_scaled:.9f}")
     print(f"Sortino Ratio: {sortino_ratio_scaled:.9f}")
     print(f"Statistical Confidence: {stat_confidence_scaled:.9f}")
-    if prove_time is not None:
+
+    # Print Python MinMetrics for comparison
+    print("\n--- PYTHON MINMETRICS ---")
+    if isinstance(python_avg_daily_pnl, (int, float)):
+        print(f"Average Daily PnL: {python_avg_daily_pnl:.9f}")
+    else:
+        print(f"Average Daily PnL: {python_avg_daily_pnl}")
+    if isinstance(python_sharpe, (int, float)):
+        print(f"Sharpe Ratio: {python_sharpe:.9f}")
+    else:
+        print(f"Sharpe Ratio: {python_sharpe}")
+    if isinstance(python_max_drawdown, (int, float)):
         print(
-            f"Proof verification: {'✅ PASSED' if verification_success else '❌ FAILED'}"
+            f"Max Drawdown: {python_max_drawdown:.9f} ({python_max_drawdown * 100:.6f}%)"
         )
+    else:
+        print(f"Max Drawdown: {python_max_drawdown}")
+    if isinstance(python_calmar, (int, float)):
+        print(f"Calmar Ratio: {python_calmar:.9f}")
+    else:
+        print(f"Calmar Ratio: {python_calmar}")
+    if isinstance(python_omega, (int, float)):
+        print(f"Omega Ratio: {python_omega:.9f}")
+    else:
+        print(f"Omega Ratio: {python_omega}")
+    if isinstance(python_sortino, (int, float)):
+        print(f"Sortino Ratio: {python_sortino:.9f}")
+    else:
+        print(f"Sortino Ratio: {python_sortino}")
+    if isinstance(python_stat_confidence, (int, float)):
+        print(f"Statistical Confidence: {python_stat_confidence:.9f}")
+    else:
+        print(f"Statistical Confidence: {python_stat_confidence}")
+    if prove_time is not None:
+        print(f"Proof generated in {prove_time}s")
     else:
         print("Proof generation failed")
 

{proof_of_portfolio-0.0.44 → proof_of_portfolio-0.0.46}/proof_of_portfolio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.44
+Version: 0.0.46
 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.44 → proof_of_portfolio-0.0.46}/proof_of_portfolio.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ proof_of_portfolio/__init__.py
 proof_of_portfolio/_version.py
 proof_of_portfolio/analyze_data.py
 proof_of_portfolio/main.py
+proof_of_portfolio/min_metrics.py
 proof_of_portfolio/miner.py
 proof_of_portfolio/post_install.py
 proof_of_portfolio/proof_generator.py

{proof_of_portfolio-0.0.44 → proof_of_portfolio-0.0.46}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "proof-of-portfolio"
-version = "0.0.44"
+version = "0.0.46"
 description = "Zero-Knowledge Proof framework for verifiable, private portfolio performance metrics"
 readme = "README.md"
 authors = [{ name = "Inference Labs, Inc.", email = "info@inferencelabs.com" }]