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

chia/consensus/block_body_validation.py

@@ -6,20 +6,25 @@ from collections.abc import Awaitable, Collection
 from dataclasses import dataclass, field
 from typing import Callable, Optional, Union
 
-from chia_rs import ConsensusConstants, SpendBundleConditions, compute_merkle_set_root
+from chia_rs import (
+    BlockRecord,
+    ConsensusConstants,
+    FullBlock,
+    SpendBundleConditions,
+    UnfinishedBlock,
+    compute_merkle_set_root,
+    is_canonical_serialization,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from chiabip158 import PyBIP158
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.check_time_locks import check_time_locks
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
-from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
 from chia.types.coin_record import CoinRecord
-from chia.types.full_block import FullBlock
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.util.errors import Err
 from chia.util.hash import std_hash
 
@@ -44,6 +49,8 @@ class ForkAdd:
     timestamp: uint64
     hint: Optional[bytes]
     is_coinbase: bool
+    # This means matching parent puzzle hash and amount
+    same_as_parent: bool
 
 
 @dataclass(frozen=True)
@@ -82,61 +89,64 @@ class ForkInfo:
         self.removals_since_fork = {}
         self.block_hashes = []
 
-    def include_spends(self, conds: Optional[SpendBundleConditions], block: FullBlock, header_hash: bytes32) -> None:
-        height = block.height
-
-        assert self.peak_height == height - 1
-
+    def update_fork_peak(self, block: FullBlock, header_hash: bytes32) -> None:
+        """Updates `self` with `block`'s height and `header_hash`."""
+        assert self.peak_height == block.height - 1
         assert len(self.block_hashes) == self.peak_height - self.fork_height
         assert block.height == self.fork_height + 1 + len(self.block_hashes)
         self.block_hashes.append(header_hash)
-
         self.peak_height = int(block.height)
         self.peak_hash = header_hash
 
+    def include_reward_coins(self, block: FullBlock) -> None:
+        """Updates `self` with `block`'s reward coins."""
+        for coin in block.get_included_reward_coins():
+            assert block.foliage_transaction_block is not None
+            timestamp = block.foliage_transaction_block.timestamp
+            coin_id = coin.name()
+            assert coin_id not in self.additions_since_fork
+            self.additions_since_fork[coin_id] = ForkAdd(
+                coin, block.height, timestamp, hint=None, is_coinbase=True, same_as_parent=False
+            )
+
+    def include_spends(self, conds: Optional[SpendBundleConditions], block: FullBlock, header_hash: bytes32) -> None:
+        self.update_fork_peak(block, header_hash)
         if conds is not None:
             assert block.foliage_transaction_block is not None
             timestamp = block.foliage_transaction_block.timestamp
             for spend in conds.spends:
-                self.removals_since_fork[bytes32(spend.coin_id)] = ForkRem(bytes32(spend.puzzle_hash), height)
+                spend_coin_id = bytes32(spend.coin_id)
+                self.removals_since_fork[spend_coin_id] = ForkRem(bytes32(spend.puzzle_hash), block.height)
                 for puzzle_hash, amount, hint in spend.create_coin:
-                    coin = Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(amount))
-                    self.additions_since_fork[coin.name()] = ForkAdd(coin, height, timestamp, hint, False)
-        for coin in block.get_included_reward_coins():
-            assert block.foliage_transaction_block is not None
-            timestamp = block.foliage_transaction_block.timestamp
-            assert coin.name() not in self.additions_since_fork
-            self.additions_since_fork[coin.name()] = ForkAdd(coin, block.height, timestamp, None, True)
+                    coin = Coin(spend_coin_id, bytes32(puzzle_hash), uint64(amount))
+                    same_as_parent = coin.puzzle_hash == spend.puzzle_hash and amount == spend.coin_amount
+                    self.additions_since_fork[coin.name()] = ForkAdd(
+                        coin, block.height, timestamp, hint=hint, is_coinbase=False, same_as_parent=same_as_parent
+                    )
+        self.include_reward_coins(block)
 
     def include_block(
         self,
         additions: list[tuple[Coin, Optional[bytes]]],
-        removals: list[Coin],
+        removals: list[tuple[bytes32, Coin]],
         block: FullBlock,
         header_hash: bytes32,
     ) -> None:
-        height = block.height
-
-        assert self.peak_height == height - 1
-
-        assert len(self.block_hashes) == self.peak_height - self.fork_height
-        assert block.height == self.fork_height + 1 + len(self.block_hashes)
-        self.block_hashes.append(header_hash)
-
-        self.peak_height = int(block.height)
-        self.peak_hash = header_hash
-
+        self.update_fork_peak(block, header_hash)
         if block.foliage_transaction_block is not None:
             timestamp = block.foliage_transaction_block.timestamp
-            for spend in removals:
-                self.removals_since_fork[bytes32(spend.name())] = ForkRem(bytes32(spend.puzzle_hash), height)
+            spent_coins: dict[bytes32, Coin] = {}
+            for spend_id, spend in removals:
+                spent_coins[bytes32(spend_id)] = spend
+                self.removals_since_fork[bytes32(spend_id)] = ForkRem(bytes32(spend.puzzle_hash), block.height)
             for coin, hint in additions:
-                self.additions_since_fork[coin.name()] = ForkAdd(coin, height, timestamp, hint, False)
-        for coin in block.get_included_reward_coins():
-            assert block.foliage_transaction_block is not None
-            timestamp = block.foliage_transaction_block.timestamp
-            assert coin.name() not in self.additions_since_fork
-            self.additions_since_fork[coin.name()] = ForkAdd(coin, block.height, timestamp, None, True)
+                parent = spent_coins.get(coin.parent_coin_info)
+                assert parent is not None
+                same_as_parent = coin.puzzle_hash == parent.puzzle_hash and coin.amount == parent.amount
+                self.additions_since_fork[coin.name()] = ForkAdd(
+                    coin, block.height, timestamp, hint=hint, is_coinbase=False, same_as_parent=same_as_parent
+                )
+        self.include_reward_coins(block)
 
     def rollback(self, header_hash: bytes32, height: int) -> None:
         assert height <= self.peak_height
