chia-blockchain 2.4.4__py3-none-any.whl

chia/consensus/multiprocess_validation.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+import traceback
+from concurrent.futures import Executor
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from chia_rs import AugSchemeMPL, SpendBundleConditions
+
+from chia.consensus.block_header_validation import validate_finished_header_block
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain_interface import BlocksProtocol
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.cost_calculator import NPCResult
+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.get_block_generator import get_block_generator
+from chia.consensus.pot_iterations import calculate_iterations_quality, is_overflow_block
+from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
+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.sized_bytes import bytes32
+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.unfinished_block import UnfinishedBlock
+from chia.util.augmented_chain import AugmentedBlockchain
+from chia.util.block_cache import BlockCache
+from chia.util.condition_tools import pkm_pairs
+from chia.util.errors import Err, ValidationError
+from chia.util.generator_tools import get_block_header, tx_removals_and_additions
+from chia.util.ints import uint16, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+log = logging.getLogger(__name__)
+
+
+@streamable
+@dataclass(frozen=True)
+class PreValidationResult(Streamable):
+    error: Optional[uint16]
+    required_iters: Optional[uint64]  # Iff error is None
+    conds: Optional[SpendBundleConditions]  # Iff error is None and block is a transaction block
+    validated_signature: bool
+    timing: uint32  # the time (in milliseconds) it took to pre-validate the block
+
+
+def batch_pre_validate_blocks(
+    constants: ConsensusConstants,
+    blocks_pickled: Dict[bytes, bytes],
+    full_blocks_pickled: List[bytes],
+    prev_transaction_generators: List[Optional[List[bytes]]],
+    conditions: Dict[uint32, bytes],
+    expected_difficulty: List[uint64],
+    expected_sub_slot_iters: List[uint64],
+    validate_signatures: bool,
+    prev_ses_block_bytes: Optional[List[Optional[bytes]]] = None,
+) -> List[bytes]:
+    blocks: Dict[bytes32, BlockRecord] = {}
+    for k, v in blocks_pickled.items():
+        blocks[bytes32(k)] = BlockRecord.from_bytes_unchecked(v)
+    results: List[PreValidationResult] = []
+
+    # In this case, we are validating full blocks, not headers
+    for i in range(len(full_blocks_pickled)):
+        try:
+            validation_start = time.monotonic()
+            block: FullBlock = FullBlock.from_bytes_unchecked(full_blocks_pickled[i])
+            tx_additions: List[Coin] = []
+            removals: List[bytes32] = []
+            conds: Optional[SpendBundleConditions] = None
+            if block.height in conditions:
+                conds = SpendBundleConditions.from_bytes(conditions[block.height])
+                removals, tx_additions = tx_removals_and_additions(conds)
+            elif block.transactions_generator is not None:
+                # TODO: this function would be simpler if conditions were
+                # required to be passed in for all transaction blocks. We would
+                # no longer need prev_transaction_generators
+                prev_generators = prev_transaction_generators[i]
+                assert prev_generators is not None
+                assert block.transactions_info is not None
+                block_generator = BlockGenerator(block.transactions_generator, prev_generators)
+                assert block_generator.program == block.transactions_generator
+                npc_result = get_name_puzzle_conditions(
+                    block_generator,
+                    min(constants.MAX_BLOCK_COST_CLVM, block.transactions_info.cost),
+                    mempool_mode=False,
+                    height=block.height,
+                    constants=constants,
+                )
+                if npc_result.error is not None:
+                    validation_time = time.monotonic() - validation_start
+                    results.append(
+                        PreValidationResult(
+                            uint16(npc_result.error), None, npc_result.conds, False, uint32(validation_time * 1000)
+                        )
+                    )
+                    continue
+                assert npc_result.conds is not None
+                conds = npc_result.conds
+                removals, tx_additions = tx_removals_and_additions(conds)
+
+            header_block = get_block_header(block, tx_additions, removals)
+            prev_ses_block = None
+            if prev_ses_block_bytes is not None and len(prev_ses_block_bytes) > 0:
+                buffer = prev_ses_block_bytes[i]
+                if buffer is not None:
+                    prev_ses_block = BlockRecord.from_bytes_unchecked(buffer)
+            required_iters, error = validate_finished_header_block(
+                constants,
+                BlockCache(blocks),
+                header_block,
+                True,  # check_filter
+                expected_difficulty[i],
+                expected_sub_slot_iters[i],
+                prev_ses_block=prev_ses_block,
+            )
+            error_int: Optional[uint16] = None
+            if error is not None:
+                error_int = uint16(error.code.value)
+
+            successfully_validated_signatures = False
+            # If we failed header block validation, no need to validate
+            # signature, the block is already invalid If this is False, it means
+            # either we don't have a signature (not a tx block) or we have an
+            # invalid signature (which also puts in an error) or we didn't
+            # validate the signature because we want to validate it later.
+            # add_block will attempt to validate the signature later.
+            if error_int is None and validate_signatures and conds is not None:
+                assert block.transactions_info is not None
+                pairs_pks, pairs_msgs = pkm_pairs(conds, constants.AGG_SIG_ME_ADDITIONAL_DATA)
+                if not AugSchemeMPL.aggregate_verify(
+                    pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature
+                ):
+                    error_int = uint16(Err.BAD_AGGREGATE_SIGNATURE.value)
+                else:
+                    successfully_validated_signatures = True
+
+            validation_time = time.monotonic() - validation_start
+            results.append(
+                PreValidationResult(
+                    error_int,
+                    required_iters,
+                    conds,
+                    successfully_validated_signatures,
+                    uint32(validation_time * 1000),
+                )
+            )
+        except Exception:
+            error_stack = traceback.format_exc()
+            log.error(f"Exception: {error_stack}")
+            validation_time = time.monotonic() - validation_start
+            results.append(
+                PreValidationResult(uint16(Err.UNKNOWN.value), None, None, False, uint32(validation_time * 1000))
+            )
+    return [bytes(r) for r in results]
+
+
+async def pre_validate_blocks_multiprocessing(
+    constants: ConsensusConstants,
+    block_records: BlocksProtocol,
+    blocks: Sequence[FullBlock],
+    pool: Executor,
+    block_height_conds_map: Dict[uint32, SpendBundleConditions],
+    *,
+    sub_slot_iters: uint64,
+    difficulty: uint64,
+    prev_ses_block: Optional[BlockRecord],
+    wp_summaries: Optional[List[SubEpochSummary]] = None,
+    validate_signatures: bool = True,
+) -> List[PreValidationResult]:
+    """
+    This method must be called under the blockchain lock
+    If all the full blocks pass pre-validation, (only validates header), returns the list of required iters.
+    if any validation issue occurs, returns False.
+
+    Args:
+        constants:
+        pool:
+        constants:
+        block_records:
+        blocks: list of full blocks to validate (must be connected to current chain)
+        npc_results
+    """
+    prev_b: Optional[BlockRecord] = None
+
+    # Collects all the recent blocks (up to the previous sub-epoch)
+    recent_blocks: Dict[bytes32, BlockRecord] = {}
+    num_sub_slots_found = 0
+    num_blocks_seen = 0
+
+    if blocks[0].height > 0:
+        curr = block_records.try_block_record(blocks[0].prev_header_hash)
+        if curr is None:
+            return [PreValidationResult(uint16(Err.INVALID_PREV_BLOCK_HASH.value), None, None, False, uint32(0))]
+        prev_b = curr
+        num_sub_slots_to_look_for = 3 if curr.overflow else 2
+        header_hash = curr.header_hash
+        while (
+            curr.sub_epoch_summary_included is None
+            or num_blocks_seen < constants.NUMBER_OF_TIMESTAMPS
+            or num_sub_slots_found < num_sub_slots_to_look_for
+        ) and curr.height > 0:
+            if curr.first_in_sub_slot:
+                assert curr.finished_challenge_slot_hashes is not None
+                num_sub_slots_found += len(curr.finished_challenge_slot_hashes)
+            recent_blocks[header_hash] = curr
+            if curr.is_transaction_block:
+                num_blocks_seen += 1
+            header_hash = curr.prev_hash
+            curr = block_records.block_record(curr.prev_hash)
+            assert curr is not None
+        recent_blocks[header_hash] = curr
+
+    # the agumented blockchain object will let us add temporary block records
+    # they won't actually be added to the underlying blockchain object
+    blockchain = AugmentedBlockchain(block_records)
+
+    diff_ssis: List[Tuple[uint64, uint64]] = []
+    prev_ses_block_list: List[Optional[BlockRecord]] = []
+
+    for block in blocks:
+        if len(block.finished_sub_slots) > 0:
+            if block.finished_sub_slots[0].challenge_chain.new_difficulty is not None:
+                difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty
+            if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
+                sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
+        overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
+        challenge = get_block_challenge(constants, block, BlockCache(recent_blocks), prev_b is None, overflow, False)
+        if block.reward_chain_block.challenge_chain_sp_vdf is None:
+            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 [PreValidationResult(uint16(Err.INVALID_POSPACE.value), None, None, False, uint32(0))]
+
+        required_iters: uint64 = calculate_iterations_quality(
+            constants.DIFFICULTY_CONSTANT_FACTOR,
+            q_str,
+            block.reward_chain_block.proof_of_space.size,
+            difficulty,
+            cc_sp_hash,
+        )
+
+        try:
+            block_rec = block_to_block_record(
+                constants,
+                blockchain,
+                required_iters,
+                block,
+                sub_slot_iters=sub_slot_iters,
+                prev_ses_block=prev_ses_block,
+            )
+        except ValueError:
+            return [PreValidationResult(uint16(Err.INVALID_SUB_EPOCH_SUMMARY.value), None, None, False, uint32(0))]
+
+        if block_rec.sub_epoch_summary_included is not None and wp_summaries is not None:
+            next_ses = wp_summaries[int(block.height / constants.SUB_EPOCH_BLOCKS) - 1]
+            if not block_rec.sub_epoch_summary_included.get_hash() == next_ses.get_hash():
+                log.error("sub_epoch_summary does not match wp sub_epoch_summary list")
+                return [PreValidationResult(uint16(Err.INVALID_SUB_EPOCH_SUMMARY.value), None, None, False, uint32(0))]
+
+        recent_blocks[block_rec.header_hash] = block_rec
+        blockchain.add_extra_block(block, block_rec)  # Temporarily add block to chain
+        prev_b = block_rec
+        diff_ssis.append((difficulty, sub_slot_iters))
+        prev_ses_block_list.append(prev_ses_block)
+        if block_rec.sub_epoch_summary_included is not None:
+            prev_ses_block = block_rec
+
+    conditions_pickled = {}
+    for k, v in block_height_conds_map.items():
+        conditions_pickled[k] = bytes(v)
+    futures = []
+    # Pool of workers to validate blocks concurrently
+    recent_blocks_bytes = {bytes(k): bytes(v) for k, v in recent_blocks.items()}  # convert to bytes
+
+    batch_size = 4
+    for i in range(0, len(blocks), batch_size):
+        end_i = min(i + batch_size, len(blocks))
+        blocks_to_validate = blocks[i:end_i]
+        b_pickled: List[bytes] = []
+        previous_generators: List[Optional[List[bytes]]] = []
+        for block in blocks_to_validate:
+            assert isinstance(block, FullBlock)
+            b_pickled.append(bytes(block))
+            try:
+                block_generator: Optional[BlockGenerator] = await get_block_generator(
+                    blockchain.lookup_block_generators, block
+                )
+            except ValueError:
+                return [
+                    PreValidationResult(
+                        uint16(Err.FAILED_GETTING_GENERATOR_MULTIPROCESSING.value), None, None, False, uint32(0)
+                    )
+                ]
+            if block_generator is not None:
+                previous_generators.append(block_generator.generator_refs)
+            else:
+                previous_generators.append(None)
+
+        ses_blocks_bytes_list: List[Optional[bytes]] = []
+        for j in range(i, end_i):
+            ses_block_rec = prev_ses_block_list[j]
+            if ses_block_rec is None:
+                ses_blocks_bytes_list.append(None)
+            else:
+                ses_blocks_bytes_list.append(bytes(ses_block_rec))
+
+        futures.append(
+            asyncio.get_running_loop().run_in_executor(
+                pool,
+                batch_pre_validate_blocks,
+                constants,
+                recent_blocks_bytes,
+                b_pickled,
+                previous_generators,
+                conditions_pickled,
+                [diff_ssis[j][0] for j in range(i, end_i)],
+                [diff_ssis[j][1] for j in range(i, end_i)],
+                validate_signatures,
+                ses_blocks_bytes_list,
+            )
+        )
+    # Collect all results into one flat list
+    return [
+        PreValidationResult.from_bytes(result)
+        for batch_result in (await asyncio.gather(*futures))
+        for result in batch_result
+    ]
+
+
+def _run_generator(
+    constants: ConsensusConstants,
+    unfinished_block_bytes: bytes,
+    block_generator_bytes: bytes,
+    height: uint32,
+) -> Optional[bytes]:
+    """
+    Runs the CLVM generator from bytes inputs. This is meant to be called under a ProcessPoolExecutor, in order to
+    validate the heavy parts of a block (clvm program) in a different process.
+    """
+    try:
+        unfinished_block: UnfinishedBlock = UnfinishedBlock.from_bytes(unfinished_block_bytes)
+        assert unfinished_block.transactions_info is not None
+        block_generator: BlockGenerator = BlockGenerator.from_bytes(block_generator_bytes)
+        assert block_generator.program == unfinished_block.transactions_generator
+        npc_result: NPCResult = get_name_puzzle_conditions(
+            block_generator,
+            min(constants.MAX_BLOCK_COST_CLVM, unfinished_block.transactions_info.cost),
+            mempool_mode=False,
+            height=height,
+            constants=constants,
+        )
+        return bytes(npc_result)
+    except ValidationError as e:
+        return bytes(NPCResult(uint16(e.code.value), None))
+    except Exception:
+        return bytes(NPCResult(uint16(Err.UNKNOWN.value), None))

