chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/consensus/make_sub_epoch_summary.py

@@ -3,10 +3,9 @@ from __future__ import annotations
 import logging
 from typing import Optional, Union
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, FullBlock, SubEpochSummary, UnfinishedBlock
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.difficulty_adjustment import (
@@ -17,9 +16,6 @@ from chia.consensus.difficulty_adjustment import (
     height_can_be_first_in_epoch,
 )
 from chia.consensus.pot_iterations import calculate_ip_iters, calculate_sp_iters, is_overflow_block
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.full_block import FullBlock
-from chia.types.unfinished_block import UnfinishedBlock
 
 log = logging.getLogger(__name__)
 

chia/consensus/multiprocess_validation.py

@@ -11,8 +11,11 @@ from dataclasses import dataclass
 from typing import Optional
 
 from chia_rs import (
+    BlockRecord,
     ConsensusConstants,
+    FullBlock,
     SpendBundleConditions,
+    SubEpochSummary,
     get_flags_for_height_and_constants,
     run_block_generator,
     run_block_generator2,
@@ -20,22 +23,21 @@ from chia_rs import (
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
 
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_header_validation import validate_finished_header_block
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.full_block_to_block_record import block_to_block_record
-from chia.consensus.get_block_challenge import get_block_challenge
+from chia.consensus.generator_tools import get_block_header, tx_removals_and_additions
+from chia.consensus.get_block_challenge import get_block_challenge, prev_tx_block
 from chia.consensus.get_block_generator import get_block_generator
-from chia.consensus.pot_iterations import calculate_iterations_quality, is_overflow_block
+from chia.consensus.pot_iterations import (
+    is_overflow_block,
+    validate_pospace_and_get_required_iters,
+)
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.errors import Err
-from chia.util.generator_tools import get_block_header, tx_removals_and_additions
 from chia.util.streamable import Streamable, streamable
 
 log = logging.getLogger(__name__)
@@ -128,11 +130,10 @@ def _pre_validate_block(
             removals_and_additions = ([], [])
 
         assert conds is None or conds.validated_signature is True
-        header_block = get_block_header(block, removals_and_additions)
         required_iters, error = validate_finished_header_block(
             constants,
             blockchain,
-            header_block,
+            get_block_header(block, removals_and_additions),
             True,  # check_filter
             expected_vs,
         )
@@ -211,19 +212,19 @@ async def pre_validate_block(
         cc_sp_hash: bytes32 = challenge
     else:
         cc_sp_hash = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
-    q_str: Optional[bytes32] = verify_and_get_quality_string(
-        block.reward_chain_block.proof_of_space, constants, challenge, cc_sp_hash, height=block.height
-    )
-    if q_str is None:
-        return return_error(Err.INVALID_POSPACE)
 
-    required_iters: uint64 = calculate_iterations_quality(
-        constants.DIFFICULTY_CONSTANT_FACTOR,
-        q_str,
-        block.reward_chain_block.proof_of_space.size,
-        vs.difficulty,
+    required_iters = validate_pospace_and_get_required_iters(
+        constants,
+        block.reward_chain_block.proof_of_space,
+        challenge,
         cc_sp_hash,
+        block.height,
+        vs.difficulty,
+        vs.ssi,
+        prev_tx_block(blockchain, prev_b),
     )
+    if required_iters is None:
+        return return_error(Err.INVALID_POSPACE)
 
     try:
         block_rec = block_to_block_record(

chia/consensus/pot_iterations.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
-from chia_rs import ConsensusConstants
+from typing import Optional
+
+from chia_rs import ConsensusConstants, PlotSize, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint64, uint128
+from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.consensus.pos_quality import _expected_plot_size
+from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
 from chia.util.hash import std_hash
 
+# TODO: todo_v2_plots add to chia_rs and get from constants
+PHASE_OUT_PERIOD = uint32(10000000)
+
 
 def is_overflow_block(constants: ConsensusConstants, signage_point_index: uint8) -> bool:
     if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
@@ -25,6 +31,25 @@ def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, si
     return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index)
 
 
+def calculate_phase_out(
+    constants: ConsensusConstants,
+    sub_slot_iters: uint64,
+    prev_transaction_block_height: uint32,
+) -> uint64:
+    if prev_transaction_block_height <= constants.HARD_FORK2_HEIGHT:
+        return uint64(0)
+    elif uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT) >= PHASE_OUT_PERIOD:
+        return uint64(calculate_sp_interval_iters(constants, sub_slot_iters))
+
+    return uint64(
+        (
+            uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT)
+            * calculate_sp_interval_iters(constants, sub_slot_iters)
+        )
+        // PHASE_OUT_PERIOD
+    )
+
+
 def calculate_ip_iters(
     constants: ConsensusConstants,
     sub_slot_iters: uint64,
@@ -46,23 +71,59 @@ def calculate_ip_iters(
     return uint64((sp_iters + constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % sub_slot_iters)
 
 
+def validate_pospace_and_get_required_iters(
+    constants: ConsensusConstants,
+    proof_of_space: ProofOfSpace,
+    challenge: bytes32,
+    cc_sp_hash: bytes32,
+    height: uint32,
+    difficulty: uint64,
+    sub_slot_iters: uint64,
+    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
+) -> Optional[uint64]:
+    q_str: Optional[bytes32] = verify_and_get_quality_string(
+        proof_of_space, constants, challenge, cc_sp_hash, height=height
+    )
+    if q_str is None:
+        return None
+
+    return calculate_iterations_quality(
+        constants,
+        q_str,
+        proof_of_space.size(),
+        difficulty,
+        cc_sp_hash,
+        sub_slot_iters,
+        prev_transaction_block_height,
+    )
+
+
 def calculate_iterations_quality(
-    difficulty_constant_factor: uint128,
+    constants: ConsensusConstants,
     quality_string: bytes32,
-    size: int,
+    size: PlotSize,
     difficulty: uint64,
     cc_sp_output_hash: bytes32,
+    ssi: uint64,
+    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
 ) -> uint64:
     """
     Calculates the number of iterations from the quality. This is derives as the difficulty times the constant factor
     times a random number between 0 and 1 (based on quality string), divided by plot size.
     """
-    sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
-
-    iters = uint64(
-        int(difficulty)
-        * int(difficulty_constant_factor)
-        * int.from_bytes(sp_quality_string, "big", signed=False)
-        // (int(pow(2, 256)) * int(_expected_plot_size(size)))
-    )
-    return max(iters, uint64(1))
+    if size.size_v1 is not None:
+        assert size.size_v2 is None
+        sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
+        phase_out = calculate_phase_out(constants, ssi, prev_transaction_block_height)
+        iters = uint64(
+            (
+                int(difficulty)
+                * int(constants.DIFFICULTY_CONSTANT_FACTOR)
+                * int.from_bytes(sp_quality_string, "big", signed=False)
+                // (int(pow(2, 256)) * int(_expected_plot_size(size.size_v1)))
+            )
+            + phase_out
+        )
+        return max(iters, uint64(1))
+    else:
+        raise NotImplementedError

chia/{util → consensus}/prev_transaction_block.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+from chia_rs import BlockRecord
 from chia_rs.sized_ints import uint128
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 
 

chia/consensus/vdf_info_computation.py

@@ -2,14 +2,12 @@ from __future__ import annotations
 
 from typing import Optional
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, EndOfSubSlotBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64, uint128
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 
 
 def get_signage_point_vdf_info(

chia/daemon/keychain_proxy.py

@@ -97,7 +97,7 @@ class KeychainProxy(DaemonProxy):
             self.log.debug(f"Sending request to keychain command: {request['command']} from {request['origin']}.")
             return await super()._get(request)
         except asyncio.TimeoutError:
-            raise KeychainProxyConnectionTimeout()
+            raise KeychainProxyConnectionTimeout
 
     async def start(self, wait_for_start: bool = False) -> None:
         self.keychain_connection_task = create_referenced_task(self.connect_to_keychain())
@@ -156,11 +156,11 @@ class KeychainProxy(DaemonProxy):
         if error:
             error_details = response["data"].get("error_details", {})
             if error == KEYCHAIN_ERR_LOCKED:
-                raise KeychainIsLocked()
+                raise KeychainIsLocked
             elif error == KEYCHAIN_ERR_NO_KEYS:
-                raise KeychainIsEmpty()
+                raise KeychainIsEmpty
             elif error == KEYCHAIN_ERR_KEY_NOT_FOUND:
-                raise KeychainKeyNotFound()
+                raise KeychainKeyNotFound
             elif error == KEYCHAIN_ERR_MALFORMED_REQUEST:
                 message = error_details.get("message", "")
                 raise KeychainMalformedRequest(message)
@@ -356,7 +356,7 @@ class KeychainProxy(DaemonProxy):
         if self.use_local_keychain():
             keys = self.keychain.get_keys(include_secrets=private)
             if len(keys) == 0:
-                raise KeychainIsEmpty()
+                raise KeychainIsEmpty
             else:
                 selected_key = keys[0]
                 if fingerprint is not None:

chia/daemon/server.py

@@ -12,7 +12,7 @@ import subprocess
 import sys
 import traceback
 import uuid
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Collection
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from enum import Enum
@@ -27,7 +27,6 @@ from typing_extensions import Protocol
 from chia import __version__
 from chia.cmds.init_funcs import check_keys, chia_init
 from chia.cmds.passphrase_funcs import default_passphrase, using_default_passphrase
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.daemon.keychain_server import KeychainServer, keychain_commands
 from chia.daemon.windows_signal import kill
 from chia.plotters.plotters import get_available_plotters
@@ -55,17 +54,31 @@ from chia.wallet.derive_keys import (
     master_sk_to_pool_sk,
     master_sk_to_wallet_sk,
 )
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 io_pool_exc = ThreadPoolExecutor()
 
 try:
-    from aiohttp import WSMsgType, web
+    from aiohttp import WSMessage, WSMsgType, web
     from aiohttp.web_ws import WebSocketResponse
 except ModuleNotFoundError:
     print("Error: Make sure to run . ./activate from the project folder before starting Chia.")
     sys.exit()
 
 
+def redact_sensitive_data(obj: Any, redaction_triggers: Collection[str] = ("pass", "key", "secret", "mnemonic")) -> Any:
+    """Recursively redact sensitive data from nested dictionaries."""
+    if isinstance(obj, dict):
+        return {
+            key: "***<redacted>***"
+            if any(trigger.casefold() in key.casefold() for trigger in redaction_triggers)
+            else redact_sensitive_data(value, redaction_triggers)
+            for key, value in obj.items()
+        }
+    else:
+        return obj
+
+
 log = logging.getLogger(__name__)
 
 service_plotter = "chia_plotter"
@@ -267,7 +280,6 @@ class WebSocketServer:
 
         while True:
             msg = await ws.receive()
-            self.log.debug("Received message: %s", msg)
             decoded: WsRpcMessage = {
                 "command": "",
                 "ack": False,
@@ -282,6 +294,10 @@ class WebSocketServer:
                     if "data" not in decoded:
                         decoded["data"] = {}
 
+                    redacted_data = redact_sensitive_data(decoded)
+                    redacted_message = WSMessage(msg.type, redacted_data, msg.extra)
+                    self.log.debug("Received message: %s", redacted_message)
+
                     maybe_response = await self.handle_message(ws, decoded)
                     if maybe_response is None:
                         continue
@@ -297,6 +313,7 @@ class WebSocketServer:
 
                 await self.send_all_responses(connections, response)
             else:
+                self.log.debug("Received non-text message")
                 service_names = self.remove_connection(ws)
 
                 if len(service_names) == 0:
@@ -669,7 +686,7 @@ class WebSocketServer:
                     pk = sk.get_g1()
                 else:
                     pk = master_pk_to_wallet_pk_unhardened(key.public_key, uint32(i))
-                wallet_address = encode_puzzle_hash(create_puzzlehash_for_pk(pk), prefix)
+                wallet_address = encode_puzzle_hash(puzzle_hash_for_pk(pk), prefix)
                 if non_observer_derivation:
                     hd_path = f"m/12381n/8444n/2n/{i}n"
                 else: