chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/fee_estimation/test_mempoolitem_height_added.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import logging
+from typing import Callable, Optional
+
+import pytest
+from chia_rs import Coin, G2Element
+
+from chia._tests.util.spend_sim import SimClient, SpendSim, sim_and_client
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.full_node.bitcoin_fee_estimator import BitcoinFeeEstimator
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import make_spend
+from chia.types.spend_bundle import SpendBundle
+from chia.util.ints import uint8, uint64
+
+log = logging.getLogger(__name__)
+
+the_puzzle_hash = bytes32(
+    bytes.fromhex("9dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2")
+)  # Program.to(1)
+
+NEW_DEFAULT_CONSTANTS: ConsensusConstants = DEFAULT_CONSTANTS.replace(
+    MAX_BLOCK_COST_CLVM=uint64(300000000),
+    MEMPOOL_BLOCK_BUFFER=uint8(1),
+)
+
+
+async def farm(
+    sim: SpendSim,
+    puzzle_hash: bytes32,
+    item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
+) -> tuple[list[Coin], list[Coin], list[Coin]]:
+    additions, removals = await sim.farm_block(puzzle_hash)  # , item_inclusion_filter)
+    height = sim.get_height()
+    new_reward_coins = sim.block_records[height].reward_claims_incorporated
+    return additions, removals, new_reward_coins
+
+
+def make_tx_sb(from_coin: Coin) -> SpendBundle:
+    coin_spend = make_spend(
+        from_coin,
+        Program.to(1),
+        Program.to([[51, from_coin.puzzle_hash, from_coin.amount]]),
+    )
+    spend_bundle = SpendBundle([coin_spend], G2Element())
+    return spend_bundle
+
+
+async def init_test(
+    sim: SpendSim, cli: SimClient, puzzle_hash: bytes32, spends_per_block: int
+) -> tuple[BitcoinFeeEstimator, list[Coin], list[Coin]]:
+    new_reward_coins = []
+    spend_coins = []
+    fee_coins = []
+    await farm(sim, puzzle_hash)
+
+    for i in range(1, spends_per_block + 1):
+        await farm(sim, puzzle_hash)
+        new_reward_coins.extend(sim.block_records[i].reward_claims_incorporated)
+        fee_coins.append(sim.block_records[i].reward_claims_incorporated[0])
+        spend_coins.append(sim.block_records[i].reward_claims_incorporated[1])
+    await farm(sim, puzzle_hash)
+
+    assert len(sim.blocks) == spends_per_block + 2
+    assert sim.blocks[-1].height == spends_per_block + 1
+    assert sim.block_records[0].reward_claims_incorporated[0].amount == 18375000000000000000
+    assert sim.block_records[0].reward_claims_incorporated[1].amount == 2625000000000000000
+
+    assert sim.block_records[1].reward_claims_incorporated[0].amount == 1750000000000
+    assert sim.block_records[1].reward_claims_incorporated[1].amount == 250000000000
+
+    estimator: BitcoinFeeEstimator = sim.mempool_manager.mempool.fee_estimator  # type:ignore
+    return estimator, spend_coins, fee_coins  # new_reward_coins
+
+
+@pytest.mark.anyio
+async def test_mempool_inclusion_filter_basic() -> None:
+    async with sim_and_client(defaults=NEW_DEFAULT_CONSTANTS, pass_prefarm=False) as (sim, cli):
+        _estimator, spend_coins, _fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
+        assert sim.mempool_manager.mempool.size() == 0
+
+        spend_bundle: SpendBundle = make_tx_sb(spend_coins[0])
+        _status, error = await cli.push_tx(spend_bundle)
+        assert sim.mempool_manager.mempool.size() == 1
+        assert error is None
+
+        mempool_item = sim.mempool_manager.get_mempool_item(spend_bundle.name())
+        assert mempool_item
+
+        def include_none(bundle_name: bytes32) -> bool:
+            return False
+
+        def include_all(bundle_name: bytes32) -> bool:
+            return True
+
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_none)
+        assert sim.mempool_manager.mempool.size() == 1
+        assert removals == []
+
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=include_all)
+        assert sim.mempool_manager.mempool.size() == 0
+        removal_ids = [c.name() for c in removals]
+        assert mempool_item.name not in removal_ids
+
+
+@pytest.mark.anyio
+async def test_mempoolitem_height_added(db_version: int) -> None:
+    async with sim_and_client(defaults=NEW_DEFAULT_CONSTANTS, pass_prefarm=False) as (sim, cli):
+        _estimator, spend_coins, _fee_coins = await init_test(sim, cli, the_puzzle_hash, 1)
+        assert sim.mempool_manager.mempool.size() == 0
+
+        spend_bundle: SpendBundle = make_tx_sb(spend_coins[0])
+
+        status, error = await cli.push_tx(spend_bundle)
+        assert sim.mempool_manager.mempool.size() == 1
+        log.warning(f"{status, error} = cli.push_tx({spend_bundle.name()})")
+
+        mempool_item = sim.mempool_manager.get_mempool_item(spend_bundle.name())
+        assert mempool_item
+        heights = {sim.get_height(): mempool_item.height_added_to_mempool}
+
+        def ignore_spend(bundle_name: bytes32) -> bool:
+            assert mempool_item
+            return bundle_name != mempool_item.name
+
+        _additions, removals = await sim.farm_block(the_puzzle_hash, item_inclusion_filter=ignore_spend)
+        removal_ids = [c.name() for c in removals]
+        assert mempool_item.name not in removal_ids
+
+        mempool_item2 = sim.mempool_manager.get_mempool_item(spend_bundle.name())
+        assert sim.mempool_manager.mempool.size() == 1
+        assert mempool_item2
+
+        # This is the important check in this test: ensure height_added_to_mempool does not
+        # change when the mempool is rebuilt
+        assert mempool_item2.height_added_to_mempool == mempool_item2.height_added_to_mempool
+
+        # Now farm it into the next block
+        _additions, removals = await sim.farm_block(the_puzzle_hash)
+        assert sim.mempool_manager.mempool.size() == 0
+        assert len(removals) == 1
+
+        log.warning(heights)

