proof-of-portfolio 0.0.80__tar.gz → 0.0.82__tar.gz

{proof_of_portfolio-0.0.80 → proof_of_portfolio-0.0.82}/PKG-INFO

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

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

{proof_of_portfolio-0.0.80 → proof_of_portfolio-0.0.82}/proof_of_portfolio/proof_generator.py

@@ -6,37 +6,38 @@ import time
 import json
 import bittensor as bt
 
-# Constants for the circuit
 MAX_DAYS = 120
 MAX_SIGNALS = 256
 MERKLE_DEPTH = 8
-ARRAY_SIZE = 256
 SCALING_FACTOR = 10**7
+RATIO_SCALE_FACTOR = 1_000_000
+PRIME = 21888242871839275222246405745257275088548364400416034343698204186575808495617
 
 
-def run_command(command, cwd, verbose=True):
-    """Executes a command in a given directory and returns the output."""
+def log_verbose(verbose, level, message):
+    if verbose:
+        getattr(bt.logging, level)(message)
+
+
+def get_attr(obj, attr):
+    """Get attribute from object or dictionary"""
+    return getattr(obj, attr) if hasattr(obj, attr) else obj[attr]
+
+
+def run_command(command, cwd):
     result = subprocess.run(command, capture_output=True, text=True, cwd=cwd)
     if result.returncode != 0:
-        if verbose:
-            bt.logging.error("Error:")
-            bt.logging.error(result.stdout)
-            bt.logging.error(result.stderr)
+        bt.logging.error(f"Command failed: {' '.join(command)}")
+        bt.logging.error(f"stdout: {result.stdout}")
+        bt.logging.error(f"stderr: {result.stderr}")
         raise RuntimeError(
             f"Command {' '.join(command)} failed with exit code {result.returncode}"
         )
     return result.stdout
 
 
-def parse_nargo_struct_output(output):
-    """
-    Parses the raw output of a nargo execute command that returns a struct.
-    """
-    if (
-        "[" in output
-        and "]" in output
-        and not ("MerkleTree" in output or "ReturnsData" in output)
-    ):
+def parse_circuit_output(output):
+    if "[" in output and "]" in output and "MerkleTree" not in output:
         array_matches = re.findall(r"\[([^\]]+)\]", output)
         if array_matches:
             array_content = array_matches[-1]
@@ -63,59 +64,37 @@ def parse_nargo_struct_output(output):
 
     if "MerkleTree" in output:
         tree = {}
-        try:
-            # Parse leaf_hashes
-            if "leaf_hashes:" in struct_content:
-                start = struct_content.find("leaf_hashes:") + len("leaf_hashes:")
-                end = struct_content.find(", path_elements:")
-                leaf_section = struct_content[start:end].strip()
-                if leaf_section.startswith("[") and leaf_section.endswith("]"):
-                    leaf_content = leaf_section[1:-1]
-                    tree["leaf_hashes"] = [
-                        x.strip() for x in leaf_content.split(",") if x.strip()
-                    ]
-
-            # Parse path_elements
-            if "path_elements:" in struct_content:
-                start = struct_content.find("path_elements:") + len("path_elements:")
-                end = struct_content.find(", path_indices:")
-                path_elem_section = struct_content[start:end].strip()
-                tree["path_elements"] = parse_nested_arrays(path_elem_section)
-
-            # Parse path_indices
-            if "path_indices:" in struct_content:
-                start = struct_content.find("path_indices:") + len("path_indices:")
-                end = struct_content.find(", root:")
-                path_idx_section = struct_content[start:end].strip()
-                tree["path_indices"] = parse_nested_arrays(path_idx_section)
-
-            # Parse root
-            if "root:" in struct_content:
-                start = struct_content.find("root:") + len("root:")
-                root_section = struct_content[start:].strip().rstrip("}")
-                tree["root"] = root_section.strip()
-
-            return tree
-        except Exception:
-            pass
+        if "path_elements:" in struct_content:
+            start = struct_content.find("path_elements:") + len("path_elements:")
+            end = struct_content.find(", path_indices:")
+            path_elem_section = struct_content[start:end].strip()
+            tree["path_elements"] = parse_nested_arrays(path_elem_section)
 