@@ -366,6 +376,10 @@ async def validate_block_body(
         assert conds is not None
         assert conds.validated_signature
 
+        if prev_transaction_block_height >= constants.HARD_FORK2_HEIGHT:
+            if not is_canonical_serialization(bytes(block.transactions_generator)):
+                return Err.INVALID_TRANSACTIONS_GENERATOR_ENCODING
+
         for spend in conds.spends:
             removals.append(bytes32(spend.coin_id))
             removals_puzzle_dic[bytes32(spend.coin_id)] = bytes32(spend.puzzle_hash)
@@ -545,7 +559,7 @@ async def validate_block_body(
     # 21. Verify conditions
     # verify absolute/relative height/time conditions
     if conds is not None:
-        error = mempool_check_time_locks(
+        error = check_time_locks(
             removal_coin_records,
             conds,
             prev_transaction_block_height,

chia/consensus/block_creation.py

@@ -7,67 +7,40 @@ from typing import Callable, Optional
 
 import chia_rs
 from chia_rs import (
-    DONT_VALIDATE_SIGNATURE,
-    MEMPOOL_MODE,
+    BlockRecord,
     ConsensusConstants,
+    EndOfSubSlotBundle,
     Foliage,
     FoliageBlockData,
     FoliageTransactionBlock,
+    FullBlock,
     G1Element,
     G2Element,
     PoolTarget,
+    ProofOfSpace,
     RewardChainBlock,
     RewardChainBlockUnfinished,
     TransactionsInfo,
+    UnfinishedBlock,
     compute_merkle_set_root,
-    get_flags_for_height_and_constants,
-    run_block_generator,
-    run_block_generator2,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 from chiabip158 import PyBIP158
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
-from chia.full_node.signage_point import SignagePoint
+from chia.consensus.prev_transaction_block import get_prev_transaction_block
+from chia.consensus.signage_point import SignagePoint
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.full_block import FullBlock
-from chia.types.generator_types import BlockGenerator
-from chia.types.unfinished_block import UnfinishedBlock
+from chia.types.generator_types import NewBlockGenerator
 from chia.util.hash import std_hash
-from chia.util.prev_transaction_block import get_prev_transaction_block
 
 log = logging.getLogger(__name__)
 
 
-def compute_block_cost(generator: BlockGenerator, constants: ConsensusConstants, height: uint32) -> uint64:
-    flags = get_flags_for_height_and_constants(height, constants) | MEMPOOL_MODE | DONT_VALIDATE_SIGNATURE
-
-    if height >= constants.HARD_FORK_HEIGHT:
-        run_block = run_block_generator2
-    else:
-        run_block = run_block_generator
-
-    err, conds = run_block(
-        bytes(generator.program),
-        generator.generator_refs,
-        constants.MAX_BLOCK_COST_CLVM,
-        flags,
-        G2Element(),
-        None,
-        constants,
-    )
-    if conds is None:  # pragma: no cover
-        log.error(f"unexpected error while computing block cost: {err} height: {height} generator: {generator.program}")
-    return uint64(0 if conds is None else conds.cost)
-
-
 def compute_block_fee(additions: Sequence[Coin], removals: Sequence[Coin]) -> uint64:
     removal_amount = 0
     addition_amount = 0
@@ -81,10 +54,7 @@ def compute_block_fee(additions: Sequence[Coin], removals: Sequence[Coin]) -> ui
 def create_foliage(
     constants: ConsensusConstants,
     reward_block_unfinished: RewardChainBlockUnfinished,
-    block_generator: Optional[BlockGenerator],
-    aggregate_sig: G2Element,
-    additions: list[Coin],
-    removals: list[Coin],
+    new_block_gen: Optional[NewBlockGenerator],
     prev_block: Optional[BlockRecord],
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,
@@ -94,7 +64,6 @@ def create_foliage(
     get_plot_signature: Callable[[bytes32, G1Element], G2Element],
     get_pool_signature: Callable[[PoolTarget, Optional[G1Element]], Optional[G2Element]],
     seed: bytes,
-    compute_cost: Callable[[BlockGenerator, ConsensusConstants, uint32], uint64],
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64],
 ) -> tuple[Foliage, Optional[FoliageTransactionBlock], Optional[TransactionsInfo]]:
     """
@@ -105,8 +74,7 @@ def create_foliage(
     Args:
         constants: consensus constants being used for this chain
         reward_block_unfinished: the reward block to look at, potentially at the signage point
-        block_generator: transactions to add to the foliage block, if created
-        aggregate_sig: aggregate of all transactions (or infinity element)
+        new_block_gen: transactions to add to the foliage block, if created, including aggregate signature
         prev_block: the previous block at the signage point
         blocks: dict from header hash to blocks, of all ancestor blocks
         total_iters_sp: total iters at the signage point
@@ -164,18 +132,21 @@ def create_foliage(
         assert prev_block is not None
         prev_block_hash = prev_block.header_hash
 
+    generator_block_heights_list: list[uint32] = []
+
     foliage_transaction_block_hash: Optional[bytes32]
 
     if is_transaction_block:
-        cost = uint64(0)
+        cost: uint64
+        spend_bundle_fees: uint64
 
         # Calculate the cost of transactions
-        if block_generator is not None:
-            cost = compute_cost(block_generator, constants, height)
-
-            spend_bundle_fees = compute_fees(additions, removals)
+        if new_block_gen is not None:
+            cost = new_block_gen.cost
+            spend_bundle_fees = compute_fees(new_block_gen.additions, new_block_gen.removals)
         else:
             spend_bundle_fees = uint64(0)
+            cost = uint64(0)
 
         reward_claims_incorporated = []
         if height > 0:
@@ -217,14 +188,20 @@ def create_foliage(
                     )
                     reward_claims_incorporated += [pool_coin, farmer_coin]
                     curr = blocks.block_record(curr.prev_hash)
-        additions.extend(reward_claims_incorporated.copy())
-        for coin in additions:
+
+        for coin in reward_claims_incorporated:
             tx_additions.append(coin)
             byte_array_tx.append(bytearray(coin.puzzle_hash))
-        for coin in removals:
-            cname = coin.name()
-            tx_removals.append(cname)
-            byte_array_tx.append(bytearray(cname))
+
+        if new_block_gen is not None:
+            generator_block_heights_list = new_block_gen.block_refs
+            for coin in new_block_gen.additions:
+                tx_additions.append(coin)
+                byte_array_tx.append(bytearray(coin.puzzle_hash))
+            for coin in new_block_gen.removals:
+                cname = coin.name()
+                tx_removals.append(cname)
+                byte_array_tx.append(bytearray(cname))
 
         bip158: PyBIP158 = PyBIP158(byte_array_tx)
         encoded = bytes(bip158.GetEncoded())
@@ -249,16 +226,20 @@ def create_foliage(
         removals_root = bytes32(compute_merkle_set_root(tx_removals))
 
         generator_hash = bytes32.zeros
-        if block_generator is not None:
-            generator_hash = std_hash(block_generator.program)
+        if new_block_gen is not None:
+            generator_hash = std_hash(new_block_gen.program)
 
         generator_refs_hash = bytes32([1] * 32)
+        if generator_block_heights_list not in (None, []):
+            generator_ref_list_bytes = b"".join([i.stream_to_bytes() for i in generator_block_heights_list])
+            generator_refs_hash = std_hash(generator_ref_list_bytes)
+
         filter_hash: bytes32 = std_hash(encoded)
 
         transactions_info: Optional[TransactionsInfo] = TransactionsInfo(
             generator_hash,
             generator_refs_hash,
-            aggregate_sig,
+            new_block_gen.signature if new_block_gen else G2Element(),
             spend_bundle_fees,
             cost,
             reward_claims_incorporated,
@@ -320,13 +301,9 @@ def create_unfinished_block(
     timestamp: uint64,
     blocks: BlockRecordsProtocol,
     seed: bytes = b"",
-    block_generator: Optional[BlockGenerator] = None,
-    aggregate_sig: G2Element = G2Element(),
-    additions: Optional[list[Coin]] = None,
-    removals: Optional[list[Coin]] = None,
+    new_block_gen: Optional[NewBlockGenerator] = None,
     prev_block: Optional[BlockRecord] = None,
     finished_sub_slots_input: Optional[list[EndOfSubSlotBundle]] = None,
-    compute_cost: Callable[[BlockGenerator, ConsensusConstants, uint32], uint64] = compute_block_cost,
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64] = compute_block_fee,
 ) -> UnfinishedBlock:
     """
@@ -349,10 +326,7 @@ def create_unfinished_block(
         signage_point: signage point information (VDFs)
         timestamp: timestamp to add to the foliage block, if created
         seed: seed to randomize chain
-        block_generator: transactions to add to the foliage block, if created
-        aggregate_sig: aggregate of all transactions (or infinity element)
-        additions: Coins added in spend_bundle
-        removals: Coins removed in spend_bundle
+        new_block_gen: transactions to add to the foliage block, if created, including aggregate signature
         prev_block: previous block (already in chain) from the signage point
         blocks: dictionary from header hash to SBR of all included SBR
         finished_sub_slots_input: finished_sub_slots at the signage point
@@ -411,17 +385,10 @@ def create_unfinished_block(
         signage_point.rc_vdf,
         rc_sp_signature,
     )
-    if additions is None:
-        additions = []
-    if removals is None:
-        removals = []
     (foliage, foliage_transaction_block, transactions_info) = create_foliage(
         constants,
         rc_block,
-        block_generator,
-        aggregate_sig,
-        additions,
-        removals,
+        new_block_gen,
         prev_block,
         blocks,
         total_iters_sp,
@@ -431,7 +398,6 @@ def create_unfinished_block(
         get_plot_signature,
         get_pool_signature,
         seed,
-        compute_cost,
         compute_fees,
     )
     return UnfinishedBlock(
@@ -442,8 +408,8 @@ def create_unfinished_block(
         foliage,
         foliage_transaction_block,
         transactions_info,
-        block_generator.program if block_generator else None,
-        [],  # generator_refs
+        new_block_gen.program if new_block_gen else None,
+        new_block_gen.block_refs if new_block_gen else [],
     )
 
 

chia/consensus/block_header_validation.py

@@ -4,30 +4,34 @@ import logging
 import time
 from typing import Optional
 
-from chia_rs import AugSchemeMPL, ConsensusConstants
+from chia_rs import (
+    AugSchemeMPL,
+    BlockRecord,
+    ChallengeChainSubSlot,
+    ConsensusConstants,
+    EndOfSubSlotBundle,
+    HeaderBlock,
+    RewardChainSubSlot,
+    SubSlotProofs,
+)
 from chia_rs.sized_bytes import bytes32
 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 can_finish_sub_and_full_epoch
-from chia.consensus.get_block_challenge import final_eos_is_already_included, get_block_challenge
+from chia.consensus.get_block_challenge import final_eos_is_already_included, get_block_challenge, prev_tx_block
 from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
-    calculate_iterations_quality,
     calculate_sp_interval_iters,
     calculate_sp_iters,
     is_overflow_block,
+    validate_pospace_and_get_required_iters,
 )
 from chia.consensus.vdf_info_computation import get_signage_point_vdf_info
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
-from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot, SubSlotProofs
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof, validate_vdf
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.header_block import HeaderBlock
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 from chia.types.validation_state import ValidationState
 from chia.util.errors import Err, ValidationError
@@ -58,6 +62,15 @@ def validate_unfinished_header_block(
     skip_overflow_last_ss_validation must be set to True. This will skip validation of end of slots, sub-epochs,
     and lead to other small tweaks in validation.
     """
+
+    # some of the checks numbers may be out of order this is because all
+    # checks need to be valid regardless of order and the numbers are reflecting the numbers as written in the chia docs
+
+    # 6. check signage point index
+    # no need to check negative values as this is uint 8
+    if header_block.reward_chain_block.signage_point_index >= constants.NUM_SPS_SUB_SLOT:
+        return None, ValidationError(Err.INVALID_SP_INDEX)
+
     # 1. Check that the previous block exists in the blockchain, or that it is correct
 
     prev_b = blocks.try_block_record(header_block.prev_header_hash)
@@ -486,25 +499,18 @@ def validate_unfinished_header_block(
     else:
         cc_sp_hash = header_block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
 
-    q_str: Optional[bytes32] = verify_and_get_quality_string(
-        header_block.reward_chain_block.proof_of_space, constants, challenge, cc_sp_hash, height=height
-    )
-    if q_str is None:
-        return None, ValidationError(Err.INVALID_POSPACE)
-
-    # 6. check signage point index
-    # no need to check negative values as this is uint 8
-    if header_block.reward_chain_block.signage_point_index >= constants.NUM_SPS_SUB_SLOT:
-        return None, ValidationError(Err.INVALID_SP_INDEX)
-
-    # Note that required iters might be from the previous slot (if we are in an overflow block)
-    required_iters: uint64 = calculate_iterations_quality(
-        constants.DIFFICULTY_CONSTANT_FACTOR,
-        q_str,
-        header_block.reward_chain_block.proof_of_space.size,
-        expected_vs.difficulty,
+    required_iters = validate_pospace_and_get_required_iters(
+        constants,
+        header_block.reward_chain_block.proof_of_space,
+        challenge,
         cc_sp_hash,
+        height,
+        expected_vs.difficulty,
+        expected_vs.ssi,
+        prev_tx_block(blocks, prev_b),
     )
+    if required_iters is None:
+        return None, ValidationError(Err.INVALID_POSPACE)
 
     # 7. check required iters
     if required_iters >= calculate_sp_interval_iters(constants, expected_vs.ssi):
@@ -824,7 +830,7 @@ def validate_unfinished_header_block(
             assert prev_transaction_b.timestamp is not None
             if header_block.foliage_transaction_block.timestamp <= prev_transaction_b.timestamp:
                 return None, ValidationError(Err.TIMESTAMP_TOO_FAR_IN_PAST)
-    return required_iters, None  # Valid unfinished header block
+    return required_iters, None
 
 
 def validate_finished_header_block(

chia/consensus/block_record.py

@@ -2,13 +2,10 @@ from __future__ import annotations
 
 from typing import Optional
 
-import chia_rs
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from typing_extensions import Protocol
 
-BlockRecord = chia_rs.BlockRecord
-
 
 class BlockRecordProtocol(Protocol):
     @property