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

chia/types/blockchain_format/proof_of_space.py

@@ -3,17 +3,14 @@ from __future__ import annotations
 import logging
 from typing import Optional, cast
 
-import chia_rs
 from bitstring import BitArray
-from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, PrivateKey
+from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, PlotSize, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32
+from chia_rs.sized_ints import uint8, uint32
 from chiapos import Verifier
 
 from chia.util.hash import std_hash
 
-ProofOfSpace = chia_rs.ProofOfSpace
-
 log = logging.getLogger(__name__)
 
 
@@ -25,6 +22,37 @@ def get_plot_id(pos: ProofOfSpace) -> bytes32:
     return calculate_plot_id_pk(pos.pool_public_key, pos.plot_public_key)
 
 
+# returns quality string for v2 plot, or None if invalid
+def validate_proof_v2(
+    plot_id: bytes32, size: uint8, difficulty: uint8, challenge: bytes32, proof: bytes
+) -> Optional[bytes32]:
+    # TODO: todo_v2_plots call into new chiapos library
+    raise NotImplementedError
+
+
+def check_plot_size(constants: ConsensusConstants, ps: PlotSize) -> bool:
+    size_v1 = ps.size_v1
+    if size_v1 is not None:
+        assert ps.size_v2 is None
+        if size_v1 < constants.MIN_PLOT_SIZE_V1:
+            log.error("Plot size is lower than the minimum")
+            return False
+        if size_v1 > constants.MAX_PLOT_SIZE_V1:
+            log.error("Plot size is higher than the maximum")
+            return False
+        return True
+
+    size_v2 = ps.size_v2
+    assert size_v2 is not None
+    if size_v2 < constants.MIN_PLOT_SIZE_V2:
+        log.error("Plot size is lower than the minimum")
+        return False
+    if size_v2 > constants.MAX_PLOT_SIZE_V2:
+        log.error("Plot size is higher than the maximum")
+        return False
+    return True
+
+
 def verify_and_get_quality_string(
     pos: ProofOfSpace,
     constants: ConsensusConstants,
@@ -40,31 +68,38 @@ def verify_and_get_quality_string(
     if (pos.pool_public_key is not None) and (pos.pool_contract_puzzle_hash is not None):
         log.error("Expected pool public key or pool contract puzzle hash but got both")
         return None
-    if pos.size < constants.MIN_PLOT_SIZE:
-        log.error("Plot size is lower than the minimum")
-        return None
-    if pos.size > constants.MAX_PLOT_SIZE:
-        log.error("Plot size is higher than the maximum")
+
+    plot_size = pos.size()
+    if not check_plot_size(constants, plot_size):
         return None
+
     plot_id: bytes32 = get_plot_id(pos)
     new_challenge: bytes32 = calculate_pos_challenge(plot_id, original_challenge_hash, signage_point)
 
     if new_challenge != pos.challenge:
         log.error("Calculated pos challenge doesn't match the provided one")
         return None
-    prefix_bits = calculate_prefix_bits(constants, height)
+
+    # we use different plot filter prefix sizes depending on v1 or v2 plots
+    prefix_bits = calculate_prefix_bits(constants, height, plot_size)
     if not passes_plot_filter(prefix_bits, plot_id, original_challenge_hash, signage_point):
         log.error("Did not pass the plot filter")
         return None
 
-    return get_quality_string(pos, plot_id)
+    if plot_size.size_v1 is not None:
+        # === V1 plots ===
+        assert plot_size.size_v2 is None
 
+        quality_str = Verifier().validate_proof(plot_id, plot_size.size_v1, pos.challenge, bytes(pos.proof))
+        if not quality_str:
+            return None
+        return bytes32(quality_str)
+    else:
+        # === V2 plots ===
+        assert plot_size.size_v2 is not None
 
-def get_quality_string(pos: ProofOfSpace, plot_id: bytes32) -> Optional[bytes32]:
-    quality_str = Verifier().validate_proof(plot_id, pos.size, pos.challenge, bytes(pos.proof))
-    if not quality_str:
-        return None
-    return bytes32(quality_str)
+        plot_difficulty = calculate_plot_difficulty(constants, height)
+        return validate_proof_v2(plot_id, plot_size.size_v2, plot_difficulty, pos.challenge, bytes(pos.proof))
 
 
 def passes_plot_filter(
@@ -84,8 +119,12 @@ def passes_plot_filter(
     return cast(bool, plot_filter[:prefix_bits].uint == 0)
 
 
-def calculate_prefix_bits(constants: ConsensusConstants, height: uint32) -> int:
-    prefix_bits = int(constants.NUMBER_ZERO_BITS_PLOT_FILTER)
+def calculate_prefix_bits(constants: ConsensusConstants, height: uint32, plot_size: PlotSize) -> int:
+    # v2 plots have a constant plot filter size
+    if plot_size.size_v2 is not None:
+        return constants.NUMBER_ZERO_BITS_PLOT_FILTER_V2
+
+    prefix_bits = int(constants.NUMBER_ZERO_BITS_PLOT_FILTER_V1)
     if height >= constants.PLOT_FILTER_32_HEIGHT:
         prefix_bits -= 4
     elif height >= constants.PLOT_FILTER_64_HEIGHT:
@@ -98,6 +137,21 @@ def calculate_prefix_bits(constants: ConsensusConstants, height: uint32) -> int:
     return max(0, prefix_bits)
 
 
+def calculate_plot_difficulty(constants: ConsensusConstants, height: uint32) -> uint8:
+    if height < constants.PLOT_DIFFICULTY_4_HEIGHT:
+        return constants.PLOT_DIFFICULTY_INITIAL
+    if height < constants.PLOT_DIFFICULTY_5_HEIGHT:
+        return uint8(4)
+    if height < constants.PLOT_DIFFICULTY_6_HEIGHT:
+        return uint8(5)
+    if height < constants.PLOT_DIFFICULTY_7_HEIGHT:
+        return uint8(6)
+    if height < constants.PLOT_DIFFICULTY_8_HEIGHT:
+        return uint8(7)
+    else:
+        return uint8(8)
+
+
 def calculate_plot_filter_input(plot_id: bytes32, challenge_hash: bytes32, signage_point: bytes32) -> bytes32:
     return std_hash(plot_id + challenge_hash + signage_point)
 

chia/types/coin_spend.py

@@ -3,21 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Union
 
-import chia_rs
-from chia_rs.sized_ints import uint64
+from chia_rs import CoinSpend
 
-from chia.consensus.condition_costs import ConditionCost
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
 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.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.util.errors import Err, ValidationError
 from chia.util.streamable import Streamable, streamable
 
-CoinSpend = chia_rs.CoinSpend
-
 
 def make_spend(
     coin: Coin,
@@ -29,66 +23,19 @@ def make_spend(
     if isinstance(puzzle_reveal, SerializedProgram):
         pr = puzzle_reveal
     elif isinstance(puzzle_reveal, Program):
-        pr = SerializedProgram.from_program(puzzle_reveal)
+        pr = puzzle_reveal.to_serialized()
     else:
         raise ValueError("Only [SerializedProgram, Program] supported for puzzle reveal")
     if isinstance(solution, SerializedProgram):
         sol = solution
     elif isinstance(solution, Program):
-        sol = SerializedProgram.from_program(solution)
+        sol = solution.to_serialized()
     else:
         raise ValueError("Only [SerializedProgram, Program] supported for solution")
 
     return CoinSpend(coin, pr, sol)
 
 
-def compute_additions_with_cost(
-    cs: CoinSpend,
-    *,
-    max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
-) -> tuple[list[Coin], int]:
-    """
-    Run the puzzle in the specified CoinSpend and return the cost and list of
-    coins created by the puzzle, i.e. additions. If the cost (CLVM- and
-    condition cost) exceeds the specified max_cost, the function fails with a
-    ValidationError exception. Byte cost is not included since at this point the
-    puzzle and solution may have been decompressed, the true byte-cost can only be
-    measured at the block generator level.
-    """
-    parent_id = cs.coin.name()
-    ret: list[Coin] = []
-    cost, r = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
-    for cond in Program.to(r).as_iter():
-        if cost > max_cost:
-            raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_additions() for CoinSpend")
-        atoms = cond.as_iter()
-        op = next(atoms).atom
-        if op 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_UNSAFE,
-            ConditionOpcode.AGG_SIG_ME,
-        }:
-            cost += ConditionCost.AGG_SIG.value
-            continue
-        if op != ConditionOpcode.CREATE_COIN.value:
-            continue
-        cost += ConditionCost.CREATE_COIN.value
-        puzzle_hash = next(atoms).as_atom()
-        amount = uint64(next(atoms).as_int())
-        ret.append(Coin(parent_id, puzzle_hash, uint64(amount)))
-
-    return ret, cost
-
-
-def compute_additions(cs: CoinSpend, *, max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM) -> list[Coin]:
-    return compute_additions_with_cost(cs, max_cost=max_cost)[0]
-
-
 @streamable
 @dataclass(frozen=True)
 class SpendInfo(Streamable):

chia/types/generator_types.py

@@ -2,12 +2,40 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
+from chia_rs import Coin, G2Element
+from chia_rs.sized_ints import uint32, uint64
+
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.util.streamable import Streamable, streamable
 
 
+# This holds what we need to pre validate a block generator
 @streamable
 @dataclass(frozen=True)
 class BlockGenerator(Streamable):
     program: SerializedProgram = field(default_factory=SerializedProgram.default)
+    # to run the block generator, we need the actual bytes of the previous
+    # generators it may reference. These are parameters passed in to the block
+    # generator
     generator_refs: list[bytes] = field(default_factory=list)
+
+
+# When we create a new block, this object holds the block generator and
+# additional information we need to create the UnfinishedBlock from it.
+# When creating a block, we still need to be able to run it, to compute its cost
+# and validate it. Therefore, this is a superset of the BlockGenerator class.
+@dataclass(frozen=True)
+class NewBlockGenerator(BlockGenerator):
+    # when creating a block, we include the block heights of the generators we
+    # reference. Tese are block heights and generator_refs contain the
+    # corresponding bytes of the generator programs
+    block_refs: list[uint32] = field(default_factory=list)
+    # the aggregate signature of all AGG_SIG_* conditions returned by the block
+    # generator.
+    signature: G2Element = G2Element()
+    # all CREATE_COIN outputs created by the block generator
+    additions: list[Coin] = field(default_factory=list)
+    # all coins being spent by the block generator
+    removals: list[Coin] = field(default_factory=list)
+    # the total cost of the block generator, CLVM + bytes + conditions
+    cost: uint64 = field(default=uint64(0))

chia/types/internal_mempool_item.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from chia_rs import SpendBundle, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.types.mempool_item import BundleCoinSpend
-from chia.types.spend_bundle import SpendBundle
-from chia.types.spend_bundle_conditions import SpendBundleConditions
 
 
 @dataclass(frozen=True)

chia/types/mempool_item.py

@@ -3,16 +3,21 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
+from chia_rs import CoinSpend, SpendBundle, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_spend import CoinSpend
-from chia.types.spend_bundle import SpendBundle
-from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.streamable import recurse_jsonify
 
 
+@dataclass(frozen=True)
+class UnspentLineageInfo:
+    coin_id: bytes32
+    parent_id: bytes32
+    parent_parent_id: bytes32
+
+
 @dataclass
 class BundleCoinSpend:
     coin_spend: CoinSpend
@@ -23,10 +28,10 @@ class BundleCoinSpend:
     cost: Optional[uint64] = None
 
     # if this spend is eligible for fast forward, this may be set to the
-    # current unspent coin belonging to this singleton, that we would rebase
-    # this spen on top of if we were to make a block now
-    # When finding MempoolItems by coin ID, we use this Coin ID if it's set
-    latest_singleton_coin: Optional[bytes32] = None
+    # current unspent lineage belonging to this singleton, that we would rebase
+    # this spend on top of if we were to make a block now
+    # When finding MempoolItems by coin ID, we use Coin ID from it if it's set
+    latest_singleton_lineage: Optional[UnspentLineageInfo] = None
 
 
 @dataclass(frozen=True)

chia/types/unfinished_header_block.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
-from chia_rs import Foliage, FoliageTransactionBlock, RewardChainBlockUnfinished
+from chia_rs import EndOfSubSlotBundle, Foliage, FoliageTransactionBlock, RewardChainBlockUnfinished
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint128
 
 from chia.types.blockchain_format.vdf import VDFProof
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 from chia.util.streamable import Streamable, streamable
 
 

chia/types/validation_state.py

@@ -3,10 +3,9 @@ from __future__ import annotations
 import dataclasses
 from typing import Optional
 
+from chia_rs import BlockRecord
 from chia_rs.sized_ints import uint64
 
-from chia.consensus.block_record import BlockRecord
-
 
 @dataclasses.dataclass
 class ValidationState:

chia/types/weight_proof.py

@@ -2,10 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from chia_rs import RewardChainBlock, SubEpochChallengeSegment, SubEpochData
+from chia_rs import EndOfSubSlotBundle, HeaderBlock, RewardChainBlock, SubEpochChallengeSegment, SubEpochData
 
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.header_block import HeaderBlock
 from chia.util.streamable import Streamable, streamable
 
 # number of challenge blocks

chia/util/action_scope.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import contextlib
 from collections.abc import AsyncIterator, Awaitable
 from dataclasses import dataclass, field
-from typing import Callable, Generic, Optional, Protocol, TypeVar, final
+from typing import Callable, Generic, Optional, Protocol, TypeVar
 
 import aiosqlite
+from typing_extensions import Self
 
 from chia.util.db_wrapper import DBWrapper2, execute_fetchone
 
@@ -80,14 +81,13 @@ class SideEffects(Protocol):
     def __bytes__(self) -> bytes: ...
 
     @classmethod
-    def from_bytes(cls: type[_T_SideEffects], blob: bytes) -> _T_SideEffects: ...
+    def from_bytes(cls, blob: bytes) -> Self: ...
 
 
 _T_SideEffects = TypeVar("_T_SideEffects", bound=SideEffects)
 _T_Config = TypeVar("_T_Config")
 
 
-@final
 @dataclass
 class ActionScope(Generic[_T_SideEffects, _T_Config]):
     """

chia/util/block_cache.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
+from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.block_record import BlockRecord
-
 
 # implements BlockRecordsProtocol
 class BlockCache:

chia/util/byte_types.py

@@ -7,6 +7,6 @@ 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"):
+    if input_str.startswith(("0x", "0X")):
         return bytes.fromhex(input_str[2:])
     return bytes.fromhex(input_str)

chia/util/casts.py

@@ -0,0 +1,21 @@
+# This file converts between chialisp bytes and Python integer
+from __future__ import annotations
+
+
+def int_from_bytes(blob: bytes) -> int:
+    size = len(blob)
+    if size == 0:
+        return 0
+    return int.from_bytes(blob, "big", signed=True)
+
+
+def int_to_bytes(v: int) -> bytes:
+    byte_count = (v.bit_length() + 8) >> 3
+    if v == 0:
+        return b""
+    r = v.to_bytes(byte_count, "big", signed=True)
+    # make sure the string returned is minimal
+    # ie. no leading 00 or ff bytes that are unnecessary
+    while len(r) > 1 and r[0] == (0xFF if r[1] & 0x80 else 0):
+        r = r[1:]
+    return r

chia/util/config.py

@@ -18,8 +18,6 @@ import importlib_resources
 import yaml
 from typing_extensions import Literal
 
-from chia.server.outbound_message import NodeType
-from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.lock import Lockfile
 
 log = logging.getLogger(__name__)
@@ -330,38 +328,3 @@ def load_defaults_for_missing_services(config: dict[str, Any], config_name: str)
                     defaulted[service]["selected_network"] = "".join(to_be_referenced)
 
     return defaulted
-
-
-PEER_INFO_MAPPING: dict[NodeType, str] = {
-    NodeType.FULL_NODE: "full_node_peer",
-    NodeType.FARMER: "farmer_peer",
-}
-
-
-def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeType) -> set[UnresolvedPeerInfo]:
-    peer_info_key = PEER_INFO_MAPPING[peer_type]
-    peer_infos: list[dict[str, Any]] = service_config.get(f"{peer_info_key}s", [])
-    peer_info: Optional[dict[str, Any]] = service_config.get(peer_info_key)
-    if peer_info is not None:
-        peer_infos.append(peer_info)
-
-    return {UnresolvedPeerInfo(host=peer["host"], port=peer["port"]) for peer in peer_infos}
-
-
-def set_peer_info(
-    service_config: dict[str, Any],
-    peer_type: NodeType,
-    peer_host: Optional[str] = None,
-    peer_port: Optional[int] = None,
-) -> None:
-    peer_info_key = PEER_INFO_MAPPING[peer_type]
-    if peer_info_key in service_config:
-        if peer_host is not None:
-            service_config[peer_info_key]["host"] = peer_host
-        if peer_port is not None:
-            service_config[peer_info_key]["port"] = peer_port
-    elif f"{peer_info_key}s" in service_config and len(service_config[f"{peer_info_key}s"]) > 0:
-        if peer_host is not None:
-            service_config[f"{peer_info_key}s"][0]["host"] = peer_host
-        if peer_port is not None:
-            service_config[f"{peer_info_key}s"][0]["port"] = peer_port

chia/util/db_wrapper.py

@@ -54,6 +54,13 @@ class InternalError(DBWrapperError):
     pass
 
 
+class PurposefulAbort(DBWrapperError):
+    obj: object
+
+    def __init__(self, obj: object) -> None:
+        self.obj = obj
+
+
 def generate_in_memory_db_uri() -> str:
     # We need to use shared cache as our DB wrapper uses different types of connections
     return f"file:db_{secrets.token_hex(16)}?mode=memory&cache=shared"
@@ -307,7 +314,7 @@ class DBWrapper2:
                 #       probably skip the nested foreign key check when exiting since
                 #       we don't have many foreign key errors and so it is likely ok
                 #       to save the extra time checking twice.
-                raise NestedForeignKeyDelayedRequestError()
+                raise NestedForeignKeyDelayedRequestError
             async with self._savepoint_ctx():
                 yield self._write_connection
             return

chia/util/errors.py

@@ -194,6 +194,9 @@ class Err(Enum):
     INVALID_COIN_ID = 146
     # message not sent/received
     MESSAGE_NOT_SENT_OR_RECEIVED = 147
+    # the transactions generator uses overlong encoding of CLVM atoms in its
+    # serialization
+    INVALID_TRANSACTIONS_GENERATOR_ENCODING = 148
 
 
 class ValidationError(Exception):
@@ -349,5 +352,3 @@ class CliRpcConnectionError(ClickException):
     """
     This error is raised when a rpc server cant be reached by the cli async generator
     """
-
-    pass

chia/util/initial-config.yaml

@@ -19,7 +19,8 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
     testnet0:
-      MIN_PLOT_SIZE: 18
+      MIN_PLOT_SIZE_V1: 18
+      MIN_PLOT_SIZE_V2: 20
       GENESIS_CHALLENGE: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
@@ -32,12 +33,12 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 3ef7c233fc0785f3c0cae5992c1d35e7c955ca37a423571c1607ba392a9d12f7
       MEMPOOL_BLOCK_BUFFER: 10
-      MIN_PLOT_SIZE: 18
+      MIN_PLOT_SIZE_V1: 18
+      MIN_PLOT_SIZE_V2: 20
       NETWORK_TYPE: 1
       SUB_SLOT_ITERS_STARTING: 67108864
       # Forks activated from the beginning on this network
       HARD_FORK_HEIGHT: 0
-      SOFT_FORK6_HEIGHT: 2000000
       PLOT_FILTER_128_HEIGHT: 6029568
       PLOT_FILTER_64_HEIGHT: 11075328
       PLOT_FILTER_32_HEIGHT: 16121088
@@ -50,7 +51,8 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
       MEMPOOL_BLOCK_BUFFER: 10
-      MIN_PLOT_SIZE: 18
+      MIN_PLOT_SIZE_V1: 18
+      MIN_PLOT_SIZE_V2: 20
       NETWORK_TYPE: 1
       SUB_SLOT_ITERS_STARTING: 67108864
   config:
@@ -306,6 +308,21 @@ full_node:
   #         the particular system we're running on. Defaults to "full".
   db_sync: "auto"
 
+  # Determine which version of block creation function to use:
+  # 0: Original function, first fill a block with transactions, then compress
+  #    it, then run it to compute its cost. The final block may not use all
+  #    available block cost.
+  # 1: Compressed block function. Compress transactions into the block as they
+  #    are added. Use the new, optimized, compression function. This produces
+  #    blocks that fill up the allowed block cost.
+
+  # block_creation: 0
+
+  # If we spend more than this many seconds forming the new transactions block
+  # generator, stop and just go with what we have so far. This is a safety
+  # measure to not spend too much time building the block generator.
+  # block_creation_timeout: 2.0
+
   # the number of threads used to read from the blockchain database
   # concurrently. There's always only 1 writer, but the number of readers is
   # configurable
@@ -682,4 +699,3 @@ simulator:
 
   # Fork Settings
   HARD_FORK_HEIGHT: 0
-  SOFT_FORK6_HEIGHT: 0

chia/util/keychain.py

@@ -79,12 +79,11 @@ def bytes_to_mnemonic(mnemonic_bytes: bytes) -> str:
     CS = len(mnemonic_bytes) // 4
 
     checksum = BitArray(bytes(std_hash(mnemonic_bytes)))[:CS]
-
     bitarray = BitArray(mnemonic_bytes) + checksum
     mnemonics = []
     assert len(bitarray) % 11 == 0
 
-    for i in range(0, len(bitarray) // 11):
+    for i in range(len(bitarray) // 11):
         start = i * 11
         end = start + 11
         bits = bitarray[start:end]
@@ -127,7 +126,7 @@ def bytes_from_mnemonic(mnemonic_str: str) -> bytes:
 
     word_list = {word: i for i, word in enumerate(bip39_word_list().splitlines())}
     bit_array = BitArray()
-    for i in range(0, len(mnemonic)):
+    for i in range(len(mnemonic)):
         word = mnemonic[i]
         if word not in word_list:
             raise ValueError(f"'{word}' is not in the mnemonic dictionary; may be misspelled")
@@ -264,24 +263,24 @@ class KeyData(Streamable):
     @property
     def mnemonic(self) -> list[str]:
         if self.secrets is None:
-            raise KeychainSecretsMissing()
+            raise KeychainSecretsMissing
         return self.secrets.mnemonic
 
     def mnemonic_str(self) -> str:
         if self.secrets is None:
-            raise KeychainSecretsMissing()
+            raise KeychainSecretsMissing
         return self.secrets.mnemonic_str()
 
     @property
     def entropy(self) -> bytes:
         if self.secrets is None:
-            raise KeychainSecretsMissing()
+            raise KeychainSecretsMissing
         return self.secrets.entropy
 
     @property
     def private_key(self) -> PrivateKey:
         if self.secrets is None:
-            raise KeychainSecretsMissing()
+            raise KeychainSecretsMissing
         return self.secrets.private_key