-    values = []
+        if "path_indices:" in struct_content:
+            start = struct_content.find("path_indices:") + len("path_indices:")
+            end = struct_content.find(", root:")
+            path_idx_section = struct_content[start:end].strip()
+            tree["path_indices"] = parse_nested_arrays(path_idx_section)
+
+        if "root:" in struct_content:
+            start = struct_content.find("root:") + len("root:")
+            root_section = struct_content[start:].strip().rstrip("}")
+            tree["root"] = root_section.strip()
+
+        return tree
 
+    values = []
     parts = re.split(r"[,\s]+", struct_content)
     for part in parts:
         part = part.strip("{}[](), \t\n\r")
         if not part:
             continue
-
-        # Check if it's a hex value
         if part.startswith("0x") and len(part) > 2:
             try:
                 values.append(str(int(part, 16)))
                 continue
             except ValueError:
                 pass
-
-        # Check if it's a negative number
         if part.lstrip("-").isdigit():
             values.append(part)
 
@@ -123,7 +102,6 @@ def parse_nargo_struct_output(output):
 
 
 def parse_nested_arrays(section):
-    """Helper function to parse nested array structures like [[...], [...]]"""
     if not section.strip().startswith("["):
         return []
 
@@ -134,116 +112,66 @@ def parse_nested_arrays(section):
     for char in section:
         if char == "[":
             depth += 1
-            if depth == 2:  # Start of inner array
+            if depth == 2:
                 current_array = ""
-            elif depth == 1:  # Start of outer array
+            elif depth == 1:
                 continue
         elif char == "]":
             depth -= 1
-            if depth == 1:  # End of inner array
+            if depth == 1:
                 if current_array.strip():
                     arrays.append(
                         [x.strip() for x in current_array.split(",") if x.strip()]
                     )
                 current_array = ""
-            elif depth == 0:  # End of outer array
+            elif depth == 0:
                 break
-        elif depth == 2:  # Inside inner array
+        elif depth == 2:
             current_array += char
 
     return arrays
 
 
-def parse_single_field_output(output):
-    """
-    Parses nargo output that contains a single field value.
-    Handles both new hex format (0x...) and old Field() format.
-    Returns the integer value, or None if no field found.
-    """
-    if "0x" in output:
-        hex_match = output.split("0x")[1].split()[0]
-        return int(hex_match, 16)
-
-    if "Field(" in output:
-        return int(output.split("Field(")[1].split(")")[0])
-
-    return None
-
-
 def field_to_toml_value(f):
-    """Converts a negative integer field to a proper field element string."""
-    PRIME = (
-        21888242871839275222246405745257275088548364400416034343698204186575808495617
-    )
-    if f < 0:
-        return str(f + PRIME)
-    return str(f)
+    return str(f + PRIME) if f < 0 else str(f)
 
 
-def run_bb_prove(circuit_dir):
-    """
-    Runs barretenberg proving.
-    Returns proof generation time and status.
-    """
-    print("\n--- Running Barretenberg Proof Generation ---")
+def field_to_signed_int(field_str):
+    val = int(field_str, 16) if field_str.startswith("0x") else int(field_str)
+    return val - 2**64 if val >= 2**63 else val
 
+
+def generate_bb_proof(circuit_dir):
     try:
         subprocess.run(["bb", "--version"], capture_output=True, check=True)
     except (subprocess.CalledProcessError, FileNotFoundError):
