chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc2__py3-none-any.whl

chia/simulator/full_node_simulator.py

@@ -7,27 +7,25 @@ from collections.abc import Collection
 from typing import Any, Optional, Union
 
 import anyio
+from chia_rs import BlockRecord, FullBlock, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_body_validation import ForkInfo
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain import BlockchainMutexPriority
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import default_get_connections
-from chia.server.outbound_message import NodeType
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, GetAllCoinsProtocol, ReorgProtocol
 from chia.types.blockchain_format.coin import Coin
 from chia.types.coin_record import CoinRecord
-from chia.types.full_block import FullBlock
-from chia.types.spend_bundle import SpendBundle
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.config import lock_and_load_config, save_config
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.conditions import CreateCoin
@@ -125,7 +123,33 @@ class FullNodeSimulator(FullNodeAPI):
             return self.auto_farm
 
     async def get_all_coins(self, request: GetAllCoinsProtocol) -> list[CoinRecord]:
-        return await self.full_node.coin_store.get_all_coins(request.include_spent_coins)
+        """
+        Simulates fetching all coins by querying coins added at each block height.
+
+        Args:
+            request: An object containing the `include_spent_coins` flag.
+
+        Returns:
+            A combined list of CoinRecords (including spent coins if requested).
+        """
+        coin_records: list[CoinRecord] = []
+        current_height = 0
+
+        # `.get_peak_height` can return `None`. We use -1 in that case to exit early
+        max_block_height = self.full_node.blockchain.get_peak_height() or -1
+
+        while current_height <= max_block_height:
+            # Fetch coins added at the current block height
+            records_at_height = await self.full_node.coin_store.get_coins_added_at_height(uint32(current_height))
+
+            if not request.include_spent_coins:
+                # Filter out spent coins if not requested
+                records_at_height = [record for record in records_at_height if not record.spent]
+
+            coin_records.extend(records_at_height)
+            current_height += 1
+
+        return coin_records
 
     async def revert_block_height(self, new_height: uint32) -> None:
         """
@@ -205,7 +229,7 @@ class FullNodeSimulator(FullNodeAPI):
                     await asyncio.sleep(1)
                 else:
                     current_time = False
-            mempool_bundle = await self.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
+            mempool_bundle = self.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
             if mempool_bundle is None:
                 spend_bundle = None
             else:
@@ -258,7 +282,7 @@ class FullNodeSimulator(FullNodeAPI):
                     await asyncio.sleep(1)
                 else:
                     current_time = False
-            mempool_bundle = await self.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
+            mempool_bundle = self.full_node.mempool_manager.create_bundle_from_mempool(curr.header_hash)
             if mempool_bundle is None:
                 spend_bundle = None
             else:
@@ -369,7 +393,8 @@ class FullNodeSimulator(FullNodeAPI):
             if count == 0:
                 return 0
 
-            target_puzzlehash = await wallet.get_new_puzzlehash()
+            async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+                target_puzzlehash = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
             rewards = 0
 
             block_reward_coins = set()
@@ -687,7 +712,10 @@ class FullNodeSimulator(FullNodeAPI):
             for amount in amounts:
                 # We need unique puzzle hash amount combos so we'll only generate a new puzzle hash when we've already
                 # seen that amount sent to that puzzle hash
-                puzzle_hash = await wallet.get_puzzle_hash(new=amount in amounts_seen)
+                async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+                    puzzle_hash = await action_scope.get_puzzle_hash(
+                        wallet.wallet_state_manager, override_reuse_puzhash_with=amount not in amounts_seen
+                    )
                 outputs.append(CreateCoin(puzzle_hash, amount))
                 amounts_seen.add(amount)
 

chia/simulator/setup_services.py

@@ -18,10 +18,20 @@ from chia_rs.sized_ints import uint16
 from chia.cmds.init_funcs import init
 from chia.consensus.constants import replace_str_to_bytes
 from chia.daemon.server import WebSocketServer, daemon_launch_lock_path
+from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import Capability, default_capabilities
 from chia.seeder.dns_server import DNSServer, create_dns_server_service
 from chia.seeder.start_crawler import create_full_node_crawler_service
-from chia.server.outbound_message import NodeType
+from chia.server.aliases import (
+    CrawlerService,
+    FarmerService,
+    FullNodeService,
+    HarvesterService,
+    IntroducerService,
+    TimelordService,
+    WalletService,
+)
+from chia.server.resolve_peer_info import set_peer_info
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_farmer import create_farmer_service
 from chia.server.start_full_node import create_full_node_service
@@ -35,18 +45,9 @@ from chia.simulator.ssl_certs import get_next_nodes_certs_and_keys, get_next_pri
 from chia.simulator.start_simulator import SimulatorFullNodeService, create_full_node_simulator_service
 from chia.ssl.create_ssl import create_all_ssl
 from chia.timelord.timelord_launcher import VDFClientProcessMgr, find_vdf_client, spawn_process
-from chia.types.aliases import (
-    CrawlerService,
-    FarmerService,
-    FullNodeService,
-    HarvesterService,
-    IntroducerService,
-    TimelordService,
-    WalletService,
-)
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.bech32m import encode_puzzle_hash
-from chia.util.config import config_path_for_filename, load_config, lock_and_load_config, save_config, set_peer_info
+from chia.util.config import config_path_for_filename, load_config, lock_and_load_config, save_config
 from chia.util.db_wrapper import generate_in_memory_db_uri
 from chia.util.keychain import bytes_to_mnemonic
 from chia.util.lock import Lockfile
@@ -316,7 +317,6 @@ async def setup_wallet_node(
                         # filesystem operations are async on windows
                         # [WinError 32] The process cannot access the file because it is
                         # being used by another process
-                        pass
             keychain.delete_all_keys()
 
 

chia/simulator/simulator_full_node_rpc_api.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
+from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.rpc.full_node_rpc_api import FullNodeRpcApi
+from chia.full_node.full_node_rpc_api import FullNodeRpcApi
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, GetAllCoinsProtocol, ReorgProtocol
 from chia.types.coin_record import CoinRecord
-from chia.types.full_block import FullBlock
 from chia.util.bech32m import decode_puzzle_hash
 
 

chia/simulator/simulator_full_node_rpc_client.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
+from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint128
 
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.types.coin_record import CoinRecord
-from chia.types.full_block import FullBlock
 from chia.util.bech32m import encode_puzzle_hash
 
 

chia/simulator/simulator_test_tools.py

@@ -9,7 +9,6 @@ from chia_rs import PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.daemon.server import WebSocketServer, daemon_launch_lock_path
 from chia.server.signal_handlers import SignalHandlers
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -29,6 +28,7 @@ from chia.util.errors import KeychainFingerprintExists
 from chia.util.keychain import Keychain
 from chia.util.lock import Lockfile
 from chia.wallet.derive_keys import master_sk_to_wallet_sk
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 """
 These functions are used to test the simulator.
@@ -56,7 +56,7 @@ def get_puzzle_hash_from_key(keychain: Keychain, fingerprint: int, key_id: int =
         raise Exception("Fingerprint not found")
     private_key = priv_key_and_entropy[0]
     sk_for_wallet_id: PrivateKey = master_sk_to_wallet_sk(private_key, uint32(key_id))
-    puzzle_hash: bytes32 = create_puzzlehash_for_pk(sk_for_wallet_id.get_g1())
+    puzzle_hash: bytes32 = puzzle_hash_for_pk(sk_for_wallet_id.get_g1())
     return puzzle_hash
 
 

chia/simulator/start_simulator.py

@@ -12,7 +12,7 @@ from chia_rs.sized_ints import uint16
 
 from chia.apis import ApiProtocolRegistry
 from chia.full_node.full_node import FullNode
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import Service, async_run
 from chia.simulator.block_tools import BlockTools, test_constants

chia/simulator/wallet_tools.py

@@ -2,19 +2,21 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, ConsensusConstants, G1Element, G2Element, PrivateKey, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_from_bytes, int_to_bytes
 
+from chia.consensus.condition_tools import (
+    agg_sig_additional_data,
+    conditions_dict_for_solution,
+    make_aggsig_final_message,
+)
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.types.spend_bundle import SpendBundle
-from chia.util.condition_tools import agg_sig_additional_data, conditions_dict_for_solution, make_aggsig_final_message
+from chia.util.casts import int_from_bytes, int_to_bytes
 from chia.util.hash import std_hash
 from chia.wallet.conditions import AssertCoinAnnouncement
 from chia.wallet.derive_keys import master_sk_to_wallet_sk
@@ -160,19 +162,9 @@ class WalletTool:
                     ConditionWithArgs(ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, [primary_announcement_hash])
                 )
                 main_solution = self.make_solution(condition_dic)
-                spends.append(
-                    CoinSpend(
-                        coin, SerializedProgram.from_program(puzzle), SerializedProgram.from_program(main_solution)
-                    )
-                )
+                spends.append(make_spend(coin, puzzle, main_solution))
             else:
-                spends.append(
-                    CoinSpend(
-                        coin,
-                        SerializedProgram.from_program(puzzle),
-                        SerializedProgram.from_program(self.make_solution(secondary_coins_cond_dic)),
-                    )
-                )
+                spends.append(make_spend(coin, puzzle, self.make_solution(secondary_coins_cond_dic)))
         return spends
 
     def sign_transaction(self, coin_spends: list[CoinSpend]) -> SpendBundle:

chia/ssl/create_ssl.py

@@ -13,7 +13,7 @@ from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives.serialization import load_pem_private_key
 from cryptography.x509.oid import NameOID
 
-from chia.util.ssl_check import DEFAULT_PERMISSIONS_CERT_FILE, DEFAULT_PERMISSIONS_KEY_FILE
+from chia.ssl.ssl_check import DEFAULT_PERMISSIONS_CERT_FILE, DEFAULT_PERMISSIONS_KEY_FILE
 
 _all_private_node_names: list[str] = [
     "full_node",

chia/timelord/iters_from_block.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
-from typing import Optional, Union
+from typing import Union
 
 from chia_rs import ConsensusConstants, RewardChainBlock, RewardChainBlockUnfinished
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
-from chia.consensus.pot_iterations import calculate_ip_iters, calculate_iterations_quality, calculate_sp_iters
-from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
+from chia.consensus.pot_iterations import (
+    calculate_ip_iters,
+    calculate_sp_iters,
+    validate_pospace_and_get_required_iters,
+)
 
 
 def iters_from_block(
@@ -16,6 +19,7 @@ def iters_from_block(
     sub_slot_iters: uint64,
     difficulty: uint64,
     height: uint32,
+    prev_transaction_block_height: uint32,
 ) -> tuple[uint64, uint64]:
     if reward_chain_block.challenge_chain_sp_vdf is None:
         assert reward_chain_block.signage_point_index == 0
@@ -23,22 +27,18 @@ def iters_from_block(
     else:
         cc_sp = reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
 
-    quality_string: Optional[bytes32] = verify_and_get_quality_string(
-        reward_chain_block.proof_of_space,
+    required_iters = validate_pospace_and_get_required_iters(
         constants,
+        reward_chain_block.proof_of_space,
         reward_chain_block.pos_ss_cc_challenge_hash,
         cc_sp,
-        height=height,
-    )
-    assert quality_string is not None
-
-    required_iters: uint64 = calculate_iterations_quality(
-        constants.DIFFICULTY_CONSTANT_FACTOR,
-        quality_string,
-        reward_chain_block.proof_of_space.size,
+        height,
         difficulty,
-        cc_sp,
+        sub_slot_iters,
+        prev_transaction_block_height,
     )
+    assert required_iters is not None
+
     return (
         calculate_sp_iters(constants, sub_slot_iters, reward_chain_block.signage_point_index),
         calculate_ip_iters(

chia/timelord/timelord.py

@@ -15,31 +15,32 @@ from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any, ClassVar, Optional, cast
 
-from chia_rs import ConsensusConstants, RewardChainBlock
+from chia_rs import (
+    ChallengeChainSubSlot,
+    ConsensusConstants,
+    EndOfSubSlotBundle,
+    InfusedChallengeChainSubSlot,
+    RewardChainBlock,
+    RewardChainSubSlot,
+    SubEpochSummary,
+    SubSlotProofs,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 from chiavdf import create_discriminant, prove
 
 from chia.consensus.pot_iterations import calculate_sp_iters, is_overflow_block
 from chia.protocols import timelord_protocol
+from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
-from chia.server.outbound_message import NodeType, make_msg
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.timelord.iters_from_block import iters_from_block
 from chia.timelord.timelord_state import LastState
 from chia.timelord.types import Chain, IterationType, StateType
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.slots import (
-    ChallengeChainSubSlot,
-    InfusedChallengeChainSubSlot,
-    RewardChainSubSlot,
-    SubSlotProofs,
-)
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof, validate_vdf
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 from chia.util.streamable import Streamable, streamable
 from chia.util.task_referencer import create_referenced_task
 
@@ -253,6 +254,7 @@ class Timelord:
                 sub_slot_iters,
                 difficulty,
                 self.get_height(),
+                self.last_state.get_last_tx_height(),
             )
         except Exception as e:
             log.warning(f"Received invalid unfinished block: {e}.")
@@ -555,6 +557,7 @@ class Timelord:
                             self.last_state.get_sub_slot_iters(),
                             self.last_state.get_difficulty(),
                             self.get_height(),
+                            uint32(0),
                         )
                     except Exception as e:
                         log.error(f"Error {e}")
@@ -628,7 +631,7 @@ class Timelord:
                     ):
                         # We don't know when the last block was, so we can't make peaks
                         return
-
+                    assert self.last_state.last_tx_block_block_height is not None
                     sp_total_iters = (
                         ip_total_iters
                         - ip_iters
@@ -1169,6 +1172,7 @@ class Timelord:
                     t1 = time.time()
                     log.info(
                         f"Working on compact proof for height: {picked_info.height}. "
+                        f"VDF: {picked_info.field_vdf}. "
                         f"Iters: {picked_info.new_proof_of_time.number_of_iterations}."
                     )
                     bluebox_process_data = BlueboxProcessData(

chia/timelord/timelord_api.py

@@ -38,7 +38,7 @@ class TimelordAPI:
         self.timelord.state_changed_callback = callback
 
     @metadata.request()
-    async def new_peak_timelord(self, new_peak: timelord_protocol.NewPeakTimelord) -> None:
+    async def new_peak_timelord(self, new_peak: NewPeakTimelord) -> None:
         if self.timelord.last_state is None:
             return None
         async with self.timelord.lock:
@@ -63,6 +63,8 @@ class TimelordAPI:
                     "Not skipping peak, has equal weight but lower iterations,"
                     f"current peak:{self.timelord.last_state.total_iters} new peak "
                     f"{new_peak.reward_chain_block.total_iters}"
+                    f"current rh: {self.timelord.last_state.peak.reward_chain_block.get_hash()}"
+                    f"new peak rh: {new_peak.reward_chain_block.get_hash()}"
                 )
                 self.timelord.new_peak = new_peak
                 self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
@@ -82,7 +84,7 @@ class TimelordAPI:
                 log.info(
                     "Not skipping peak, don't have. Maybe we are not the fastest timelord "
                     f"height: {new_peak.reward_chain_block.height} weight:"
-                    f"{new_peak.reward_chain_block.weight} "
+                    f"{new_peak.reward_chain_block.weight} rh {new_peak.reward_chain_block.get_hash()}"
                 )
                 self.timelord.new_peak = new_peak
                 self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
@@ -99,13 +101,22 @@ class TimelordAPI:
             self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
 
     def check_orphaned_unfinished_block(self, new_peak: NewPeakTimelord):
+        new_peak_unf_rh = new_peak.reward_chain_block.get_unfinished().get_hash()
         for unf_block in self.timelord.unfinished_blocks:
             if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                if unf_block.reward_chain_block.get_hash() == new_peak_unf_rh:
+                    log.debug("unfinished block is the same as the new peak")
+                    continue
                 # there is an unfinished block that would be orphaned by this peak
+                log.info(f"this peak would orphan unfinished block {unf_block.reward_chain_block.get_hash()}")
                 return True
         for unf_block in self.timelord.overflow_blocks:
             if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                if unf_block.reward_chain_block.get_hash() == new_peak_unf_rh:
+                    log.debug("overflow unfinished block is the same as the new peak")
+                    continue
                 # there is an unfinished block (overflow) that would be orphaned by this peak
+                log.info(f"this peak would orphan unfinished overflow block {unf_block.reward_chain_block.get_hash()}")
                 return True
         return False
 
@@ -123,6 +134,7 @@ class TimelordAPI:
                     self.timelord.last_state.get_sub_slot_iters(),
                     self.timelord.last_state.get_difficulty(),
                     self.timelord.get_height(),
+                    self.timelord.last_state.get_last_tx_height(),
                 )
             except Exception:
                 return None

chia/timelord/timelord_state.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Optional, Union
 
-from chia_rs import ConsensusConstants
+from chia_rs import ChallengeBlockInfo, ConsensusConstants, EndOfSubSlotBundle, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
@@ -11,9 +11,6 @@ from chia.protocols import timelord_protocol
 from chia.timelord.iters_from_block import iters_from_block
 from chia.timelord.types import Chain, StateType
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.slots import ChallengeBlockInfo
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 
 log = logging.getLogger(__name__)
 
@@ -41,7 +38,9 @@ class LastState:
         self.last_height: uint32 = uint32(0)
         self.total_iters: uint128 = uint128(0)
         self.last_challenge_sb_or_eos_total_iters = uint128(0)
-        self.last_block_total_iters: Optional[uint128] = None
+        self.last_tx_block_total_iters: Optional[uint128] = None
+        self.last_tx_block_block_height: uint32 = uint32(0)
+        self.last_tx_block_sp_index: uint8 = uint8(0)
         self.last_peak_challenge: bytes32 = constants.GENESIS_CHALLENGE
         self.difficulty: uint64 = constants.DIFFICULTY_STARTING
         self.sub_slot_iters: uint64 = constants.SUB_SLOT_ITERS_STARTING
@@ -55,13 +54,7 @@ class LastState:
             self.state_type = StateType.PEAK
             self.peak = state
             self.subslot_end = None
-            _, self.last_ip = iters_from_block(
-                self.constants,
-                state.reward_chain_block,
-                state.sub_slot_iters,
-                state.difficulty,
-                state.reward_chain_block.height,
-            )
+
             self.deficit = state.deficit
             self.sub_epoch_summary = state.sub_epoch_summary
             self.last_weight = state.reward_chain_block.weight
@@ -71,7 +64,17 @@ class LastState:
             self.difficulty = state.difficulty
             self.sub_slot_iters = state.sub_slot_iters
             if state.reward_chain_block.is_transaction_block:
-                self.last_block_total_iters = self.total_iters
+                self.last_tx_block_block_height = state.reward_chain_block.height
+                self.last_tx_block_total_iters = self.total_iters
+                self.last_tx_block_sp_index = state.reward_chain_block.signage_point_index
+            _, self.last_ip = iters_from_block(
+                self.constants,
+                state.reward_chain_block,
+                state.sub_slot_iters,
+                state.difficulty,
+                state.reward_chain_block.height,
+                self.last_tx_block_block_height,
+            )
             self.reward_challenge_cache = state.previous_reward_challenges
             self.last_challenge_sb_or_eos_total_iters = self.peak.last_challenge_sb_or_eos_total_iters
             self.new_epoch = False
@@ -171,7 +174,10 @@ class LastState:
         return None
 
     def get_last_block_total_iters(self) -> Optional[uint128]:
-        return self.last_block_total_iters
+        return self.last_tx_block_total_iters
+
+    def get_last_tx_height(self) -> uint32:
+        return self.last_tx_block_block_height
 
     def get_passed_ses_height_but_not_yet_included(self) -> bool:
         return self.passed_ses_height_but_not_yet_included

chia/types/blockchain_format/program.py

@@ -1,23 +1,25 @@
 from __future__ import annotations
 
 import io
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
-from chia_rs import ENABLE_KECCAK, MEMPOOL_MODE, run_chia_program, tree_hash
+from chia_rs import MEMPOOL_MODE, run_chia_program, tree_hash
 from chia_rs.sized_bytes import bytes32
-from clvm.casts import int_from_bytes
 from clvm.CLVMObject import CLVMStorage
 from clvm.EvalError import EvalError
 from clvm.serialize import sexp_from_stream, sexp_to_stream
 from clvm.SExp import SExp
+from typing_extensions import Self
 
+from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.tree_hash import sha256_treehash
 from chia.util.byte_types import hexstr_to_bytes
+from chia.util.casts import int_from_bytes
 from chia.util.hash import std_hash
 
 INFINITE_COST = 11000000000
 
-DEFAULT_FLAGS = MEMPOOL_MODE | ENABLE_KECCAK
+DEFAULT_FLAGS = MEMPOOL_MODE
 
 T_CLVMStorage = TypeVar("T_CLVMStorage", bound=CLVMStorage)
 T_Program = TypeVar("T_Program", bound="Program")
@@ -29,14 +31,27 @@ class Program(SExp):
     """
 
     @classmethod
-    def parse(cls: type[T_Program], f) -> T_Program:
+    def parse(cls, f) -> Self:
         return sexp_from_stream(f, cls.to)
 
-    def stream(self, f):
+    def stream(self, f) -> None:
         sexp_to_stream(self, f)
 
     @classmethod
-    def from_bytes(cls: type[T_Program], blob: bytes) -> T_Program:
+    def from_serialized(cls, prg: SerializedProgram) -> Self:
+        """
+        Convert the SerializedProgram to a Program object.
+        """
+        return cls.from_bytes(bytes(prg))
+
+    def to_serialized(self) -> SerializedProgram:
+        """
+        Convert a Program object to a SerializedProgram.
+        """
+        return SerializedProgram.from_bytes(bytes(self))
+
+    @classmethod
+    def from_bytes(cls, blob: bytes) -> Self:
         # this runs the program "1", which just returns the first argument.
         # the first argument is the buffer we want to parse. This effectively
         # leverages the rust parser and LazyNode, making it a lot faster to
@@ -50,7 +65,7 @@ class Program(SExp):
         return cls.to(ret)
 
     @classmethod
-    def fromhex(cls: type[T_Program], hexstr: str) -> T_Program:
+    def fromhex(cls, hexstr: str) -> Self:
         return cls.from_bytes(hexstr_to_bytes(hexstr))
 
     @classmethod
@@ -90,7 +105,7 @@ class Program(SExp):
                 raise ValueError(f"`at` got illegal character `{c}`. Only `f` & `r` allowed")
         return v
 
-    def replace(self: T_Program, **kwargs: Any) -> T_Program:
+    def replace(self, **kwargs: Any) -> Self:
         """
         Create a new program replacing the given paths (using `at` syntax).
         Example:
@@ -155,7 +170,7 @@ class Program(SExp):
     # (2 (1 . self) rest)
     #
     # Resulting in a function which places its own arguments after those
-    # curried in in the form of a proper list.
+    # curried in the form of a proper list.
     def curry(self, *args) -> Program:
         fixed_args: Any = 1
         for arg in reversed(args):
@@ -267,3 +282,31 @@ def _sexp_replace(sexp: T_CLVMStorage, to_sexp: Callable[[Any], T_Program], **kw
     new_r = _sexp_replace(pair[1], to_sexp, **args_by_prefix.get("r", {}))
 
     return to_sexp((new_f, new_r))
+
+
+def _run(prg: Union[SerializedProgram, Program], max_cost: int, flags: int, args: Any) -> tuple[int, Program]:
+    if isinstance(prg, SerializedProgram):
+        result = prg.run_rust(max_cost, flags, args)
+        return result[0], Program(result[1])  # type: ignore[arg-type]
+    else:
+        return prg._run(max_cost, flags, args)
+
+
+def uncurry(prg: Union[SerializedProgram, Program]) -> tuple[Program, Program]:
+    if isinstance(prg, SerializedProgram):
+        result = prg.uncurry_rust()
+        return Program(result[0]), Program(result[1])  # type: ignore[arg-type]
+    else:
+        return prg.uncurry()
+
+
+def run(prg: Union[SerializedProgram, Program], args: Any) -> Program:
+    return _run(prg, INFINITE_COST, 0, args)[1]
+
+
+def run_with_cost(prg: Union[SerializedProgram, Program], max_cost: int, args: Any) -> tuple[int, Program]:
+    return _run(prg, max_cost, 0, args)
+
+
+def run_mempool_with_cost(prg: Union[SerializedProgram, Program], max_cost: int, args: Any) -> tuple[int, Program]:
+    return _run(prg, max_cost, MEMPOOL_MODE, args)