chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/plotting/prover.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from enum import IntEnum
 from typing import TYPE_CHECKING, ClassVar, Protocol, cast
 
-from chia_rs import PlotSize
+from chia_rs import PartialProof, PlotParam, Prover, QualityProof
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8
 from chiapos import DiskProver
@@ -19,46 +20,65 @@ class PlotVersion(IntEnum):
     V2 = 2
 
 
+class QualityProtocol(Protocol):
+    def get_string(self) -> bytes32: ...
+
+
 class ProverProtocol(Protocol):
     def get_filename(self) -> str: ...
-    def get_size(self) -> PlotSize: ...
+    def get_param(self) -> PlotParam: ...
+    def get_strength(self) -> uint8: ...
     def get_memo(self) -> bytes: ...
     def get_compression_level(self) -> uint8: ...
     def get_version(self) -> PlotVersion: ...
     def __bytes__(self) -> bytes: ...
     def get_id(self) -> bytes32: ...
-    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]: ...
-
-    # this is only supported by v2 plots
-    def get_partial_proofs_for_challenge(self, challenge: bytes32, required_plot_strength: uint8) -> list[bytes]: ...
-
-    # this is only supported by v1 plots. v2 plots first get the partial proof
-    # and turn it into a full proof by calling solve_proof(), or pass it to the solver service
-    def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes: ...
+    def get_qualities_for_challenge(
+        self, challenge: bytes32, proof_fragment_filter: uint8
+    ) -> list[QualityProtocol]: ...
 
     @classmethod
     def from_bytes(cls, data: bytes) -> ProverProtocol: ...
 
 
+@dataclass(frozen=True)
+class V2Quality(QualityProtocol):
+    _quality_proof: QualityProof
+
+    def get_string(self) -> bytes32:
+        return self._quality_proof.serialize()
+
+
 class V2Prover:
     """Placeholder for future V2 plot format support"""
 
+    _prover: Prover
+
     if TYPE_CHECKING:
         _protocol_check: ClassVar[ProverProtocol] = cast("V2Prover", None)
 
-    def __init__(self, filename: str):
-        self._filename = filename
+    @classmethod
+    def from_filename(cls, path: str) -> V2Prover:
+        return V2Prover(Prover(path))
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> V2Prover:
+        return V2Prover(Prover.from_bytes(data))
+
+    def __init__(self, prover: Prover):
+        self._prover = prover
 
     def get_filename(self) -> str:
-        return str(self._filename)
+        return self._prover.get_filename()
 
-    def get_size(self) -> PlotSize:
-        # TODO: todo_v2_plots get k size from plot
-        raise NotImplementedError("V2 plot format is not yet implemented")
+    def get_param(self) -> PlotParam:
+        return PlotParam.make_v2(self._prover.get_strength())
+
+    def get_strength(self) -> uint8:
+        return uint8(self._prover.get_strength())
 
     def get_memo(self) -> bytes:
-        # TODO: todo_v2_plots
-        raise NotImplementedError("V2 plot format is not yet implemented")
+        return self._prover.get_memo()
 
     def get_compression_level(self) -> uint8:
         # v2 plots are never compressed
@@ -68,27 +88,24 @@ class V2Prover:
         return PlotVersion.V2
 
     def __bytes__(self) -> bytes:
-        # TODO: todo_v2_plots Implement prover serialization for caching
-        raise NotImplementedError("V2 plot format is not yet implemented")
+        return self._prover.to_bytes()
 
     def get_id(self) -> bytes32:
-        # TODO: Extract plot ID from V2 plot file
-        raise NotImplementedError("V2 plot format is not yet implemented")
+        return self._prover.plot_id()
 
-    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]:
-        raise AssertionError("V2 plot format does not support qualities directly, use partial proofs")
+    def get_qualities_for_challenge(self, challenge: bytes32, proof_fragment_filter: uint8) -> list[QualityProtocol]:
+        return [V2Quality(q) for q in self._prover.get_qualities_for_challenge(challenge, proof_fragment_filter)]
 