-        print(
-            "Error: bb (Barretenberg) not found. Please install it using \n`curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash`"
+        bt.logging.error(
+            "bb (Barretenberg) not found. Install with: curl -L https://raw.githubusercontent.com/AztecProtocol/aztec-packages/master/barretenberg/cpp/installation/install | bash"
         )
         return None, False
 
-    try:
-        target_dir = os.path.join(circuit_dir, "target")
-        proof_dir = os.path.join(circuit_dir, "proof")
-        vk_dir = os.path.join(circuit_dir, "vk")
+    target_dir = os.path.join(circuit_dir, "target")
+    proof_dir = os.path.join(circuit_dir, "proof")
+    os.makedirs(proof_dir, exist_ok=True)
 
-        os.makedirs(proof_dir, exist_ok=True)
-        os.makedirs(vk_dir, exist_ok=True)
+    witness_file = os.path.join(target_dir, "witness.gz")
+    circuit_file = os.path.join(target_dir, "circuits.json")
 
-        witness_file = os.path.join(target_dir, "witness.gz")
-        circuit_file = os.path.join(target_dir, "circuits.json")
-
-        proof_file = proof_dir
-
-        prove_start = time.time()
-        prove_result = subprocess.run(
-            ["bb", "prove", "-b", circuit_file, "-w", witness_file, "-o", proof_file],
-            capture_output=True,
-            text=True,
-            cwd=circuit_dir,
-        )
-        prove_time = time.time() - prove_start
-
-        if prove_result.returncode != 0:
-            print("bb prove failed:")
-            print(
-                " ".join(
-                    [
-                        "bb",
-                        "prove",
-                        "-b",
-                        circuit_file,
-                        "-w",
-                        witness_file,
-                        "-o",
-                        proof_file,
-                    ]
-                )
-            )
-            print(prove_result.stdout)
-            print(prove_result.stderr)
-            return None, False
-
-        print(f"Proof generated in {prove_time:.3f}s")
-        return prove_time, True
+    prove_start = time.time()
+    prove_result = subprocess.run(
+        ["bb", "prove", "-b", circuit_file, "-w", witness_file, "-o", proof_dir],
+        capture_output=True,
+        text=True,
+        cwd=circuit_dir,
+    )
+    prove_time = time.time() - prove_start
 
-    except Exception as e:
-        print(f"Error during proof generation/verification: {e}")
+    if prove_result.returncode != 0:
+        bt.logging.error(f"bb prove failed: {prove_result.stderr}")
         return None, False
 
+    return prove_time, True
+
 
 def generate_proof(
     data=None,
@@ -256,43 +184,26 @@ def generate_proof(
     witness_only=False,
     account_size=None,
 ):
-    """
-    Core proof generation logic.
-
-    Args:
-        data: Optional dictionary containing perf_ledgers and positions.
-              If None, will read from validator_checkpoint.json
-        miner_hotkey: The hotkey of the miner to generate proof for.
-                     If None and reading from file, uses first available hotkey
-        verbose: Optional boolean to control logging verbosity.
-                If None, auto-detects (demo mode = verbose, production = minimal)
-        annual_risk_free_percentage: Annual risk-free rate percentage (default 4.19)
-        use_weighting: Whether to use weighted calculations (default False)
-        bypass_confidence: Whether to bypass confidence thresholds (default False)
-        daily_checkpoints: Number of checkpoints expected per day (default 2)
-        witness_only: If True, skip barretenberg proof generation for faster testing (default False)
-
-    Returns:
-        Dictionary with proof results including status, portfolio_metrics, etc.
-    """
-    bt.logging.info(
-        f"generate_proof called with verbose={verbose}, miner_hotkey={miner_hotkey[:8] if miner_hotkey else None}"
-    )
-
-    # Auto-detect mode: demo mode if reading from file, production if data provided
     is_demo_mode = data is None
     if verbose is None:
         verbose = is_demo_mode
 
-    bt.logging.info(
-        f"After auto-detect: verbose={verbose}, is_demo_mode={is_demo_mode}"
+    log_verbose(
+        verbose,
+        "info",
+        f"generate_proof called with miner_hotkey={miner_hotkey[:8] if miner_hotkey else None}",
+    )
+    log_verbose(
+        verbose,
+        "info",
+        f"Mode: {'Demo' if is_demo_mode else 'Production'}, verbose={verbose}",
     )
 
     try:
         if data is None:
-            if verbose:
-                bt.logging.info("Loading data from validator_checkpoint.json...")
-
+            log_verbose(
+                verbose, "info", "Loading data from validator_checkpoint.json..."
+            )
             with open("validator_checkpoint.json", "r") as f:
                 data = json.load(f)
     except Exception as e:
@@ -300,13 +211,13 @@ def generate_proof(
 
     if miner_hotkey is None:
         miner_hotkey = list(data["perf_ledgers"].keys())[0]
-        if verbose:
-            bt.logging.info(
-                f"No hotkey specified, using first available: {miner_hotkey}"
-            )
+        log_verbose(
+            verbose,
+            "info",
+            f"No hotkey specified, using first available: {miner_hotkey}",
+        )
     else:
-        if verbose:
-            bt.logging.info(f"Using specified hotkey: {miner_hotkey}")
+        log_verbose(verbose, "info", f"Using specified hotkey: {miner_hotkey}")
 
     if miner_hotkey not in data["perf_ledgers"]:
         raise ValueError(
@@ -314,18 +225,18 @@ def generate_proof(
         )
 
     positions = data["positions"][miner_hotkey]["positions"]
-    if verbose:
-        bt.logging.info("Preparing circuit inputs...")
+    log_verbose(verbose, "info", "Preparing circuit inputs...")
 
     # Use daily returns calculated by PTN
     daily_log_returns = data.get("daily_returns", [])
     n_returns = len(daily_log_returns)
 
     if n_returns > MAX_DAYS:
-        if verbose:
-            bt.logging.warning(
-                f"Warning: Miner has {n_returns} daily returns, but circuit only supports {MAX_DAYS}. Truncating."
-            )
+        log_verbose(
+            verbose,
+            "warning",
+            f"Truncating {n_returns} daily returns to {MAX_DAYS} (circuit limit)",
+        )
         daily_log_returns = daily_log_returns[:MAX_DAYS]
         n_returns = MAX_DAYS
 
@@ -335,19 +246,19 @@ def generate_proof(
     # Pad to MAX_DAYS
     scaled_log_returns += [0] * (MAX_DAYS - len(scaled_log_returns))
 
-    if verbose:
-        bt.logging.info(f"Using {n_returns} daily returns from PTN")
+    log_verbose(verbose, "info", f"Using {n_returns} daily returns from PTN")
 
     all_orders = []
     for pos in positions:
-        all_orders.extend(pos["orders"])
+        all_orders.extend(get_attr(pos, "orders"))
 
     signals_count = len(all_orders)
     if signals_count > MAX_SIGNALS:
-        if verbose:
-            bt.logging.warning(
-                f"Warning: Miner has {signals_count} signals, but circuit only supports {MAX_SIGNALS}. Truncating."
-            )
+        log_verbose(
+            verbose,
+            "warning",
+            f"Truncating {signals_count} signals to {MAX_SIGNALS} (circuit limit)",
+        )
         all_orders = all_orders[:MAX_SIGNALS]
         signals_count = MAX_SIGNALS
 
@@ -356,24 +267,34 @@ def generate_proof(
 
     signals = []
     for order in all_orders:
-        trade_pair_str = order.get("trade_pair", ["UNKNOWN"])[0]
+        trade_pair = get_attr(order, "trade_pair")
+        trade_pair_str = (
+            str(trade_pair).split(".")[1]
+            if hasattr(trade_pair, "name")
+            else str(trade_pair)
+        )
         if trade_pair_str not in trade_pair_map:
             trade_pair_map[trade_pair_str] = trade_pair_counter
             trade_pair_counter += 1
 
-        order_type_str = order["order_type"]
+        order_type = get_attr(order, "order_type")
+        order_type_str = (
+            str(order_type).split(".")[1]
+            if hasattr(order_type, "name")
+            else str(order_type)
+        )
         order_type_map = {"SHORT": 2, "LONG": 1, "FLAT": 0}
-        price = int(order.get("price", 0) * SCALING_FACTOR)
-        order_uuid = order.get("order_uuid", "0")
-        bid = int(order.get("bid", 0) * SCALING_FACTOR)
-        ask = int(order.get("ask", 0) * SCALING_FACTOR)
-        processed_ms = order.get("processed_ms", 0)
+        price = int(get_attr(order, "price") * SCALING_FACTOR)
+        order_uuid = get_attr(order, "order_uuid")
+        bid = int(get_attr(order, "bid") * SCALING_FACTOR)
+        ask = int(get_attr(order, "ask") * SCALING_FACTOR)
+        processed_ms = get_attr(order, "processed_ms")
 
         signals.append(
             {
                 "trade_pair": str(trade_pair_map[trade_pair_str]),
                 "order_type": str(order_type_map.get(order_type_str, 0)),
-                "leverage": str(int(abs(order.get("leverage", 0)) * SCALING_FACTOR)),
+                "leverage": str(int(abs(order.leverage) * SCALING_FACTOR)),
                 "price": str(price),
                 "processed_ms": str(processed_ms),
                 "order_uuid": f"0x{order_uuid.replace('-', '')}",
@@ -396,39 +317,26 @@ def generate_proof(
         }
     ] * (MAX_SIGNALS - len(signals))
 
-    if verbose:
-        bt.logging.info(
-            f"Prepared {n_returns} daily returns and {signals_count} signals for circuit."
-        )
+    log_verbose(
+        verbose,
+        "info",
+        f"Prepared {n_returns} daily returns and {signals_count} signals for circuit",
+    )
 
+    if verbose:
         bt.logging.info(f"Circuit daily returns count: {n_returns}")
-        bt.logging.info("Circuit First 10 daily returns:")
-        for i in range(min(10, n_returns)):
+        bt.logging.info("Sample daily returns:")
+        for i in range(min(5, n_returns)):
             bt.logging.info(
                 f"  [{i}] return={daily_log_returns[i]:.6f} (scaled={scaled_log_returns[i]})"
             )
-
-        if n_returns > 10:
-            bt.logging.info("Circuit Last 5 daily returns:")
-            for i in range(n_returns - 5, n_returns):
-                if i >= 0:
-                    bt.logging.info(
-                        f"  [{i}] return={daily_log_returns[i]:.6f} (scaled={scaled_log_returns[i]})"
-                    )
-
         if daily_log_returns:
             mean_return = sum(daily_log_returns) / len(daily_log_returns)
-            bt.logging.info(
-                f"Circuit daily returns stats: mean={mean_return:.6f}, count={n_returns}"
-            )
-
-        bt.logging.info(f"Daily returns from PTN: {n_returns}")
+            bt.logging.info(f"Mean daily return: {mean_return:.6f}, count={n_returns}")
         bt.logging.info(f"Circuit Config: MAX_DAYS={MAX_DAYS}, DAILY_CHECKPOINTS=2")
 
-    if verbose:
-        bt.logging.info("Running tree_generator circuit...")
-    else:
-        bt.logging.info(f"Generating tree for hotkey {miner_hotkey}...")
+    log_verbose(verbose, "info", "Running tree_generator circuit...")
+    bt.logging.info(f"Generating tree for hotkey {miner_hotkey[:8]}...")
     current_dir = os.path.dirname(os.path.abspath(__file__))
     tree_generator_dir = os.path.join(current_dir, "tree_generator")
 
@@ -438,12 +346,11 @@ def generate_proof(
         toml.dump(tree_prover_input, f)
 
     output = run_command(
-        ["nargo", "execute", "--silence-warnings" if not verbose else ""],
+        ["nargo", "execute", "--silence-warnings"],
         tree_generator_dir,
-        verbose,
     )
 
-    tree = parse_nargo_struct_output(output)
+    tree = parse_circuit_output(output)
     try:
         path_elements = tree["path_elements"]
         path_indices = tree["path_indices"]
@@ -453,23 +360,15 @@ def generate_proof(
             "Unexpected tree_generator output structure, expected MerkleTree dict with leaf_hashes, path_elements, path_indices, and root"
         )
 
-    if verbose:
-        print(f"Generated signals Merkle root: {signals_merkle_root}")
-        if isinstance(signals_merkle_root, str) and signals_merkle_root.startswith(
-            "0x"
-        ):
-            print(f"Signals Merkle root (hex): {signals_merkle_root}")
-        else:
-            print(f"Signals Merkle root (int): {signals_merkle_root}")
-
-    if verbose:
-        print("Returns Merkle root will be calculated within the circuit")
-        print(f"Number of daily returns: {n_returns}")
-
-    if verbose:
-        print("Running main proof of portfolio circuit...")
-    else:
-        print(f"Generating witness for hotkey {miner_hotkey}...")
+    log_verbose(
+        verbose, "info", f"Generated signals Merkle root: {signals_merkle_root}"
+    )
+    log_verbose(
+        verbose, "info", "Returns Merkle root will be calculated within circuit"
+    )
+    log_verbose(verbose, "info", f"Number of daily returns: {n_returns}")
+    log_verbose(verbose, "info", "Running main proof of portfolio circuit...")
+    bt.logging.info(f"Generating witness for hotkey {miner_hotkey[:8]}...")
     main_circuit_dir = os.path.join(current_dir, "circuits")
 
     # Pass annual risk-free rate (to match ann_excess_return usage)
@@ -513,17 +412,15 @@ def generate_proof(
     with open(os.path.join(main_circuit_dir, "Prover.toml"), "w") as f:
         toml.dump(main_prover_input, f)
 
-    if verbose:
-        print("Executing main circuit to generate witness...")
+    log_verbose(verbose, "info", "Executing main circuit to generate witness...")
     witness_start = time.time()
     output = run_command(
-        ["nargo", "execute", "witness", "--silence-warnings"], main_circuit_dir, verbose
+        ["nargo", "execute", "witness", "--silence-warnings"], main_circuit_dir
     )
     witness_time = time.time() - witness_start
-    if verbose:
-        print(f"Witness generation completed in {witness_time:.3f}s")
+    log_verbose(verbose, "info", f"Witness generation completed in {witness_time:.3f}s")
 
-    fields = parse_nargo_struct_output(output)
+    fields = parse_circuit_output(output)
     if len(fields) < 9:
         raise RuntimeError(
             f"Expected 9 output fields from main circuit, got {len(fields)}: {fields}"
@@ -585,53 +482,57 @@ def generate_proof(
 
     if witness_only:
         prove_time, proving_success = None, True
-        if verbose:
-            print("Skipping barretenberg proof generation (witness_only=True)")
+        log_verbose(
+            verbose,
+            "info",
+            "Skipping barretenberg proof generation (witness_only=True)",
+        )
     else:
         try:
-            prove_time, proving_success = run_bb_prove(main_circuit_dir)
+            prove_time, proving_success = generate_bb_proof(main_circuit_dir)
             if prove_time is None:
-                if verbose:
-                    print("Barretenberg proof generation failed")
+                bt.logging.error("Barretenberg proof generation failed")
                 prove_time, proving_success = None, False
         except Exception as e:
-            print(f"Exception during proof generation: {e}")
+            bt.logging.error(f"Exception during proof generation: {e}")
             prove_time, proving_success = None, False
 
     # Always print key production info: hotkey and verification status
-    print(f"Hotkey: {miner_hotkey}")
-    print(f"Orders processed: {signals_count}")
-    print(f"Signals Merkle Root: {signals_merkle_root}")
-    print(f"Returns Merkle Root: {returns_merkle_root}")
-    print(f"Average Daily PnL: {avg_daily_pnl_scaled:.9f}")
-    print(f"Sharpe Ratio: {sharpe_ratio_scaled:.9f}")
+    bt.logging.info(f"Hotkey: {miner_hotkey}")
+    bt.logging.info(f"Orders processed: {signals_count}")
+    bt.logging.info(f"Signals Merkle Root: {signals_merkle_root}")
+    bt.logging.info(f"Returns Merkle Root: {returns_merkle_root}")
+    bt.logging.info(f"Average Daily PnL: {avg_daily_pnl_scaled:.9f}")
+    bt.logging.info(f"Sharpe Ratio: {sharpe_ratio_scaled:.9f}")
     # Convert drawdown factor to percentage: drawdown% = (1 - factor) * 100
     drawdown_percentage = (1 - max_drawdown_scaled) * 100
-    print(f"Max Drawdown: {max_drawdown_scaled:.9f} ({drawdown_percentage:.6f}%)")
-    print(f"Calmar Ratio: {calmar_ratio_scaled:.9f}")
-    print(f"Omega Ratio: {omega_ratio_scaled:.9f}")
-    print(f"Sortino Ratio: {sortino_ratio_scaled:.9f}")
-    print(f"Statistical Confidence: {stat_confidence_scaled:.9f}")
-    print(f"PnL Score: {pnl_score_scaled:.9f}")
+    bt.logging.info(
+        f"Max Drawdown: {max_drawdown_scaled:.9f} ({drawdown_percentage:.6f}%)"
+    )
+    bt.logging.info(f"Calmar Ratio: {calmar_ratio_scaled:.9f}")
+    bt.logging.info(f"Omega Ratio: {omega_ratio_scaled:.9f}")
+    bt.logging.info(f"Sortino Ratio: {sortino_ratio_scaled:.9f}")
+    bt.logging.info(f"Statistical Confidence: {stat_confidence_scaled:.9f}")
+    bt.logging.info(f"PnL Score: {pnl_score_scaled:.9f}")
 
     if verbose:
-        print("\n--- Proof Generation Complete ---")
-        print("\n=== MERKLE ROOTS ===")
-        print(f"Signals Merkle Root: {signals_merkle_root}")
-        print(f"Returns Merkle Root: {returns_merkle_root}")
-
-        print("\n=== DATA SUMMARY ===")
-        print(f"Daily returns processed: {n_returns}")
-        print(f"Trading signals processed: {signals_count}")
-        print("PnL calculated from cumulative returns in circuit")
-
-        print("\n=== PROOF GENERATION RESULTS ===")
-        print(f"Witness generation time: {witness_time:.3f}s")
+        bt.logging.info("\n--- Proof Generation Complete ---")
+        bt.logging.info("\n=== MERKLE ROOTS ===")
+        bt.logging.info(f"Signals Merkle Root: {signals_merkle_root}")
+        bt.logging.info(f"Returns Merkle Root: {returns_merkle_root}")
+
+        bt.logging.info("\n=== DATA SUMMARY ===")
+        bt.logging.info(f"Daily returns processed: {n_returns}")
+        bt.logging.info(f"Trading signals processed: {signals_count}")
+        bt.logging.info("PnL calculated from cumulative returns in circuit")
+
+        bt.logging.info("\n=== PROOF GENERATION RESULTS ===")
+        bt.logging.info(f"Witness generation time: {witness_time:.3f}s")
         if not witness_only:
             if prove_time is not None:
-                print(f"Proof generation time: {prove_time:.3f}s")
+                bt.logging.info(f"Proof generation time: {prove_time:.3f}s")
             else:
-                print("Unable to prove due to an error.")
+                bt.logging.info("Unable to prove due to an error.")
 
     # Return structured results for programmatic access
     return {

{proof_of_portfolio-0.0.80 → proof_of_portfolio-0.0.82}/proof_of_portfolio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proof-of-portfolio
-Version: 0.0.80
+Version: 0.0.82
 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.80 → proof_of_portfolio-0.0.82}/pyproject.toml

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