New RPC block_spends - Get spends for block using transaction generator

chia/rpc/full_node_rpc_api.py

@@ -1,9 +1,13 @@
 from typing import Any, Dict, List, Optional
 
+from clvm.casts import int_from_bytes
+
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR
 from chia.full_node.full_node import FullNode
+from chia.full_node.generator import create_generator_args
 from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
+from chia.types.blockchain_format.coin import Coin
 from chia.rpc.rpc_server import Endpoint
 from chia.types.blockchain_format.program import Program, SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -41,6 +45,7 @@ def get_routes(self) -> Dict[str, Endpoint]:
             "/get_block_record_by_height": self.get_block_record_by_height,
             "/get_block_record": self.get_block_record,
             "/get_block_records": self.get_block_records,
+            "/get_block_spends": self.get_block_spends,
             "/get_unfinished_block_headers": self.get_unfinished_block_headers,
             "/get_network_space": self.get_network_space,
             "/get_additions_and_removals": self.get_additions_and_removals,
@@ -399,6 +404,32 @@ async def get_block_records(self, request: Dict) -> Dict[str, object]:
             records.append(record)
         return {"block_records": records}
 
+    async def get_block_spends(self, request: Dict) -> Optional[Dict]:
+        if "header_hash" not in request:
+            raise ValueError("No header_hash in request")
+        header_hash = bytes32.from_hexstr(request["header_hash"])
+        full_block: Optional[FullBlock] = await self.service.block_store.get_full_block(header_hash)
+        if full_block is None or full_block.transactions_generator is None:
+            raise ValueError(f"Block {header_hash.hex()} not found or invalid block generator")
+
+        spends: List[CoinSpend] = []
+        block_generator = await self.service.blockchain.get_block_generator(full_block)
+        if block_generator is None:
+            return {"block_spends": spends}
+
+        args = create_generator_args(block_generator.generator_refs).first()
+        _, block_result = block_generator.program.run_with_cost(self.service.constants.MAX_BLOCK_COST_CLVM, 0, args)
+
+        coin_spends = block_result.first()
+
+        for spend in coin_spends.as_iter():
+            parent, puzzle, amount, solution = spend.as_iter()
+            puzzle_hash = puzzle.get_tree_hash()
+            coin = Coin(parent.atom, puzzle_hash, int_from_bytes(amount.atom))
+            spends.append(CoinSpend(coin, puzzle, solution))
+
+        return {"block_spends": spends}
+
     async def get_block_record_by_height(self, request: Dict) -> Dict[str, object]:
         if "height" not in request:
             raise ValueError("No height in request")

chia/rpc/full_node_rpc_client.py

@@ -200,6 +200,16 @@ async def get_block_records(self, start: int, end: int) -> List:
         # TODO: return block records
         return response["block_records"]
 
+    async def get_block_spends(self, header_hash: bytes32) -> Optional[List[CoinSpend]]:
+        try:
+            response = await self.fetch("get_block_spends", {"header_hash": header_hash.hex()})
+            block_spends = []
+            for block_spend in response["block_spends"]:
+                block_spends.append(CoinSpend.from_json_dict(block_spend))
+            return block_spends
+        except Exception:
+            return None
+
     async def push_tx(self, spend_bundle: SpendBundle):
         return await self.fetch("push_tx", {"spend_bundle": spend_bundle.to_json_dict()})
 

tests/core/test_full_node_rpc.py

@@ -186,6 +186,31 @@ def stop_node_cb():
             assert len(await client.get_coin_records_by_puzzle_hash(ph, True, 0, blocks[-1].height + 1)) == 2
             assert len(await client.get_coin_records_by_puzzle_hash(ph, True, 0, 1)) == 0
 
+            coin_records = await client.get_coin_records_by_puzzle_hash(ph, False)
+
+            coin_spends = []
+
+            # Spend 3 coins using standard transaction
+            for i in range(3):
+                spend_bundle = wallet.generate_signed_transaction(
+                    coin_records[i].coin.amount, ph_receiver, coin_records[i].coin
+                )
+                await client.push_tx(spend_bundle)
+                coin_spends = coin_spends + spend_bundle.coin_spends
+                await time_out_assert(
+                    5, full_node_api_1.full_node.mempool_manager.get_spendbundle, spend_bundle, spend_bundle.name()
+                )
+
+            await full_node_api_1.farm_new_transaction_block(FarmNewBlockProtocol(ph_2))
+            block: FullBlock = (await full_node_api_1.get_all_full_blocks())[-1]
+
+            assert len(block.transactions_generator_ref_list) > 0  # compression has occurred
+
+            block_spends = await client.get_block_spends(block.header_hash)
+
+            assert len(block_spends) == 3
+            assert block_spends == coin_spends
+
             memo = 32 * b"\f"
 
             for i in range(2):