chia/consensus/pos_quality.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from chia.util.ints import uint64
+
+# The actual space in bytes of a plot, is _expected_plot_size(k) * UI_ACTUAL_SPACE_CONSTANT_FACTO
+# This is not used in consensus, only for display purposes
+UI_ACTUAL_SPACE_CONSTANT_FACTOR = 0.78
+
+
+def _expected_plot_size(k: int) -> uint64:
+    """
+    Given the plot size parameter k (which is between 32 and 59), computes the
+    expected size of the plot in bytes (times a constant factor). This is based on efficient encoding
+    of the plot, and aims to be scale agnostic, so larger plots don't
+    necessarily get more rewards per byte. The +1 is added to give half a bit more space per entry, which
+    is necessary to store the entries in the plot.
+    """
+
+    return uint64(((2 * k) + 1) * (2 ** (k - 1)))

chia/consensus/pot_iterations.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.pos_quality import _expected_plot_size
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+from chia.util.ints import uint8, uint64, uint128
+
+
+def is_overflow_block(constants: ConsensusConstants, signage_point_index: uint8) -> bool:
+    if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
+        raise ValueError("SP index too high")
+    return signage_point_index >= constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA
+
+
+def calculate_sp_interval_iters(constants: ConsensusConstants, sub_slot_iters: uint64) -> uint64:
+    assert sub_slot_iters % constants.NUM_SPS_SUB_SLOT == 0
+    return uint64(sub_slot_iters // constants.NUM_SPS_SUB_SLOT)
+
+
+def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, signage_point_index: uint8) -> uint64:
+    if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
+        raise ValueError("SP index too high")
+    return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index)
+
+
+def calculate_ip_iters(
+    constants: ConsensusConstants,
+    sub_slot_iters: uint64,
+    signage_point_index: uint8,
+    required_iters: uint64,
+) -> uint64:
+    # Note that the SSI is for the block passed in, which might be in the previous epoch
+    sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index)
+    sp_interval_iters: uint64 = calculate_sp_interval_iters(constants, sub_slot_iters)
+    if sp_iters % sp_interval_iters != 0 or sp_iters >= sub_slot_iters:
+        raise ValueError(f"Invalid sp iters {sp_iters} for this ssi {sub_slot_iters}")
+
+    if required_iters >= sp_interval_iters or required_iters == 0:
+        raise ValueError(
+            f"Required iters {required_iters} is not below the sp interval iters {sp_interval_iters} "
+            f"{sub_slot_iters} or not >0."
+        )
+
+    return uint64((sp_iters + constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % sub_slot_iters)
+
+
+def calculate_iterations_quality(
+    difficulty_constant_factor: uint128,
+    quality_string: bytes32,
+    size: int,
+    difficulty: uint64,
+    cc_sp_output_hash: bytes32,
+) -> 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))

chia/consensus/puzzles/chialisp_deserialisation.clsp

@@ -0,0 +1,69 @@
+;; this code is included in the ROM. Unfortunately, it has a problem that limits
+;; its usefulness: it is incapable of deserializing atoms with length longer than
+;; 8191 = 0x1fff.
+;;
+;; Because this code is included in the ROM, fixing the bug would be a hard fork
+;; so we're rather stuck with this bug. We recommend simply using a local version
+;; of this code when necessary.
+
+(mod (input)
+
+  (defconstant MAX_SINGLE_BYTE 0x7F)
+  (defconstant MAX_TWO_BYTE 0xbf)
+  (defconstant MAX_THREE_BYTE 0xdf)
+  (defconstant MAX_FOUR_BYTE 0xef)
+  (defconstant MAX_FIVE_BYTE 0xf7)
+  (defconstant MAX_SIX_BYTE 0xfb)
+  (defconstant CONS_BOX_MARKER 0xFF)
+
+  (defun sexp_from_stream (input_stream)
+    (if (= (substr input_stream 0 1) CONS_BOX_MARKER)
+        (cons_sexp_from_stream (sexp_from_stream (substr input_stream 1)))
+        (atom_from_stream (substr input_stream 1) (substr input_stream 0 1))
+    )
+  )
+
+  (defun cons_sexp_from_stream (left_sexp_with_input)
+    (cons_return (f left_sexp_with_input) (sexp_from_stream (f (r left_sexp_with_input))))
+  )
+
+  (defun cons_return (left_sexp right_sexp_with_input)
+    (list (c left_sexp (f right_sexp_with_input)) (f (r right_sexp_with_input)))
+  )
+
+  (defun atom_from_stream (input_file input_bits)
+    (if (= input_bits (quote 0x80))
+        (list () input_file)
+        (if (>s input_bits MAX_SINGLE_BYTE)
+            (atom_from_stream_part_two (get_bitcount input_bits input_file))
+            (list input_bits input_file)
+        )
+    )
+  )
+
+  ; Note that we reject any serialized atom here with more than 3 bytes of
+  ; encoded length prefix, even though the Rust and Python CLVM interpreters
+  ; and deserializers support more.
+  ; This allows 5 + 8 = 13 bits = 8191-byte atoms
+  ; Also note that this does not limit intermediate atom length. Those limits
+  ; are implemented in the clvm interpreters theselves
+  (defun-inline get_bitcount (input_bits input_file)
+    (if (>s input_bits MAX_TWO_BYTE)
+        (if (>s input_bits MAX_THREE_BYTE)
+            (x)
+            ;three byte length prefix
+            (list (concat (logand (quote 0x1f) input_bits) (substr input_file 0 1)) (substr input_file 1))
+        )
+        ;two byte length prefix
+        (list (logand (quote 0x3f) input_bits) input_file)
+    )
+  )
+
+  (defun atom_from_stream_part_two ((size_to_read input_file))
+    (list (substr input_file 0 size_to_read) (substr input_file size_to_read))
+  )
+
+  ; main
+  (f (sexp_from_stream input))
+
+)

chia/consensus/puzzles/chialisp_deserialisation.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff05ffff02ff3effff04ff02ffff04ff05ff8080808080ffff04ffff01ffffff81ff7fff81df81bfffffff02ffff03ffff09ff0bffff01818080ffff01ff04ff80ffff04ff05ff808080ffff01ff02ffff03ffff0aff0bff1880ffff01ff02ff1affff04ff02ffff04ffff02ffff03ffff0aff0bff1c80ffff01ff02ffff03ffff0aff0bff1480ffff01ff0880ffff01ff04ffff0effff18ffff011fff0b80ffff0cff05ff80ffff01018080ffff04ffff0cff05ffff010180ff80808080ff0180ffff01ff04ffff18ffff013fff0b80ffff04ff05ff80808080ff0180ff80808080ffff01ff04ff0bffff04ff05ff80808080ff018080ff0180ff04ffff0cff15ff80ff0980ffff04ffff0cff15ff0980ff808080ffff04ffff04ff05ff1380ffff04ff2bff808080ffff02ff16ffff04ff02ffff04ff09ffff04ffff02ff3effff04ff02ffff04ff15ff80808080ff8080808080ff02ffff03ffff09ffff0cff05ff80ffff010180ff1080ffff01ff02ff2effff04ff02ffff04ffff02ff3effff04ff02ffff04ffff0cff05ffff010180ff80808080ff80808080ffff01ff02ff12ffff04ff02ffff04ffff0cff05ffff010180ffff04ffff0cff05ff80ffff010180ff808080808080ff0180ff018080

chia/consensus/puzzles/rom_bootstrap_generator.clsp

@@ -0,0 +1,37 @@
+(mod (block_decompresser_program (historical_blocks_tree))
+
+  (defconstant local_deserialize_mod
+    ;; this monstrosity is the assembly output of `chialisp_deserialisation.clsp`
+    ;; it's pasted in here because the compiler doesn't yet support nested `mod`
+    ;; my apologies -- RK
+
+    (a (q 5 (a 62 (c 2 (c 5 ()))))
+      (c (q ((-1 . 127) -33 . -65) ((a (i (= 11 (q . -128)) (q 4 () (c 5 ())) (q 2 (i (>s 11 24) (q 2 26 (c 2 (c (a (i (>s 11 28) (q 2 (i (>s 11 20) (q 8) (q 4 (concat (logand (q . 31) 11) (substr 5 () (q . 1))) (c (substr 5 (q . 1)) ()))) 1) (q 4 (logand (q . 63) 11) (c 5 ()))) 1) ()))) (q 4 11 (c 5 ()))) 1)) 1) 4 (substr 21 () 9) (c (substr 21 9) ())) (c (c 5 19) (c 43 ())) (a 22 (c 2 (c 9 (c (a 62 (c 2 (c 21 ()))) ())))) 2 (i (= (substr 5 () (q . 1)) 16) (q 2 46 (c 2 (c (a 62 (c 2 (c (substr 5 (q . 1)) ()))) ()))) (q 2 18 (c 2 (c (substr 5 (q . 1)) (c (substr 5 () (q . 1)) ()))))) 1)
+    1))
+  )
+
+  (defun sha256tree
+    (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree (f TREE)) (sha256tree (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (defun process_coin_spend ((parent puzzle amount solution . spend_level_extras))
+    (c parent (c (sha256tree puzzle) (c amount (c (a puzzle solution) spend_level_extras))))
+  )
+
+  (defun recurse (coin_spends)
+    (if coin_spends
+        (c (process_coin_spend (f coin_spends)) (recurse (r coin_spends)))
+        0
+    )
+  )
+
+  (defun process-decompressor ((coin_spends . block-level-extras))
+    (c (recurse coin_spends) block-level-extras)
+  )
+
+(process-decompressor (a block_decompresser_program (list local_deserialize_mod historical_blocks_tree))))
+)

chia/consensus/puzzles/rom_bootstrap_generator.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff0cffff04ff02ffff04ffff02ff05ffff04ff08ffff04ff13ff80808080ff80808080ffff04ffff01ffffff02ffff01ff05ffff02ff3effff04ff02ffff04ff05ff8080808080ffff04ffff01ffffff81ff7fff81df81bfffffff02ffff03ffff09ff0bffff01818080ffff01ff04ff80ffff04ff05ff808080ffff01ff02ffff03ffff0aff0bff1880ffff01ff02ff1affff04ff02ffff04ffff02ffff03ffff0aff0bff1c80ffff01ff02ffff03ffff0aff0bff1480ffff01ff0880ffff01ff04ffff0effff18ffff011fff0b80ffff0cff05ff80ffff01018080ffff04ffff0cff05ffff010180ff80808080ff0180ffff01ff04ffff18ffff013fff0b80ffff04ff05ff80808080ff0180ff80808080ffff01ff04ff0bffff04ff05ff80808080ff018080ff0180ff04ffff0cff15ff80ff0980ffff04ffff0cff15ff0980ff808080ffff04ffff04ff05ff1380ffff04ff2bff808080ffff02ff16ffff04ff02ffff04ff09ffff04ffff02ff3effff04ff02ffff04ff15ff80808080ff8080808080ff02ffff03ffff09ffff0cff05ff80ffff010180ff1080ffff01ff02ff2effff04ff02ffff04ffff02ff3effff04ff02ffff04ffff0cff05ffff010180ff80808080ff80808080ffff01ff02ff12ffff04ff02ffff04ffff0cff05ffff010180ffff04ffff0cff05ff80ffff010180ff808080808080ff0180ff018080ff04ffff02ff16ffff04ff02ffff04ff09ff80808080ff0d80ffff04ff09ffff04ffff02ff1effff04ff02ffff04ff15ff80808080ffff04ff2dffff04ffff02ff15ff5d80ff7d80808080ffff02ffff03ff05ffff01ff04ffff02ff0affff04ff02ffff04ff09ff80808080ffff02ff16ffff04ff02ffff04ff0dff8080808080ff8080ff0180ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff1effff04ff02ffff04ff09ff80808080ffff02ff1effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080