chia/_tests/generator/puzzles/test_generator_deserialize.clsp

@@ -0,0 +1,3 @@
+(mod (deserializer generator_list reserved_arg)
+  (a deserializer (list reserved_arg))
+)

chia/_tests/generator/puzzles/test_generator_deserialize.clsp.hex

@@ -0,0 +1 @@
+ff02ff02ffff04ff0bff808080

chia/_tests/generator/puzzles/test_multiple_generator_input_arguments.clsp

@@ -0,0 +1,19 @@
+
+(mod (decompress_puzzle decompress_coin_spend_entry start1 end1 start2 end2 compressed_cses deserialize gen_list reserved_arg)
+
+  (defun decompress_cses (decompress_puzzle decompress_coin_spend_entry cses deserialize puzzle_prefix)
+    (if cses
+        (c (a decompress_coin_spend_entry (list deserialize decompress_puzzle puzzle_prefix (f cses)))
+        (decompress_cses decompress_puzzle decompress_coin_spend_entry (r cses) deserialize puzzle_prefix ))
+  ()) )
+
+  (defun join_gen_args (generators start1 end1 start2 end2)
+    (concat
+      (substr (f generators) start1 end1)
+      (substr (f (r generators)) start2 end2)
+    )
+  )
+
+  (list (decompress_cses decompress_puzzle decompress_coin_spend_entry compressed_cses deserialize (join_gen_args gen_list start1 end1 start2 end2)))
+
+)

chia/_tests/generator/puzzles/test_multiple_generator_input_arguments.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff02ff04ffff04ff02ffff04ff05ffff04ff0bffff04ff82017fffff04ff8202ffffff04ffff02ff06ffff04ff02ffff04ff8205ffffff04ff17ffff04ff2fffff04ff5fffff04ff81bfff8080808080808080ff8080808080808080ff8080ffff04ffff01ffff02ffff03ff17ffff01ff04ffff02ff0bffff04ff2fffff04ff05ffff04ff5fffff04ff27ff808080808080ffff02ff04ffff04ff02ffff04ff05ffff04ff0bffff04ff37ffff04ff2fffff04ff5fff808080808080808080ff8080ff0180ff0effff0cff09ff0bff1780ffff0cff15ff2fff5f8080ff018080

chia/_tests/generator/test_compression.py

@@ -0,0 +1,201 @@
+# ruff: noqa: E501
+from __future__ import annotations
+
+import io
+from typing import Any
+
+from chia_rs import serialized_length
+from clvm.serialize import sexp_from_stream
+from clvm.SExp import SExp
+from clvm_tools import binutils
+
+from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.spend_bundle import SpendBundle
+from chia.util.byte_types import hexstr_to_bytes
+from chia.util.ints import uint32
+from chia.wallet.puzzles.load_clvm import load_clvm
+
+TEST_GEN_DESERIALIZE = load_clvm(
+    "test_generator_deserialize.clsp", package_or_requirement="chia._tests.generator.puzzles"
+)
+DESERIALIZE_MOD = load_clvm("chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles")
+
+DECOMPRESS_PUZZLE = load_clvm("decompress_puzzle.clsp", package_or_requirement="chia.full_node.puzzles")
+DECOMPRESS_CSE = load_clvm("decompress_coin_spend_entry.clsp", package_or_requirement="chia.full_node.puzzles")
+
+DECOMPRESS_CSE_WITH_PREFIX = load_clvm(
+    "decompress_coin_spend_entry_with_prefix.clsp", package_or_requirement="chia.full_node.puzzles"
+)
+DECOMPRESS_BLOCK = load_clvm("block_program_zero.clsp", package_or_requirement="chia.full_node.puzzles")
+TEST_MULTIPLE = load_clvm(
+    "test_multiple_generator_input_arguments.clsp", package_or_requirement="chia._tests.generator.puzzles"
+)
+
+Nil = Program.from_bytes(b"\x80")
+
+original_generator = hexstr_to_bytes(
+    "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
+)
+
+gen1 = b"\xff\x01" + original_generator
+gen2 = b"\xff\x01\xff\x01" + original_generator
+FAKE_BLOCK_HEIGHT1 = uint32(100)
+FAKE_BLOCK_HEIGHT2 = uint32(200)
+
+assert serialized_length(original_generator) == len(original_generator)
+assert serialized_length(gen1) == len(gen1)
+assert serialized_length(gen2) == len(gen2)
+
+
+def spend_bundle_to_coin_spend_entry_list(bundle: SpendBundle) -> list[Any]:
+    r = []
+    for coin_spend in bundle.coin_spends:
+        entry = [
+            coin_spend.coin.parent_coin_info,
+            sexp_from_stream(io.BytesIO(bytes(coin_spend.puzzle_reveal)), SExp.to),
+            coin_spend.coin.amount,
+            sexp_from_stream(io.BytesIO(bytes(coin_spend.solution)), SExp.to),
+        ]
+        r.append(entry)
+    return r
+
+
+class TestCompression:
+    def test_compress_spend_bundle(self) -> None:
+        pass
+
+
+class TestDecompression:
+    def test_deserialization(self) -> None:
+        _cost, out = DESERIALIZE_MOD.run_with_cost(INFINITE_COST, [bytes(Program.to("hello"))])
+        assert out == Program.to("hello")
+
+    def test_deserialization_as_argument(self) -> None:
+        _cost, out = TEST_GEN_DESERIALIZE.run_with_cost(
+            INFINITE_COST, [DESERIALIZE_MOD, Nil, bytes(Program.to("hello"))]
+        )
+        print(bytes(Program.to("hello")))
+        print()
+        print(out)
+        assert out == Program.to("hello")
+
+    def test_decompress_puzzle(self) -> None:
+        _cost, out = DECOMPRESS_PUZZLE.run_with_cost(
+            INFINITE_COST, [DESERIALIZE_MOD, b"\xff", bytes(Program.to("pubkey")), b"\x80"]
+        )
+
+        print()
+        print(out)
+
+    # An empty CSE is invalid. (An empty CSE list may be okay)
+    # def test_decompress_empty_cse(self):
+    #    cse0 = binutils.assemble("()")
+    #    cost, out = DECOMPRESS_CSE.run_with_cost(INFINITE_COST, [DESERIALIZE_MOD, DECOMPRESS_PUZZLE, b"\xff", b"\x80", cse0])
+    #    print()
+    #    print(out)
+
+    def test_decompress_cse(self) -> None:
+        """Decompress a single CSE / CoinSpendEntry"""
+        cse0 = binutils.assemble(
+            "((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ())))"
+        )
+        _cost, out = DECOMPRESS_CSE.run_with_cost(
+            INFINITE_COST, [DESERIALIZE_MOD, DECOMPRESS_PUZZLE, b"\xff", b"\x80", cse0]
+        )
+
+        print()
+        print(out)
+
+    def test_decompress_cse_with_prefix(self) -> None:
+        cse0 = binutils.assemble(
+            "((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0) (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3 (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ())))"
+        )
+
+        start = 2 + 44
+        end = start + 238
+        prefix = original_generator[start:end]
+        # (deserialize decompress_puzzle puzzle_prefix cse)
+        _cost, out = DECOMPRESS_CSE_WITH_PREFIX.run_with_cost(
+            INFINITE_COST, [DESERIALIZE_MOD, DECOMPRESS_PUZZLE, prefix, cse0]
+        )
+
+        print()
+        print(out)
+
+    def test_block_program_zero(self) -> None:
+        "Decompress a list of CSEs"
+        cse2 = binutils.assemble(
+            """
+(
+  ((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0)
+   (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3
+    (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))
+  )
+
+  ((0x0000000000000000000000000000000000000000000000000000000000000001 0x0186a0)
+   (0xb0a6207f5173ec41491d9f2c1b8fff5579e13703077e0eaca8fe587669dcccf51e9209a6b65576845ece5f7c2f3229e7e3
+   (() (q (51 0x24254a3efc3ebfac9979bbe0d615e2eda043aa329905f65b63846fa24149e2b6 0x0186a0)) ())))
+
+)
+        """
+        )
+
+        start = 2 + 44
+        end = start + 238
+
+        # (mod (decompress_puzzle decompress_coin_spend_entry start end compressed_cses deserialize generator_list reserved_arg)
+        # cost, out = DECOMPRESS_BLOCK.run_with_cost(INFINITE_COST, [DECOMPRESS_PUZZLE, DECOMPRESS_CSE, start, Program.to(end), cse0, DESERIALIZE_MOD, bytes(original_generator)])
+        _cost, out = DECOMPRESS_BLOCK.run_with_cost(
+            INFINITE_COST,
+            [
+                DECOMPRESS_PUZZLE,
+                DECOMPRESS_CSE_WITH_PREFIX,
+                start,
+                Program.to(end),
+                cse2,
+                DESERIALIZE_MOD,
+                [bytes(original_generator)],
+            ],
+        )
+
+        print()
+        print(out)
+
+    def test_block_program_zero_with_curry(self) -> None:
+        cse2 = binutils.assemble(
+            """
+(
+  ((0x0000000000000000000000000000000000000000000000000000000000000000 0x0186a0)
+   (0xb081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3
+    (() (q (51 0x6b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9 0x0186a0)) ()))
+  )
+
+  ((0x0000000000000000000000000000000000000000000000000000000000000001 0x0186a0)
+   (0xb0a6207f5173ec41491d9f2c1b8fff5579e13703077e0eaca8fe587669dcccf51e9209a6b65576845ece5f7c2f3229e7e3
+   (() (q (51 0x24254a3efc3ebfac9979bbe0d615e2eda043aa329905f65b63846fa24149e2b6 0x0186a0)) ())))
+
+)
+        """
+        )
+
+        start = 2 + 44
+        end = start + 238
+
+        # (mod (decompress_puzzle decompress_coin_spend_entry start end compressed_cses deserialize generator_list reserved_arg)
+        # cost, out = DECOMPRESS_BLOCK.run_with_cost(INFINITE_COST, [DECOMPRESS_PUZZLE, DECOMPRESS_CSE, start, Program.to(end), cse0, DESERIALIZE_MOD, bytes(original_generator)])
+        p = DECOMPRESS_BLOCK.curry(DECOMPRESS_PUZZLE, DECOMPRESS_CSE_WITH_PREFIX, start, Program.to(end))
+        _cost, out = p.run_with_cost(INFINITE_COST, [cse2, DESERIALIZE_MOD, [bytes(original_generator)]])
+
+        print()
+        print(p)
+        print(out)
+
+        p_with_cses = DECOMPRESS_BLOCK.curry(
+            DECOMPRESS_PUZZLE, DECOMPRESS_CSE_WITH_PREFIX, start, Program.to(end), cse2, DESERIALIZE_MOD
+        )
+        generator_args = Program.to([[original_generator]])
+        _cost, out = p_with_cses.run_with_cost(INFINITE_COST, generator_args)
+
+        print()
+        print(p_with_cses)
+        print(out)

chia/_tests/generator/test_generator_types.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from unittest import TestCase
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+
+gen0 = SerializedProgram.from_bytes(
+    bytes.fromhex(
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
+    )
+)
+
+gen1 = SerializedProgram.from_bytes(
+    bytes.fromhex(
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
+    )
+)
+
+gen2 = SerializedProgram.from_bytes(
+    bytes.fromhex(
+        "ff01ffffffa00000000000000000000000000000000000000000000000000000000000000000ff830186a080ffffff02ffff01ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080ffff04ffff01b081963921826355dcb6c355ccf9c2637c18adf7d38ee44d803ea9ca41587e48c913d8d46896eb830aeadfc13144a8eac3ff018080ffff80ffff01ffff33ffa06b7a83babea1eec790c947db4464ab657dbe9b887fe9acc247062847b8c2a8a9ff830186a08080ff8080808080"
+    )
+)
+
+
+class TestGeneratorTypes(TestCase):
+    def test_make_generator_args(self) -> None:
+        gen_args = Program.to([[bytes(gen1)]])
+
+        # First Argument to the block generator is the first template generator
+        arg2 = gen_args.first().first()
+        print(arg2)
+        assert arg2 == bytes(gen1)
+
+    # It's not a list anymore.
+    # TODO: Test the first three arg positions passed through here.
+    # def test_generator_arg_is_list(self):
+    #    generator_ref_list = [Program.to(b"gen1"), Program.to(b"gen2")]
+    #    gen_args = create_generator_args(generator_ref_list)
+    #    gen_args_as_program = Program.from_bytes(bytes(gen_args))
+    #    arg2 = gen_args_as_program.rest().first()
+    #    assert arg2 == binutils.assemble("('gen1' 'gen2')")
+    #    print(arg2)

chia/_tests/generator/test_rom.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from clvm.CLVMObject import CLVMStorage
+from clvm_tools import binutils
+from clvm_tools.clvmc import compile_clvm_text
+
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
+from chia.consensus.condition_costs import ConditionCost
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+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.generator_types import BlockGenerator
+from chia.types.spend_bundle_conditions import SpendConditions
+from chia.util.ints import uint32
+from chia.wallet.puzzles.load_clvm import load_clvm, load_serialized_clvm_maybe_recompile
+
+MAX_COST = 10**15
+COST_PER_BYTE = 12000
+
+
+DESERIALIZE_MOD = load_clvm("chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles")
+GENERATOR_MOD: SerializedProgram = load_serialized_clvm_maybe_recompile(
+    "rom_bootstrap_generator.clsp", package_or_requirement="chia.consensus.puzzles"
+)
+
+
+GENERATOR_CODE = """
+(mod (deserialize-mod historical-generators)
+    (defun first-block (deserialize-mod historical-generators)
+                       (a deserialize-mod (list (f historical-generators))))
+
+    (defun second-block (deserialize-mod historical-generators)
+                        (a deserialize-mod (r historical-generators)))
+
+    (defun go (deserialize-mod historical-generators)
+    (c (first-block deserialize-mod historical-generators)
+       (second-block deserialize-mod historical-generators)
+    ))
+    (go deserialize-mod historical-generators)
+)
+"""
+
+
+COMPILED_GENERATOR_CODE = bytes(Program.to(compile_clvm_text(GENERATOR_CODE, [])))  # type: ignore[no-untyped-call]
+
+FIRST_GENERATOR = Program.to(
+    binutils.assemble(
+        """
+        ((0x0000000000000000000000000000000000000000000000000000000000000000 1 50000
+        ((51 0x0000000000000000000000000000000000000000000000000000000000000001 500))
+        "extra" "data" "for" "coin" ))"""
+    )
+).as_bin()
+
+SECOND_GENERATOR = Program.to(binutils.assemble("(extra data for block)")).as_bin()
+
+
+def to_sp(sexp: bytes) -> SerializedProgram:
+    return SerializedProgram.from_bytes(sexp)
+
+
+def block_generator() -> BlockGenerator:
+    generator_list = [FIRST_GENERATOR, SECOND_GENERATOR]
+    return BlockGenerator(to_sp(COMPILED_GENERATOR_CODE), generator_list)
+
+
+EXPECTED_ABBREVIATED_COST = 108379
+EXPECTED_COST1 = 113415
+EXPECTED_COST2 = 108423
+EXPECTED_OUTPUT = (
+    "ffffffa00000000000000000000000000000000000000000000000000000000000000000"
+    "ff01ff8300c350ffffff33ffa00000000000000000000000000000000000000000000000"
+    "000000000000000001ff8201f48080ff856578747261ff8464617461ff83666f72ff8463"
+    "6f696e8080ff856578747261ff8464617461ff83666f72ff85626c6f636b80"
+)
+
+
+def run_generator(self: BlockGenerator) -> tuple[int, Program]:
+    """This mode is meant for accepting possibly soft-forked transactions into the mempool"""
+    args = Program.to([self.generator_refs])
+    return GENERATOR_MOD.run_with_cost(MAX_COST, [self.program, args])
+
+
+def as_atom_list(prg: CLVMStorage) -> list[bytes]:
+    """
+    Pretend `prg` is a list of atoms. Return the corresponding
+    python list of atoms.
+
+    At each step, we always assume a node to be an atom or a pair.
+    If the assumption is wrong, we exit early. This way we never fail
+    and always return SOMETHING.
+    """
+    items = []
+    obj = prg
+    while True:
+        pair = obj.pair
+        if pair is None:
+            break
+        atom = pair[0].atom
+        if atom is None:
+            break
+        items.append(atom)
+        obj = pair[1]
+    return items
+
+
+class TestROM:
+    def test_rom_inputs(self) -> None:
+        # this test checks that the generator just works
+        # It's useful for debugging the generator prior to having the ROM invoke it.
+
+        args = Program.to([DESERIALIZE_MOD, [FIRST_GENERATOR, SECOND_GENERATOR]])
+        sp = to_sp(COMPILED_GENERATOR_CODE)
+        cost, r = sp.run_with_cost(MAX_COST, args)
+        assert cost == EXPECTED_ABBREVIATED_COST
+        assert r.as_bin().hex() == EXPECTED_OUTPUT
+
+    def test_get_name_puzzle_conditions(self, softfork_height: int) -> None:
+        # this tests that extra block or coin data doesn't confuse `get_name_puzzle_conditions`
+
+        gen = block_generator()
+        cost, r = run_generator(gen)
+        print(r)
+
+        npc_result = get_name_puzzle_conditions(
+            gen, max_cost=MAX_COST, mempool_mode=False, height=uint32(softfork_height), constants=DEFAULT_CONSTANTS
+        )
+        if softfork_height >= DEFAULT_CONSTANTS.HARD_FORK_HEIGHT:
+            cost = EXPECTED_COST2
+        else:
+            cost = EXPECTED_COST1
+        assert npc_result.error is None
+        assert npc_result.conds is not None
+        assert npc_result.conds.cost == cost + ConditionCost.CREATE_COIN.value + (
+            len(bytes(gen.program)) * COST_PER_BYTE
+        )
+        assert npc_result.conds is not None
+
+        spend = SpendConditions(
+            coin_id=bytes32.fromhex("e8538c2d14f2a7defae65c5c97f5d4fae7ee64acef7fec9d28ad847a0880fd03"),
+            parent_id=bytes32.fromhex("0000000000000000000000000000000000000000000000000000000000000000"),
+            puzzle_hash=bytes32.fromhex("9dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2"),
+            coin_amount=50000,
+            height_relative=None,
+            seconds_relative=None,
+            before_height_relative=None,
+            before_seconds_relative=None,
+            birth_height=None,
+            birth_seconds=None,
+            create_coin=[(bytes([0] * 31 + [1]), 500, None)],
+            agg_sig_me=[],
+            agg_sig_parent=[],
+            agg_sig_puzzle=[],
+            agg_sig_amount=[],
+            agg_sig_puzzle_amount=[],
+            agg_sig_parent_amount=[],
+            agg_sig_parent_puzzle=[],
+            flags=0,
+        )
+
+        assert npc_result.conds.spends == [spend]
+
+    def test_coin_extras(self) -> None:
+        # the ROM supports extra data after a coin. This test checks that it actually gets passed through
+
+        gen = block_generator()
+        _cost, r = run_generator(gen)
+        coin_spends = r.first()
+        for coin_spend in coin_spends.as_iter():
+            extra_data = coin_spend.rest().rest().rest().rest()
+            assert as_atom_list(extra_data) == b"extra data for coin".split()
+
+    def test_block_extras(self) -> None:
+        # the ROM supports extra data after the coin spend list. This test checks that it actually gets passed through
+
+        gen = block_generator()
+        _cost, r = run_generator(gen)
+        extra_block_data = r.rest()
+        assert as_atom_list(extra_block_data) == b"extra data for block".split()

chia/_tests/plot_sync/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+checkout_blocks_and_plots = True