proof-of-portfolio 0.0.45__py3-none-any.whl → 0.0.47__py3-none-any.whl

proof_of_portfolio/__init__.py

@@ -52,14 +52,14 @@ def requires_dependencies(func):
     return wrapper
 
 
-def _prove_worker(miner_data, hotkey):
+def _prove_worker(miner_data, hotkey, verbose=False):
     """
     Worker function to run proof generation in a separate process.
     """
     try:
         from .proof_generator import generate_proof
 
-        result = generate_proof(miner_data, hotkey)
+        result = generate_proof(miner_data, hotkey, verbose=verbose)
 
         return {
             "status": "success",
@@ -81,13 +81,14 @@ def _prove_worker(miner_data, hotkey):
 
 
 @requires_dependencies
-async def prove(miner_data, hotkey):
+async def prove(miner_data, hotkey, verbose=False):
     """
     Generate zero-knowledge proof for miner portfolio data asynchronously.
 
     Args:
         miner_data: Dictionary containing perf_ledgers and positions for the miner
         hotkey: Miner's hotkey
+        verbose: Boolean to control logging verbosity
 
     Returns:
         Dictionary with proof results including status, portfolio_metrics, etc.
@@ -97,7 +98,7 @@ async def prove(miner_data, hotkey):
     with ProcessPoolExecutor(max_workers=1) as executor:
         try:
             result = await loop.run_in_executor(
-                executor, _prove_worker, miner_data, hotkey
+                executor, _prove_worker, miner_data, hotkey, verbose
             )
             return result
         except Exception as e:
@@ -108,15 +109,16 @@ async def prove(miner_data, hotkey):
             }
 
 
-def prove_sync(miner_data, hotkey):
+def prove_sync(miner_data, hotkey, verbose=False):
     """
     Synchronous wrapper for the prove function for backward compatibility.
 
     Args:
         miner_data: Dictionary containing perf_ledgers and positions for the miner
         hotkey: Miner's hotkey
+        verbose: Boolean to control logging verbosity
 
     Returns:
         Dictionary with proof results including status, portfolio_metrics, etc.
     """
-    return _prove_worker(miner_data, hotkey)
+    return _prove_worker(miner_data, hotkey, verbose)

proof_of_portfolio/_version.py

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

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/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
@@ -570,6 +572,46 @@ def generate_proof(data=None, miner_hotkey=None, verbose=None):
 
     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}")
     print(f"Orders processed: {signals_count}")
@@ -582,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.45.dist-info → proof_of_portfolio-0.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.45
+Version: 0.0.47
 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.45.dist-info → proof_of_portfolio-0.0.47.dist-info}/RECORD

@@ -1,10 +1,11 @@
-proof_of_portfolio/__init__.py,sha256=ymGh1kUyiNXBTZr3pzs34E9ndABq_knWBIW3Dl5tdEI,3392
-proof_of_portfolio/_version.py,sha256=ox0oMfi5CduaU3I9Tx5cfYVIE5VXC6ZPUoY23fVdhUc,66
+proof_of_portfolio/__init__.py,sha256=cb8b_zhdFvxvpq7I5g3bP5RM7yAmD8kv4lrcrhD3-1w,3580
+proof_of_portfolio/_version.py,sha256=p0btOyieR5oGcDyMaFDVp1gIO7fOoskkRSjuDGVhg7k,66
 proof_of_portfolio/analyze_data.py,sha256=t80ueFtBUzcWTrPiamiC1HXvw5Em-151zXJx0cCk8sQ,3709
 proof_of_portfolio/main.py,sha256=JbvdAK7B6hw2sQdjT0EVCiglCQZgN3urKphdeWcW43w,30994
+proof_of_portfolio/min_metrics.py,sha256=BAEpJdqYoR6RjkqX-M5BUTWlurSADvxAHuLFznH3AT8,13196
 proof_of_portfolio/miner.py,sha256=eGXcPMRQVAepzXJj1ePbbDAf-72E9Yj9n-yfP7GohLw,17177
 proof_of_portfolio/post_install.py,sha256=e-57Z_h-svQdjA8ibsM985MXmdV6-KLyymQm3Cgu8YM,5654
-proof_of_portfolio/proof_generator.py,sha256=9j1EQ80qP8h63L26jj18J5wnyH9QSsI_N3T4VFy9Y4M,24213
+proof_of_portfolio/proof_generator.py,sha256=U0ZXkoKJasj-i6reCCx8TEDXcmzjsetkV48KhTTao6Q,27317
 proof_of_portfolio/signal_processor.py,sha256=JQjnkMJEbv_MWIgKNrjKjrBIcIT5pAkAlCneEOGsqT0,6702
 proof_of_portfolio/validator.py,sha256=kt3BeaXOffv-h52PZBKV1YHUWtiGsnPte16m3EJpITY,3839
 proof_of_portfolio/circuits/Nargo.toml,sha256=D6ycN7H3xiTcWHH5wz4qXYTXn7Ht0WgPr9w4B7d8ZGw,141
@@ -79,8 +80,8 @@ proof_of_portfolio/tree_generator/Nargo.toml,sha256=O6iSvb-EpV0XcETiDxNgSp7XKNiY
 proof_of_portfolio/tree_generator/target.gz,sha256=7LPzAb8JvKWSDOzyW5vI_6NKQ0aB9cb31q4CWbchFSw,308614
 proof_of_portfolio/tree_generator/src/main.nr,sha256=zHG_0OphqSROyeVc7yTSEULg4bYS8B-LsmvTzTl8aW4,2393
 proof_of_portfolio/tree_generator/target/tree_generator.json,sha256=M_bI5et5ncgILJ_Czen4ZsGfWHwComEVxMLQpIWmN1k,1540889
-proof_of_portfolio-0.0.45.dist-info/METADATA,sha256=hQ5SDJlOD608p8mmdP7lDdUe-wlz9eCPT-Fjddn8j0E,7051
-proof_of_portfolio-0.0.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-proof_of_portfolio-0.0.45.dist-info/entry_points.txt,sha256=KeLSJT_UJtr1WiLTkhlGqWQuPKbO_ylgj6OXOC2gJV4,53
-proof_of_portfolio-0.0.45.dist-info/top_level.txt,sha256=sY5xZnE6YuiISK1IuRHPfl71NV0vXO3N3YA2li_SPXU,19
-proof_of_portfolio-0.0.45.dist-info/RECORD,,
+proof_of_portfolio-0.0.47.dist-info/METADATA,sha256=TyZe0lNQcrp9QRAyXRTo_NeFBDwceDc9zv-9-d0KyNE,7051
+proof_of_portfolio-0.0.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+proof_of_portfolio-0.0.47.dist-info/entry_points.txt,sha256=KeLSJT_UJtr1WiLTkhlGqWQuPKbO_ylgj6OXOC2gJV4,53
+proof_of_portfolio-0.0.47.dist-info/top_level.txt,sha256=sY5xZnE6YuiISK1IuRHPfl71NV0vXO3N3YA2li_SPXU,19
+proof_of_portfolio-0.0.47.dist-info/RECORD,,