-    def get_partial_proofs_for_challenge(self, challenge: bytes, required_plot_strength: uint8) -> list[bytes]:
-        # TODO: todo_v2_plots Implement plot partial proof lookup
-        raise NotImplementedError("V2 plot format is not yet implemented")
+    def get_partial_proof(self, quality: V2Quality) -> PartialProof:
+        return self._prover.get_partial_proof(quality._quality_proof)[0]
 
-    def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes:
-        raise AssertionError("V2 plot format require solver to get full proof")
 
-    @classmethod
-    def from_bytes(cls, data: bytes) -> V2Prover:
-        # TODO: todo_v2_plots Implement prover deserialization from cache
-        raise NotImplementedError("V2 plot format is not yet implemented")
+@dataclass(frozen=True)
+class V1Quality(QualityProtocol):
+    _quality: bytes32
+
+    def get_string(self) -> bytes32:
+        return self._quality
 
 
 class V1Prover:
@@ -103,8 +120,11 @@ class V1Prover:
     def get_filename(self) -> str:
         return str(self._disk_prover.get_filename())
 
-    def get_size(self) -> PlotSize:
-        return PlotSize.make_v1(uint8(self._disk_prover.get_size()))
+    def get_param(self) -> PlotParam:
+        return PlotParam.make_v1(uint8(self._disk_prover.get_size()))
+
+    def get_strength(self) -> uint8:
+        raise AssertionError("V1 plot format doesn't use strength")
 
     def get_memo(self) -> bytes:
         return bytes(self._disk_prover.get_memo())
@@ -121,11 +141,8 @@ class V1Prover:
     def get_id(self) -> bytes32:
         return bytes32(self._disk_prover.get_id())
 
-    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]:
-        return [bytes32(quality) for quality in self._disk_prover.get_qualities_for_challenge(challenge)]
-
-    def get_partial_proofs_for_challenge(self, challenge: bytes32, required_plot_strength: uint8) -> list[bytes]:
-        raise AssertionError("V1 plot format doesn't use partial proofs")
+    def get_qualities_for_challenge(self, challenge: bytes32, proof_fragment_filter: uint8) -> list[QualityProtocol]:
+        return [V1Quality(bytes32(quality)) for quality in self._disk_prover.get_qualities_for_challenge(challenge)]
 
     def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes:
         return bytes(self._disk_prover.get_full_proof(challenge, index, parallel_read))
@@ -137,7 +154,7 @@ class V1Prover:
 
 def get_prover_from_bytes(filename: str, prover_data: bytes) -> ProverProtocol:
     if filename.endswith(".plot2"):
-        return V2Prover.from_bytes(prover_data)
+        return V2Prover(Prover.from_bytes(prover_data))
     elif filename.endswith(".plot"):
         return V1Prover(DiskProver.from_bytes(prover_data))
     else:
@@ -146,7 +163,7 @@ def get_prover_from_bytes(filename: str, prover_data: bytes) -> ProverProtocol:
 
 def get_prover_from_file(filename: str) -> ProverProtocol:
     if filename.endswith(".plot2"):
-        return V2Prover(filename)
+        return V2Prover(Prover(filename))
     elif filename.endswith(".plot"):
         return V1Prover(DiskProver(filename))
     else:

chia/plotting/util.py

@@ -4,7 +4,7 @@ import logging
 from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from chia.plotting.prover import ProverProtocol
@@ -42,8 +42,8 @@ class PlotsRefreshParameter(Streamable):
 @dataclass
 class PlotInfo:
     prover: ProverProtocol
-    pool_public_key: Optional[G1Element]
-    pool_contract_puzzle_hash: Optional[bytes32]
+    pool_public_key: G1Element | None
+    pool_contract_puzzle_hash: bytes32 | None
     plot_public_key: G1Element
     file_size: int
     time_modified: float
@@ -88,10 +88,10 @@ class Params:
     num_threads: int
     buckets: int
     tmp_dir: Path
-    tmp2_dir: Optional[Path]
+    tmp2_dir: Path | None
     final_dir: Path
-    plotid: Optional[str]
-    memo: Optional[str]
+    plotid: str | None
+    memo: str | None
     nobitfield: bool
     stripe_size: int = 65536
 
@@ -101,7 +101,7 @@ class HarvestingMode(IntEnum):
     GPU = 2
 
 
