chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/util/block_cache.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
+
+from chia.consensus.block_record import BlockRecord
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32
+
+
+# implements BlockRecordsProtocol
+class BlockCache:
+    if TYPE_CHECKING:
+        from chia.consensus.blockchain_interface import BlockRecordsProtocol
+
+        _protocol_check: ClassVar[BlockRecordsProtocol] = cast("BlockCache", None)
+
+    _block_records: dict[bytes32, BlockRecord]
+    _height_to_hash: dict[uint32, bytes32]
+
+    def __init__(
+        self,
+        blocks: dict[bytes32, BlockRecord],
+    ):
+        self._block_records = blocks
+        self._height_to_hash = {block.height: hh for hh, block in blocks.items()}
+
+    def add_block(self, block: BlockRecord) -> None:
+        hh = block.header_hash
+        self._block_records[hh] = block
+        self._height_to_hash[block.height] = hh
+
+    def block_record(self, header_hash: bytes32) -> BlockRecord:
+        return self._block_records[header_hash]
+
+    def height_to_block_record(self, height: uint32) -> BlockRecord:
+        # Precondition: height is < peak height
+        header_hash: Optional[bytes32] = self.height_to_hash(height)
+        assert header_hash is not None
+        return self.block_record(header_hash)
+
+    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+        if height not in self._height_to_hash:
+            return None
+        return self._height_to_hash[height]
+
+    def contains_block(self, header_hash: bytes32) -> bool:
+        return header_hash in self._block_records
+
+    def contains_height(self, height: uint32) -> bool:
+        return height in self._height_to_hash
+
+    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        return self._block_records.get(header_hash)
+
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
+        return [self._block_records[h].prev_hash for h in header_hashes]

chia/util/byte_types.py

@@ -0,0 +1,12 @@
+# Package: utils
+
+from __future__ import annotations
+
+
+def hexstr_to_bytes(input_str: str) -> bytes:
+    """
+    Converts a hex string into bytes, removing the 0x if it's present.
+    """
+    if input_str.startswith("0x") or input_str.startswith("0X"):
+        return bytes.fromhex(input_str[2:])
+    return bytes.fromhex(input_str)

chia/util/check_fork_next_block.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable
+from typing import Callable
+
+from chia.consensus.blockchain_interface import BlockchainInterface
+from chia.server.ws_connection import WSChiaConnection
+from chia.util.ints import uint32
+
+
+async def check_fork_next_block(
+    blockchain: BlockchainInterface,
+    fork_point_height: uint32,
+    peers_with_peak: list[WSChiaConnection],
+    check_block_future: Callable[[WSChiaConnection, uint32, BlockchainInterface], Awaitable[bool]],
+) -> uint32:
+    our_peak_height = blockchain.get_peak_height()
+    ses_heigths = blockchain.get_ses_heights()
+    if len(ses_heigths) > 2 and our_peak_height is not None:
+        ses_heigths.sort()
+        max_fork_ses_height = ses_heigths[-3]
+        potential_peek = uint32(our_peak_height + 1)
+        # This is the fork point in SES in the case where no fork was detected
+        if blockchain.get_peak_height() is not None and fork_point_height == max_fork_ses_height:
+            for peer in peers_with_peak.copy():
+                if peer.closed:
+                    peers_with_peak.remove(peer)
+                    continue
+                # Grab a block at peak + 1 and check if fork point is actually our current height
+                if await check_block_future(peer, potential_peek, blockchain):
+                    fork_point_height = our_peak_height
+                    break
+    return fork_point_height

chia/util/chia_logging.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import logging
+import os
+from logging.handlers import SysLogHandler
+from pathlib import Path
+from typing import Any, Optional, cast
+
+import colorlog
+from concurrent_log_handler import ConcurrentRotatingFileHandler
+
+from chia import __version__
+from chia.util.chia_version import chia_short_version
+from chia.util.path import path_from_root
+
+default_log_level = "WARNING"
+
+
+def get_beta_logging_config() -> dict[str, Any]:
+    return {
+        "log_filename": f"{chia_short_version()}/chia-blockchain/beta.log",
+        "log_level": "DEBUG",
+        "log_stdout": False,
+        "log_maxfilesrotation": 100,
+        "log_maxbytesrotation": 100 * 1024 * 1024,
+        "log_use_gzip": True,
+    }
+
+
+def get_file_log_handler(
+    formatter: logging.Formatter, root_path: Path, logging_config: dict[str, object]
+) -> ConcurrentRotatingFileHandler:
+    log_path = path_from_root(root_path, str(logging_config.get("log_filename", "log/debug.log")))
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    maxrotation = cast(int, logging_config.get("log_maxfilesrotation", 7))
+    maxbytesrotation = cast(int, logging_config.get("log_maxbytesrotation", 50 * 1024 * 1024))
+    use_gzip = cast(bool, logging_config.get("log_use_gzip", False))
+    handler = ConcurrentRotatingFileHandler(
+        os.fspath(log_path), "a", maxBytes=maxbytesrotation, backupCount=maxrotation, use_gzip=use_gzip
+    )
+    handler.setFormatter(formatter)
+    return handler
+
+
+def initialize_logging(
+    service_name: str,
+    logging_config: dict[str, Any],
+    root_path: Path,
+    beta_root_path: Optional[Path] = None,
+) -> None:
+    log_backcompat = logging_config.get("log_backcompat", False)
+    log_level = logging_config.get("log_level", default_log_level)
+    file_name_length = 33 - len(service_name)
+    log_date_format = "%Y-%m-%dT%H:%M:%S"
+    file_log_formatter = logging.Formatter(
+        fmt=(
+            f"%(asctime)s.%(msecs)03d {service_name} %(name)-{file_name_length}s: %(levelname)-8s %(message)s"
+            if log_backcompat
+            else f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
+            f"%(levelname)-8s %(message)s"
+        ),
+        datefmt=log_date_format,
+    )
+    handlers: list[logging.Handler] = []
+    if logging_config["log_stdout"]:
+        stdout_handler = colorlog.StreamHandler()
+        stdout_handler.setFormatter(
+            colorlog.ColoredFormatter(
+                (
+                    f"%(asctime)s.%(msecs)03d {service_name} %(name)-{file_name_length}s: "
+                    f"%(log_color)s%(levelname)-8s%(reset)s %(message)s"
+                    if log_backcompat
+                    else f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
+                    f"%(log_color)s%(levelname)-8s%(reset)s %(message)s"
+                ),
+                datefmt=log_date_format,
+                reset=True,
+            )
+        )
+        handlers.append(stdout_handler)
+    else:
+        handlers.append(get_file_log_handler(file_log_formatter, root_path, logging_config))
+
+    if logging_config.get("log_syslog", False):
+        log_syslog_host = logging_config.get("log_syslog_host", "localhost")
+        log_syslog_port = logging_config.get("log_syslog_port", 514)
+        log_syslog_handler = SysLogHandler(address=(log_syslog_host, log_syslog_port))
+        log_syslog_handler.setFormatter(logging.Formatter(fmt=f"{service_name} %(message)s", datefmt=log_date_format))
+        handlers.append(log_syslog_handler)
+
+    if beta_root_path is not None:
+        handlers.append(get_file_log_handler(file_log_formatter, beta_root_path, get_beta_logging_config()))
+
+    root_logger = logging.getLogger()
+    for handler in handlers:
+        root_logger.addHandler(handler)
+
+    set_log_level(log_level=log_level, service_name=service_name)
+
+
+def set_log_level(log_level: str, service_name: str) -> list[str]:
+    root_logger = logging.getLogger()
+    log_level_exceptions = {}
+
+    for handler in root_logger.handlers:
+        try:
+            handler.setLevel(log_level)
+        except Exception as e:
+            handler.setLevel(default_log_level)
+            log_level_exceptions[handler] = e
+
+    error_strings = [
+        f"Handler {handler}: Invalid log level '{log_level}' for {service_name}. "
+        f"Defaulting to: {default_log_level}. Error: {exception}"
+        for handler, exception in log_level_exceptions.items()
+    ]
+    for error_string in error_strings:
+        root_logger.error(error_string)
+
+    # Adjust the root logger to the smallest used log level since its default level is WARNING which would overwrite
+    # the potentially smaller log levels of specific handlers.
+    root_logger.setLevel(min(handler.level for handler in root_logger.handlers))
+
+    if root_logger.level <= logging.DEBUG:
+        logging.getLogger("aiosqlite").setLevel(logging.INFO)  # Too much logging on debug level
+
+    return error_strings
+
+
+def initialize_service_logging(service_name: str, config: dict[str, Any], root_path: Path) -> None:
+    if service_name == "daemon":
+        # TODO: Maybe introduce a separate `daemon` section in the config instead of having `daemon_port`, `logging`
+        #  and the daemon related stuff as top level entries.
+        logging_config = config["logging"]
+    else:
+        logging_config = config[service_name]["logging"]
+    beta_config = config.get("beta", {})
+    beta_config_path = beta_config.get("path") if beta_config.get("enabled", False) else None
+    initialize_logging(
+        service_name=service_name,
+        logging_config=logging_config,
+        root_path=root_path,
+        beta_root_path=beta_config_path,
+    )

chia/util/chia_version.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from re import search
+from typing import Union
+
+from packaging.version import InvalidVersion, Version
+
+from chia import __version__
+
+
+def _chia_short_version_from_version(version: Version) -> str:
+    release_version_str = f"{version.major}.{version.minor}.{version.micro}"
+
+    return release_version_str if version.pre is None else release_version_str + "".join(map(str, version.pre))
+
+
+def _chia_short_version_from_str(version: str) -> str:
+    try:
+        return chia_short_version(Version(version))
+    except InvalidVersion:
+        pass
+    match = search(r"^(\d+\.\d+\.\d+)", version)
+    if match is not None:
+        return match.group(1)
+
+    return version
+
+
+def chia_short_version(version: Union[str, Version] = __version__) -> str:
+    if isinstance(version, Version):
+        return _chia_short_version_from_version(version)
+
+    return _chia_short_version_from_str(version)

chia/util/collection.py

@@ -0,0 +1,17 @@
+# Package: utils
+
+from __future__ import annotations
+
+# Utility Functions for Collections & Sequences
+
+
+def find_duplicates(array: list[int]) -> set[int]:
+    seen = set()
+    duplicates = set()
+
+    for i in array:
+        if i in seen:
+            duplicates.add(i)
+        seen.add(i)
+
+    return duplicates

chia/util/condition_tools.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Callable, Union
+
+from chia_rs import G1Element
+from clvm.casts import int_from_bytes, int_to_bytes
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
+from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
+from chia.util.errors import ConsensusError, Err
+from chia.util.hash import std_hash
+from chia.util.ints import uint64
+
+
+def parse_sexp_to_condition(sexp: Program) -> ConditionWithArgs:
+    """
+    Takes a ChiaLisp sexp and returns a ConditionWithArgs.
+    Raises an ConsensusError if it fails.
+    """
+    first = sexp.pair
+    if first is None:
+        raise ConsensusError(Err.INVALID_CONDITION, ["first is None"])
+    op = first[0].atom
+    if op is None or len(op) != 1:
+        raise ConsensusError(Err.INVALID_CONDITION, ["invalid op"])
+
+    # since the ConditionWithArgs only has atoms as the args, we can't parse
+    # hints and memos with this function. We just exit the loop if we encounter
+    # a pair instead of an atom
+    vars: list[bytes] = []
+    for arg in Program(first[1]).as_iter():
+        a = arg.atom
+        if a is None:
+            break
+        vars.append(a)
+        # no condition (currently) has more than 3 arguments. Additional
+        # arguments are allowed but ignored
+        if len(vars) > 3:
+            break
+
+    return ConditionWithArgs(ConditionOpcode(op), vars)
+
+
+def parse_sexp_to_conditions(sexp: Program) -> list[ConditionWithArgs]:
+    """
+    Takes a ChiaLisp sexp (list) and returns the list of ConditionWithArgss
+    Raises an ConsensusError if it fails.
+    """
+    return [parse_sexp_to_condition(s) for s in sexp.as_iter()]
+
+
+@lru_cache
+def agg_sig_additional_data(agg_sig_data: bytes) -> dict[ConditionOpcode, bytes]:
+    ret: dict[ConditionOpcode, bytes] = {}
+    for code in [
+        ConditionOpcode.AGG_SIG_PARENT,
+        ConditionOpcode.AGG_SIG_PUZZLE,
+        ConditionOpcode.AGG_SIG_AMOUNT,
+        ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT,
+        ConditionOpcode.AGG_SIG_PARENT_AMOUNT,
+        ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
+    ]:
+        ret[code] = std_hash(agg_sig_data + code)
+
+    ret[ConditionOpcode.AGG_SIG_ME] = agg_sig_data
+    return ret
+
+
+def make_aggsig_final_message(
+    opcode: ConditionOpcode,
+    msg: bytes,
+    spend_conditions: Union[Coin, SpendConditions],
+    agg_sig_additional_data: dict[ConditionOpcode, bytes],
+) -> bytes:
+    if isinstance(spend_conditions, Coin):
+        coin = spend_conditions
+    elif isinstance(spend_conditions, SpendConditions):
+        coin = Coin(spend_conditions.parent_id, spend_conditions.puzzle_hash, uint64(spend_conditions.coin_amount))
+    else:
+        raise ValueError(f"Expected Coin or Spend, got {type(spend_conditions)}")  # pragma: no cover
+
+    COIN_TO_ADDENDUM_F_LOOKUP: dict[ConditionOpcode, Callable[[Coin], bytes]] = {
+        ConditionOpcode.AGG_SIG_PARENT: lambda coin: coin.parent_coin_info,
+        ConditionOpcode.AGG_SIG_PUZZLE: lambda coin: coin.puzzle_hash,
+        ConditionOpcode.AGG_SIG_AMOUNT: lambda coin: int_to_bytes(coin.amount),
+        ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT: lambda coin: coin.puzzle_hash + int_to_bytes(coin.amount),
+        ConditionOpcode.AGG_SIG_PARENT_AMOUNT: lambda coin: coin.parent_coin_info + int_to_bytes(coin.amount),
+        ConditionOpcode.AGG_SIG_PARENT_PUZZLE: lambda coin: coin.parent_coin_info + coin.puzzle_hash,
+        ConditionOpcode.AGG_SIG_ME: lambda coin: coin.name(),
+    }
+    addendum = COIN_TO_ADDENDUM_F_LOOKUP[opcode](coin)
+    return msg + addendum + agg_sig_additional_data[opcode]
+
+
+def pkm_pairs(conditions: SpendBundleConditions, additional_data: bytes) -> tuple[list[G1Element], list[bytes]]:
+    ret: tuple[list[G1Element], list[bytes]] = ([], [])
+
+    data = agg_sig_additional_data(additional_data)
+
+    for pk, msg in conditions.agg_sig_unsafe:
+        ret[0].append(pk)
+        ret[1].append(msg)
+
+    for spend in conditions.spends:
+        condition_items_pairs = [
+            (ConditionOpcode.AGG_SIG_PARENT, spend.agg_sig_parent),
+            (ConditionOpcode.AGG_SIG_PUZZLE, spend.agg_sig_puzzle),
+            (ConditionOpcode.AGG_SIG_AMOUNT, spend.agg_sig_amount),
+            (ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT, spend.agg_sig_puzzle_amount),
+            (ConditionOpcode.AGG_SIG_PARENT_AMOUNT, spend.agg_sig_parent_amount),
+            (ConditionOpcode.AGG_SIG_PARENT_PUZZLE, spend.agg_sig_parent_puzzle),
+            (ConditionOpcode.AGG_SIG_ME, spend.agg_sig_me),
+        ]
+        for condition, items in condition_items_pairs:
+            for pk, msg in items:
+                ret[0].append(pk)
+                ret[1].append(make_aggsig_final_message(condition, msg, spend, data))
+
+    return ret
+
+
+def validate_cwa(cwa: ConditionWithArgs) -> None:
+    if (
+        len(cwa.vars) != 2
+        or len(cwa.vars[0]) != 48
+        or len(cwa.vars[1]) > 1024
+        or cwa.vars[0] is None
+        or cwa.vars[1] is None
+    ):
+        raise ConsensusError(Err.INVALID_CONDITION)
+
+
+def pkm_pairs_for_conditions_dict(
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]],
+    coin: Coin,
+    additional_data: bytes,
+) -> list[tuple[G1Element, bytes]]:
+    ret: list[tuple[G1Element, bytes]] = []
+
+    data = agg_sig_additional_data(additional_data)
+
+    for cwa in conditions_dict.get(ConditionOpcode.AGG_SIG_UNSAFE, []):
+        validate_cwa(cwa)
+        for disallowed in data.values():
+            if cwa.vars[1].endswith(disallowed):
+                raise ConsensusError(Err.INVALID_CONDITION)
+        ret.append((G1Element.from_bytes(cwa.vars[0]), cwa.vars[1]))
+
+    for opcode in [
+        ConditionOpcode.AGG_SIG_PARENT,
+        ConditionOpcode.AGG_SIG_PUZZLE,
+        ConditionOpcode.AGG_SIG_AMOUNT,
+        ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT,
+        ConditionOpcode.AGG_SIG_PARENT_AMOUNT,
+        ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
+        ConditionOpcode.AGG_SIG_ME,
+    ]:
+        for cwa in conditions_dict.get(opcode, []):
+            validate_cwa(cwa)
+            ret.append((G1Element.from_bytes(cwa.vars[0]), make_aggsig_final_message(opcode, cwa.vars[1], coin, data)))
+
+    return ret
+
+
+def created_outputs_for_conditions_dict(
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]],
+    input_coin_name: bytes32,
+) -> list[Coin]:
+    output_coins = []
+    for cvp in conditions_dict.get(ConditionOpcode.CREATE_COIN, []):
+        puzzle_hash, amount_bin = cvp.vars[0], cvp.vars[1]
+        amount = int_from_bytes(amount_bin)
+        coin = Coin(input_coin_name, bytes32(puzzle_hash), uint64(amount))
+        output_coins.append(coin)
+    return output_coins
+
+
+def conditions_dict_for_solution(
+    puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
+) -> dict[ConditionOpcode, list[ConditionWithArgs]]:
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {}
+    for cvp in conditions_for_solution(puzzle_reveal, solution, max_cost):
+        conditions_dict.setdefault(cvp.opcode, list()).append(cvp)
+    return conditions_dict
+
+
+def conditions_for_solution(
+    puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
+) -> list[ConditionWithArgs]:
+    # get the standard script for a puzzle hash and feed in the solution
+    try:
+        _cost, r = puzzle_reveal.run_with_cost(max_cost, solution)
+        return parse_sexp_to_conditions(r)
+    except Program.EvalError as e:
+        raise ConsensusError(Err.SEXP_ERROR, [str(e)]) from e