[CHIA-3805] reduce use of pool_reward_puzzle_hash feature of BlockTools (#20277)

* reduce use of pool_reward_puzzle_hash feature of BlockTools, since it's not supported by v2 plots

* the BlockTools feature to ask for a specific pool puzzle hash are not supported by v2 proofs. v2 plots only have pool contract puzzle hash

Author: arvidn

chia/_tests/blockchain/test_blockchain.py

@@ -812,7 +812,6 @@ async def one_node_one_block(
             1,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             genesis_timestamp=uint64(10000),
             time_per_block=10,
         )
@@ -841,7 +840,6 @@ async def two_nodes_one_block(blockchain_constants: ConsensusConstants):
             1,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             genesis_timestamp=uint64(10000),
             time_per_block=10,
         )

chia/_tests/conftest.py

@@ -16,6 +16,7 @@
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia._tests.core.full_node.test_full_node import find_reward_coin
 from chia._tests.util.db_connection import DBConnection, PathDBConnection
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_height_map import BlockHeightMap
@@ -57,11 +58,11 @@ async def test_block_store(tmp_dir: Path, db_version: int, bt: BlockTools, use_c
         3,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=bt.pool_ph,
-        pool_reward_puzzle_hash=bt.pool_ph,
         time_per_block=10,
     )
     wt: WalletTool = bt.get_pool_wallet_tool()
-    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0])
+    coin = find_reward_coin(blocks[-1], bt.pool_ph)
+    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
     blocks = bt.get_consecutive_blocks(
         10,
         block_list_input=blocks,

chia/_tests/core/full_node/stores/test_block_store.py

@@ -67,7 +67,6 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
         10,
         [],
         farmer_reward_puzzle_hash=reward_ph,
-        pool_reward_puzzle_hash=reward_ph,
     )
 
     coins_to_spend: list[Coin] = []
@@ -86,7 +85,6 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
             10,
             blocks,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             transaction_data=spend_bundle,
         )
 
@@ -374,11 +372,9 @@ async def test_get_puzzle_hash(tmp_dir: Path, db_version: int, bt: BlockTools) -
     async with DBConnection(db_version) as db_wrapper:
         num_blocks = 20
         farmer_ph = bytes32(32 * b"0")
-        pool_ph = bytes32(32 * b"1")
         blocks = bt.get_consecutive_blocks(
             num_blocks,
             farmer_reward_puzzle_hash=farmer_ph,
-            pool_reward_puzzle_hash=pool_ph,
             guarantee_transaction_block=True,
         )
         coin_store = await CoinStore.create(db_wrapper)
@@ -391,7 +387,7 @@ async def test_get_puzzle_hash(tmp_dir: Path, db_version: int, bt: BlockTools) -
         assert peak is not None
         assert peak.height == num_blocks - 1
 
-        coins_farmer = await coin_store.get_coin_records_by_puzzle_hash(True, pool_ph)
+        coins_farmer = await coin_store.get_coin_records_by_puzzle_hash(True, bt.pool_ph)
         coins_pool = await coin_store.get_coin_records_by_puzzle_hash(True, farmer_ph)
 
         assert len(coins_farmer) == num_blocks - 2

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -6,6 +6,7 @@
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
+from chia._tests.core.full_node.test_full_node import find_reward_coin
 from chia._tests.util.db_connection import DBConnection
 from chia.full_node.hint_store import HintStore
 from chia.server.server import ChiaServer
@@ -151,7 +152,6 @@ async def test_hints_in_blockchain(
         block_list_input=[],
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=bt.pool_ph,
-        pool_reward_puzzle_hash=bt.pool_ph,
     )
     for block in blocks:
         await full_node_1.full_node.add_block(block, None)
@@ -160,7 +160,7 @@ async def test_hints_in_blockchain(
     puzzle_hash = bytes32(32 * b"\0")
     amount = int_to_bytes(1)
     hint = bytes32(32 * b"\5")
-    coin_spent = blocks[-1].get_included_reward_coins()[0]
+    coin_spent = find_reward_coin(blocks[-1], bt.pool_ph)
     condition_dict = {
         ConditionOpcode.CREATE_COIN: [ConditionWithArgs(ConditionOpcode.CREATE_COIN, [puzzle_hash, amount, hint])]
     }

chia/_tests/core/full_node/stores/test_hint_store.py

@@ -12,6 +12,7 @@
 import pytest
 from chia_rs import (
     AugSchemeMPL,
+    Coin,
     ConsensusConstants,
     Foliage,
     FoliageTransactionBlock,
@@ -111,6 +112,13 @@
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
+def find_reward_coin(b: FullBlock, puzzle_hash: bytes32) -> Coin:
+    for c in b.get_included_reward_coins():
+        if c.puzzle_hash == puzzle_hash:
+            return c
+    raise ValueError("no reward coin with the specified puzzle hash found")
+
+
 def test_pre_validation_result() -> None:
     conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
@@ -812,11 +820,10 @@ async def test_respond_unfinished(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=ph,
-        pool_reward_puzzle_hash=ph,
     )
     await full_node_1.full_node.add_block(blocks[-2])
     await full_node_1.full_node.add_block(blocks[-1])
-    coin_to_spend = blocks[-1].get_included_reward_coins()[0]
+    coin_to_spend = find_reward_coin(blocks[-1], ph)
 
     spend_bundle = wallet_a.generate_signed_transaction(coin_to_spend.amount, ph_receiver, coin_to_spend)
 
@@ -936,7 +943,6 @@ async def test_new_transaction_and_mempool(
         3,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=wallet_ph,
-        pool_reward_puzzle_hash=wallet_ph,
     )
     for block in blocks:
         await full_node_1.full_node.add_block(block)
@@ -1127,7 +1133,6 @@ async def test_request_respond_transaction(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=wallet_ph,
-        pool_reward_puzzle_hash=wallet_ph,
     )
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -1148,9 +1153,8 @@ async def test_request_respond_transaction(
 
     receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
 
-    spend_bundle = wallet_a.generate_signed_transaction(
-        uint64(100), receiver_puzzlehash, blocks[-1].get_included_reward_coins()[0]
-    )
+    coin = find_reward_coin(blocks[-1], wallet_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(100), receiver_puzzlehash, coin)
     assert spend_bundle is not None
     respond_transaction = fnp.RespondTransaction(spend_bundle)
     res = await full_node_1.respond_transaction(respond_transaction, peer)
@@ -1192,7 +1196,6 @@ async def test_respond_transaction_fail(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=cb_ph,
-        pool_reward_puzzle_hash=cb_ph,
     )
     await asyncio.sleep(1)
     while incoming_queue.qsize() > 0:
@@ -1204,11 +1207,8 @@ async def test_respond_transaction_fail(
 
     await time_out_assert(10, time_out_messages(incoming_queue, "new_peak", 3))
     # Invalid transaction does not propagate
-    spend_bundle = wallet_a.generate_signed_transaction(
-        uint64(100_000_000_000_000),
-        receiver_puzzlehash,
-        blocks_new[-1].get_included_reward_coins()[0],
-    )
+    coin = find_reward_coin(blocks_new[-1], cb_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(100_000_000_000_000), receiver_puzzlehash, coin)
 
     assert spend_bundle is not None
     respond_transaction = fnp.RespondTransaction(spend_bundle)
@@ -1228,18 +1228,15 @@ async def test_request_block(
     full_node_1, _full_node_2, _server_1, _server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
+    wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(
         3,
         block_list_input=blocks,
         guarantee_transaction_block=True,
-        farmer_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-        pool_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-    )
-    spend_bundle = wallet_a.generate_signed_transaction(
-        uint64(1123),
-        wallet_receiver.get_new_puzzlehash(),
-        blocks[-1].get_included_reward_coins()[0],
+        farmer_reward_puzzle_hash=wallet_ph,
     )
+    coin = find_reward_coin(blocks[-1], wallet_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(1123), wallet_receiver.get_new_puzzlehash(), coin)
     blocks = bt.get_consecutive_blocks(
         1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=spend_bundle
     )
@@ -1280,18 +1277,19 @@ async def test_request_blocks(
     blocks = await full_node_1.get_all_full_blocks()
 
     # create more blocks than constants.MAX_BLOCK_COUNT_PER_REQUEST (32)
+    wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(
         33,
         block_list_input=blocks,
         guarantee_transaction_block=True,
-        farmer_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-        pool_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
+        farmer_reward_puzzle_hash=wallet_ph,
     )
 
+    coin = find_reward_coin(blocks[-1], wallet_ph)
     spend_bundle = wallet_a.generate_signed_transaction(
         uint64(1123),
         wallet_receiver.get_new_puzzlehash(),
-        blocks[-1].get_included_reward_coins()[0],
+        coin,
     )
     blocks_t = bt.get_consecutive_blocks(
         1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=spend_bundle
@@ -3325,15 +3323,17 @@ async def test_pending_tx_cache_retry_on_new_peak(
         wallet = WalletTool(test_constants)
         ph = wallet.get_new_puzzlehash()
         blocks = bt.get_consecutive_blocks(
-            3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=ph, pool_reward_puzzle_hash=ph
+            3,
+            guarantee_transaction_block=True,
+            farmer_reward_puzzle_hash=ph,
         )
         for block in blocks:
             await full_node_api.full_node.add_block(block)
         peak = full_node_api.full_node.blockchain.get_peak()
         assert peak is not None
         current_height = peak.height
         # Create a transaction with a height condition that makes it pending
-        coin = blocks[-1].get_included_reward_coins()[0]
+        coin = find_reward_coin(blocks[-1], ph)
         if condition == ConditionOpcode.ASSERT_HEIGHT_RELATIVE:
             condition_height = 1
         else:
@@ -3406,13 +3406,11 @@ async def test_ban_for_mismatched_tx_cost_fee(
     else:
         node = full_node_2.full_node
         ws_con = ws_con_2
-    blocks = bt.get_consecutive_blocks(
-        3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=wallet_ph, pool_reward_puzzle_hash=wallet_ph
-    )
+    blocks = bt.get_consecutive_blocks(3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=wallet_ph)
     for block in blocks:
         await node.add_block(block)
     # Create a transaction and add it to the relevant full node's mempool
-    coin = blocks[-1].get_included_reward_coins()[0]
+    coin = find_reward_coin(blocks[-1], wallet_ph)
     sb = wallet.generate_signed_transaction(uint64(42), wallet_ph, coin)
     sb_name = sb.name()
     await node.add_transaction(sb, sb_name, ws_con)

chia/_tests/core/full_node/test_full_node.py

@@ -36,7 +36,6 @@ async def test_full_block_performance(
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=wallet_ph,
-            pool_reward_puzzle_hash=wallet_ph,
         )
         for block in blocks:
             await full_node_1.full_node.add_block(block)