-def get_plot_directories(root_path: Path, config: Optional[dict] = None) -> list[str]:
+def get_plot_directories(root_path: Path, config: dict | None = None) -> list[str]:
     if config is None:
         config = load_config(root_path, "config.yaml")
     return config["harvester"]["plot_directories"] or []
@@ -192,14 +192,14 @@ def get_harvester_config(root_path: Path) -> dict[str, Any]:
 def update_harvester_config(
     root_path: Path,
     *,
-    use_gpu_harvesting: Optional[bool] = None,
-    gpu_index: Optional[int] = None,
-    enforce_gpu_index: Optional[bool] = None,
-    disable_cpu_affinity: Optional[bool] = None,
-    parallel_decompressor_count: Optional[int] = None,
-    decompressor_thread_count: Optional[int] = None,
-    recursive_plot_scan: Optional[bool] = None,
-    refresh_parameter: Optional[PlotsRefreshParameter] = None,
+    use_gpu_harvesting: bool | None = None,
+    gpu_index: int | None = None,
+    enforce_gpu_index: bool | None = None,
+    disable_cpu_affinity: bool | None = None,
+    parallel_decompressor_count: int | None = None,
+    decompressor_thread_count: int | None = None,
+    recursive_plot_scan: bool | None = None,
+    refresh_parameter: PlotsRefreshParameter | None = None,
 ):
     with lock_and_load_config(root_path, "config.yaml") as config:
         if use_gpu_harvesting is not None:
@@ -257,7 +257,7 @@ def get_filenames(directory: Path, recursive: bool, follow_links: bool) -> list[
     return all_files
 
 
-def parse_plot_info(memo: bytes) -> tuple[Union[G1Element, bytes32], G1Element, PrivateKey]:
+def parse_plot_info(memo: bytes) -> tuple[G1Element | bytes32, G1Element, PrivateKey]:
     # Parses the plot info bytes into keys
     if len(memo) == (48 + 48 + 32):
         # This is a public key memo

chia/pools/pool_config.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32

chia/pools/pool_puzzles.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 from chia_puzzles_py.programs import (
     P2_SINGLETON_OR_DELAYED_PUZHASH,
@@ -126,8 +125,8 @@ def get_delayed_puz_info_from_launcher_spend(coinsol: CoinSpend) -> tuple[uint64
     extra_data = Program.from_bytes(bytes(coinsol.solution)).rest().rest().first()
     # Extra data is (pool_state delayed_puz_info)
     # Delayed puz info is (seconds delayed_puzzle_hash)
-    seconds: Optional[uint64] = None
-    delayed_puzzle_hash: Optional[bytes32] = None
+    seconds: uint64 | None = None
+    delayed_puzzle_hash: bytes32 | None = None
     for key_value_pairs in extra_data.as_iter():
         key_value_pair = key_value_pairs.as_pair()
         if key_value_pair is None:
@@ -221,14 +220,14 @@ def create_travel_spend(
     else:
         raise ValueError
 
-    current_singleton: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(last_coin_spend)
+    current_singleton: Coin | None = get_most_recent_singleton_coin_from_coin_spend(last_coin_spend)
     assert current_singleton is not None
 
     if current_singleton.parent_coin_info == launcher_coin.name():
         parent_info_list = Program.to([launcher_coin.parent_coin_info, launcher_coin.amount])
     else:
         p = Program.from_bytes(bytes(last_coin_spend.puzzle_reveal))
-        last_coin_spend_inner_puzzle: Optional[Program] = get_inner_puzzle_from_puzzle(p)
+        last_coin_spend_inner_puzzle: Program | None = get_inner_puzzle_from_puzzle(p)
         assert last_coin_spend_inner_puzzle is not None
         parent_info_list = Program.to(
             [
@@ -272,14 +271,14 @@ def create_absorb_spend(
     else:
         raise ValueError
     # full sol = (parent_info, my_amount, inner_solution)
-    coin: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(last_coin_spend)
+    coin: Coin | None = get_most_recent_singleton_coin_from_coin_spend(last_coin_spend)
     assert coin is not None
 
     if coin.parent_coin_info == launcher_coin.name():
         parent_info: Program = Program.to([launcher_coin.parent_coin_info, launcher_coin.amount])
     else:
         p = Program.from_bytes(bytes(last_coin_spend.puzzle_reveal))
-        last_coin_spend_inner_puzzle: Optional[Program] = get_inner_puzzle_from_puzzle(p)
+        last_coin_spend_inner_puzzle: Program | None = get_inner_puzzle_from_puzzle(p)
         assert last_coin_spend_inner_puzzle is not None
         parent_info = Program.to(
             [
@@ -309,7 +308,7 @@ def create_absorb_spend(
     return coin_spends
 
 
-def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Optional[Coin]:
+def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Coin | None:
     additions: list[Coin] = compute_additions(coin_sol)
     for coin in additions:
         if coin.amount % 2 == 1:
@@ -369,7 +368,7 @@ def uncurry_pool_waitingroom_inner_puzzle(inner_puzzle: Program) -> tuple[Progra
     return target_puzzle_hash, relative_lock_height, owner_pubkey, p2_singleton_hash
 
 
-def get_inner_puzzle_from_puzzle(full_puzzle: Program) -> Optional[Program]:
+def get_inner_puzzle_from_puzzle(full_puzzle: Program) -> Program | None:
     p = Program.from_bytes(bytes(full_puzzle))
     r = p.uncurry()
     if r is None:
@@ -382,8 +381,8 @@ def get_inner_puzzle_from_puzzle(full_puzzle: Program) -> Optional[Program]:
     return inner_puzzle
 
 
-def pool_state_from_extra_data(extra_data: Program) -> Optional[PoolState]:
-    state_bytes: Optional[bytes] = None
+def pool_state_from_extra_data(extra_data: Program) -> PoolState | None:
+    state_bytes: bytes | None = None
     try:
         for key, value in extra_data.as_python():
             if key == b"p":
@@ -397,7 +396,7 @@ def pool_state_from_extra_data(extra_data: Program) -> Optional[PoolState]:
         return None
 
 
-def solution_to_pool_state(full_spend: CoinSpend) -> Optional[PoolState]:
+def solution_to_pool_state(full_spend: CoinSpend) -> PoolState | None:
     full_solution_ser: SerializedProgram = full_spend.solution
     full_solution: Program = Program.from_bytes(bytes(full_solution_ser))
 

chia/pools/pool_wallet.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -41,11 +40,10 @@ from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
-from chia.wallet.conditions import AssertCoinAnnouncement, Condition, ConditionValidTimes
+from chia.wallet.conditions import AssertCoinAnnouncement, Condition
 from chia.wallet.puzzles.singleton_top_layer import SINGLETON_LAUNCHER
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.compute_additions import compute_additions
-from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet import Wallet
@@ -79,7 +77,7 @@ class PoolWallet:
     wallet_id: int
     next_transaction_fee: uint64 = uint64(0)
     next_tx_config: TXConfig = DEFAULT_TX_CONFIG
-    target_state: Optional[PoolState] = None
+    target_state: PoolState | None = None
 
     """
     From the user's perspective, this is not a wallet at all, but a way to control
@@ -134,7 +132,7 @@ class PoolWallet:
         return self.wallet_info.id
 
     @classmethod
-    def _verify_self_pooled(cls, state: PoolState) -> Optional[str]:
+    def _verify_self_pooled(cls, state: PoolState) -> str | None:
         err = ""
         if state.pool_url not in {None, ""}:
             err += " Unneeded pool_url for self-pooling"
@@ -145,7 +143,7 @@ class PoolWallet:
         return None if err == "" else err
 
     @classmethod
-    def _verify_pooling_state(cls, state: PoolState) -> Optional[str]:
+    def _verify_pooling_state(cls, state: PoolState) -> str | None:
         err = ""
         if state.relative_lock_height < cls.MINIMUM_RELATIVE_LOCK_HEIGHT:
             err += (
@@ -163,7 +161,7 @@ class PoolWallet:
         return err
 
     @classmethod
-    def _verify_pool_state(cls, state: PoolState) -> Optional[str]:
+    def _verify_pool_state(cls, state: PoolState) -> str | None:
         if state.target_puzzle_hash is None:
             return "Invalid puzzle_hash"
 
@@ -199,13 +197,13 @@ class PoolWallet:
 
         launcher_coin: Coin = all_spends[0].coin
         delayed_seconds, delayed_puzhash = get_delayed_puz_info_from_launcher_spend(all_spends[0])
-        tip_singleton_coin: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(all_spends[-1])
+        tip_singleton_coin: Coin | None = get_most_recent_singleton_coin_from_coin_spend(all_spends[-1])
         launcher_id: bytes32 = launcher_coin.name()
         p2_singleton_puzzle_hash = launcher_id_to_p2_puzzle_hash(launcher_id, delayed_seconds, delayed_puzhash)
         assert tip_singleton_coin is not None
 
         curr_spend_i = len(all_spends) - 1
-        pool_state: Optional[PoolState] = None
+        pool_state: PoolState | None = None
         last_singleton_spend_height = uint32(0)
         while pool_state is None:
             full_spend: CoinSpend = all_spends[curr_spend_i]
@@ -234,7 +232,7 @@ class PoolWallet:
         current_state: PoolWalletInfo = await self.get_current_state()
         pool_config_list: list[PoolWalletConfig] = load_pool_config(self.wallet_state_manager.root_path)
         pool_config_dict: dict[bytes32, PoolWalletConfig] = {c.launcher_id: c for c in pool_config_list}
-        existing_config: Optional[PoolWalletConfig] = pool_config_dict.get(current_state.launcher_id, None)
+        existing_config: PoolWalletConfig | None = pool_config_dict.get(current_state.launcher_id, None)
         payout_instructions: str = existing_config.payout_instructions if existing_config is not None else ""
 
         if len(payout_instructions) == 0:
@@ -263,7 +261,7 @@ class PoolWallet:
         tip: tuple[uint32, CoinSpend] = await self.get_tip()
         tip_spend = tip[1]
 
-        tip_coin: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
+        tip_coin: Coin | None = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
         assert tip_coin is not None
         spent_coin_name: bytes32 = tip_coin.name()
 
@@ -285,7 +283,7 @@ class PoolWallet:
         for _, added_spend in reversed(
             await self.wallet_state_manager.pool_store.get_spends_for_wallet(self.wallet_id)
         ):
-            latest_state: Optional[PoolState] = solution_to_pool_state(added_spend)
+            latest_state: PoolState | None = solution_to_pool_state(added_spend)
             if latest_state is not None:
                 if self.target_state == latest_state:
                     self.target_state = None
@@ -328,7 +326,7 @@ class PoolWallet:
         block_spends: list[CoinSpend],
         block_height: uint32,
         *,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> PoolWallet:
         """
         This creates a new PoolWallet with only one spend: the launcher spend. The DB MUST be committed after calling
@@ -346,7 +344,7 @@ class PoolWallet:
             standard_wallet=wallet,
         )
 
-        launcher_spend: Optional[CoinSpend] = None
+        launcher_spend: CoinSpend | None = None
         for spend in block_spends:
             if spend.coin.name() == launcher_coin_id:
                 launcher_spend = spend
@@ -366,7 +364,7 @@ class PoolWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         wallet_info: WalletInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> PoolWallet:
         """
         This creates a PoolWallet from DB. However, all data is already handled by WalletPoolStore, so we don't need
@@ -388,8 +386,8 @@ class PoolWallet:
         initial_target_state: PoolState,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        p2_singleton_delay_time: Optional[uint64] = None,
-        p2_singleton_delayed_ph: Optional[bytes32] = None,
+        p2_singleton_delay_time: uint64 | None = None,
+        p2_singleton_delayed_ph: bytes32 | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> tuple[bytes32, bytes32]:
         """
@@ -523,25 +521,15 @@ class PoolWallet:
 
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=uint64(time.time()),
-                    to_puzzle_hash=new_full_puzzle.get_tree_hash(),
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(new_full_puzzle.get_tree_hash()),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=self.id(),
+                    puzzle_hash=new_full_puzzle.get_tree_hash(),
                     amount=uint64(1),
-                    fee_amount=fee,
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=unsigned_spend_bundle,
                     additions=unsigned_spend_bundle.additions(),
                     removals=unsigned_spend_bundle.removals(),
-                    wallet_id=self.id(),
-                    sent_to=[],
-                    trade_id=None,
-                    memos={},
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=unsigned_spend_bundle.name(),
-                    valid_times=ConditionValidTimes(),
                 )
             )
 
@@ -714,7 +702,7 @@ class PoolWallet:
         return total_fee
 
     async def claim_pool_rewards(
-        self, fee: uint64, max_spends_in_tx: Optional[int], action_scope: WalletActionScope
+        self, fee: uint64, max_spends_in_tx: int | None, action_scope: WalletActionScope
     ) -> None:
         # Search for p2_puzzle_hash coins, and spend them with the singleton
         if await self.have_unconfirmed_transaction():
@@ -734,7 +722,7 @@ class PoolWallet:
         farming_rewards: list[TransactionRecord] = await self.wallet_state_manager.tx_store.get_farming_rewards()
         coin_to_height_farmed: dict[Coin, uint32] = {}
         for tx_record in farming_rewards:
-            height_farmed: Optional[uint32] = tx_record.height_farmed(
+            height_farmed: uint32 | None = tx_record.height_farmed(
                 self.wallet_state_manager.constants.GENESIS_CHALLENGE
             )
             assert height_farmed is not None
@@ -793,29 +781,18 @@ class PoolWallet:
                 ),
             )
 
-        current_time = uint64(time.time())
         # The claim spend, minus the fee amount from the main wallet
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=current_time,
-                    to_puzzle_hash=current_state.current.target_puzzle_hash,
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(current_state.current.target_puzzle_hash),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=uint32(self.wallet_id),
+                    puzzle_hash=current_state.current.target_puzzle_hash,
                     amount=uint64(total_amount),
-                    fee_amount=fee,  # This will not be double counted in self.standard_wallet
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=claim_spend,
                     additions=[add for add in claim_spend.additions() if add.amount == last_solution.coin.amount],
                     removals=claim_spend.removals(),
-                    wallet_id=uint32(self.wallet_id),
-                    sent_to=[],
-                    memos={},
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=claim_spend.name(),
-                    valid_times=ConditionValidTimes(),
                 )
             )
 
@@ -842,7 +819,7 @@ class PoolWallet:
                 unconfirmed: list[
                     TransactionRecord
                 ] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(self.wallet_id)
-                next_tip: Optional[Coin] = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
+                next_tip: Coin | None = get_most_recent_singleton_coin_from_coin_spend(tip_spend)
                 assert next_tip is not None
 
                 if any([rem.name() == next_tip.name() for tx_rec in unconfirmed for rem in tx_rec.removals]):
@@ -870,7 +847,7 @@ class PoolWallet:
         )
         return len(unconfirmed) > 0
 
-    async def get_confirmed_balance(self, _: Optional[object] = None) -> uint128:
+    async def get_confirmed_balance(self, _: object | None = None) -> uint128:
         amount: uint128 = uint128(0)
         if (await self.get_current_state()).current.state == SELF_POOLING.value:
             unspent_coin_records: list[WalletCoinRecord] = list(
@@ -881,19 +858,19 @@ class PoolWallet:
                     amount = uint128(amount + record.coin.amount)
         return amount
 
-    async def get_unconfirmed_balance(self, record_list: Optional[object] = None) -> uint128:
+    async def get_unconfirmed_balance(self, record_list: object | None = None) -> uint128:
         return await self.get_confirmed_balance(record_list)
 
-    async def get_spendable_balance(self, record_list: Optional[object] = None) -> uint128:
+    async def get_spendable_balance(self, record_list: object | None = None) -> uint128:
         return await self.get_confirmed_balance(record_list)
 
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)
 
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None) -> uint128:
         return uint128(0)
 
-    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[object]) -> None:
+    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: object | None) -> None:
         pass
 
     async def select_coins(self, amount: uint64, action_scope: WalletActionScope) -> set[Coin]:
@@ -917,8 +894,8 @@ class PoolWallet:
         puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        memos: Optional[list[list[bytes]]] = None,
+        coins: set[Coin] | None = None,
+        memos: list[list[bytes]] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None: