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

chia/wallet/wallet_state_manager.py

@@ -7,15 +7,15 @@ import logging
 import multiprocessing.context
 import time
 import traceback
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast
 
 import aiosqlite
-from chia_rs import AugSchemeMPL, CoinSpend, CoinState, ConsensusConstants, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinRecord, CoinSpend, CoinState, ConsensusConstants, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint16, uint32, uint64, uint128
+from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.coinbase import farmer_parent_id, pool_parent_id
@@ -33,8 +33,7 @@ from chia.rpc.rpc_server import StateChangedProtocol
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import NIL, Program
-from chia.types.coin_record import CoinRecord
+from chia.types.blockchain_format.program import Program
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.db_synchronous import db_synchronous_on
@@ -60,10 +59,12 @@ from chia.wallet.conditions import (
 from chia.wallet.db_wallet.db_wallet_puzzles import MIRROR_PUZZLE_HASH
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.derive_keys import (
+    MAX_POOL_WALLETS,
     _derive_path,
     _derive_pk_unhardened,
     master_pk_to_wallet_pk_unhardened,
     master_pk_to_wallet_pk_unhardened_intermediate,
+    master_sk_to_singleton_owner_sk,
     master_sk_to_wallet_sk,
     master_sk_to_wallet_sk_intermediate,
     master_sk_to_wallet_sk_unhardened,
@@ -105,7 +106,7 @@ from chia.wallet.util.compute_hints import compute_spend_hints_and_additions
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
 from chia.wallet.util.puzzle_decorator import PuzzleDecoratorManager
-from chia.wallet.util.query_filter import HashFilter
+from chia.wallet.util.query_filter import FilterMode, HashFilter
 from chia.wallet.util.transaction_type import CLAWBACK_INCOMING_TRANSACTION_TYPES, TransactionType
 from chia.wallet.util.tx_config import TXConfig, TXConfigLoader
 from chia.wallet.util.wallet_sync_utils import (
@@ -123,7 +124,7 @@ from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_action_scope import WalletActionScope, new_wallet_action_scope
 from chia.wallet.wallet_blockchain import WalletBlockchain
 from chia.wallet.wallet_coin_record import MetadataTypes, WalletCoinRecord
-from chia.wallet.wallet_coin_store import WalletCoinStore
+from chia.wallet.wallet_coin_store import CoinRecordOrder, WalletCoinStore
 from chia.wallet.wallet_info import WalletInfo
 from chia.wallet.wallet_interested_store import WalletInterestedStore
 from chia.wallet.wallet_nft_store import WalletNftStore
@@ -165,16 +166,16 @@ class WalletStateManager:
     log: logging.Logger
 
     # TODO Don't allow user to send tx until wallet is synced
-    _sync_target: Optional[uint32]
+    _sync_target: uint32 | None
 
-    state_changed_callback: Optional[StateChangedProtocol] = None
-    pending_tx_callback: Optional[PendingTxCallback]
+    state_changed_callback: StateChangedProtocol | None = None
+    pending_tx_callback: PendingTxCallback | None
     db_path: Path
     db_wrapper: DBWrapper2
 
     main_wallet: Wallet
     wallets: dict[uint32, WalletProtocol[Any]]
-    private_key: Optional[PrivateKey]
+    private_key: PrivateKey | None
     root_pubkey: G1Element
 
     trade_manager: TradeManager
@@ -196,14 +197,14 @@ class WalletStateManager:
 
     @staticmethod
     async def create(
-        private_key: Optional[PrivateKey],
+        private_key: PrivateKey | None,
         config: dict[str, Any],
         db_path: Path,
         constants: ConsensusConstants,
         server: ChiaServer,
         root_path: Path,
         wallet_node: WalletNode,
-        root_pubkey: Optional[G1Element] = None,
+        root_pubkey: G1Element | None = None,
     ) -> WalletStateManager:
         self = WalletStateManager()
 
@@ -214,7 +215,7 @@ class WalletStateManager:
         self.log = logging.getLogger(__name__)
         self.lock = asyncio.Lock()
         self.log.debug(f"Starting in db path: {db_path}")
-        sql_log_path: Optional[Path] = None
+        sql_log_path: Path | None = None
         if self.config.get("log_sqlite_cmds", False):
             sql_log_path = path_from_root(self.root_path, "log/wallet_sql.log")
             self.log.info(f"logging SQL commands to {sql_log_path}")
@@ -280,7 +281,7 @@ class WalletStateManager:
             AssetType.CAT: CATWallet,
         }
 
-        wallet: Optional[WalletProtocol[Any]] = None
+        wallet: WalletProtocol[Any] | None = None
         for wallet_info in await self.get_all_wallet_info_entries():
             wallet_type = WalletType(wallet_info.type)
             if wallet_type == WalletType.STANDARD_WALLET:
@@ -367,9 +368,13 @@ class WalletStateManager:
         return self.private_key
 
     def get_wallet(self, id: uint32, required_type: type[TWalletType]) -> TWalletType:
+        if id not in self.wallets:
+            raise ValueError(f"Wallet with id {id} does not exist")
+
         wallet = self.wallets[id]
+
         if not isinstance(wallet, required_type):
-            raise Exception(
+            raise ValueError(
                 f"wallet id {id} is of type {type(wallet).__name__} but type {required_type.__name__} is required",
             )
 
@@ -389,9 +394,9 @@ class WalletStateManager:
         self,
         from_zero: bool = False,
         mark_existing_as_used: bool = True,
-        up_to_index: Optional[uint32] = None,
-        num_additional_phs: Optional[int] = None,
-        previous_result: Optional[CreateMorePuzzleHashesResult] = None,
+        up_to_index: uint32 | None = None,
+        num_additional_phs: int | None = None,
+        previous_result: CreateMorePuzzleHashesResult | None = None,
         _commit_previous_result: bool = True,
     ) -> CreateMorePuzzleHashesResult:
         """
@@ -408,8 +413,8 @@ class WalletStateManager:
                     if _commit_previous_result:
                         await previous_result.commit(self)
                 targets = list(self.wallets.keys())
-                self.log.debug("Target wallets to generate puzzle hashes for: %s", repr(targets))
-                unused: Optional[uint32] = (
+                self.log.debug("Target wallets to generate puzzle hashes for: %r", targets)
+                unused: uint32 | None = (
                     up_to_index if up_to_index is not None else await self.puzzle_store.get_unused_derivation_path()
                 )
                 if unused is None:
@@ -439,7 +444,7 @@ class WalletStateManager:
                     if from_zero:
                         start_index_by_wallet[wallet_id] = 0
                         continue
-                    last: Optional[uint32] = await self.puzzle_store.get_last_derivation_path_for_wallet(wallet_id)
+                    last: uint32 | None = await self.puzzle_store.get_last_derivation_path_for_wallet(wallet_id)
                     if last is not None:
                         if last >= last_index:
                             self.log.debug(f"Nothing to create for for wallet_id: {wallet_id}, index: {last_index}")
@@ -490,7 +495,7 @@ class WalletStateManager:
                     )
                     self.log.info(f"Start: {creating_msg}")
                     for index in range(start_index, last_index + 1):
-                        pubkey: Optional[G1Element] = hardened_keys.get(index)
+                        pubkey: G1Element | None = hardened_keys.get(index)
                         if pubkey is not None:
                             # Hardened
                             puzzlehash: bytes32 = target_wallet.puzzle_hash_for_pk(pubkey)
@@ -540,8 +545,8 @@ class WalletStateManager:
     async def update_wallet_puzzle_hashes(self, wallet_id: uint32) -> None:
         derivation_paths: list[DerivationRecord] = []
         target_wallet = self.wallets[wallet_id]
-        last: Optional[uint32] = await self.puzzle_store.get_last_derivation_path_for_wallet(wallet_id)
-        unused: Optional[uint32] = await self.puzzle_store.get_unused_derivation_path_for_wallet(wallet_id)
+        last: uint32 | None = await self.puzzle_store.get_last_derivation_path_for_wallet(wallet_id)
+        unused: uint32 | None = await self.puzzle_store.get_unused_derivation_path_for_wallet(wallet_id)
         if unused is None:
             # This handles the case where the database has entries but they have all been used
             unused = await self.puzzle_store.get_last_derivation_path()
@@ -571,7 +576,7 @@ class WalletStateManager:
         wallet_id: uint32,
         *,
         hardened: bool = False,
-        previous_result: Optional[GetUnusedDerivationRecordResult] = None,
+        previous_result: GetUnusedDerivationRecordResult | None = None,
     ) -> GetUnusedDerivationRecordResult:
         """
         Creates a puzzle hash for the given wallet, and then makes more puzzle hashes
@@ -582,13 +587,13 @@ class WalletStateManager:
             async with self.puzzle_hash_db_writer():
                 if previous_result is not None:
                     await previous_result.commit(self)
-                    create_more_puzzle_hashes_result: Optional[CreateMorePuzzleHashesResult] = (
+                    create_more_puzzle_hashes_result: CreateMorePuzzleHashesResult | None = (
                         previous_result.create_more_puzzle_hashes_result
                     )
                 else:
                     create_more_puzzle_hashes_result = None
                 # If we have no unused public keys, we will create new ones
-                unused: Optional[uint32] = await self.puzzle_store.get_unused_derivation_path()
+                unused: uint32 | None = await self.puzzle_store.get_unused_derivation_path()
                 if unused is None:
                     self.log.debug("No unused paths, generate more ")
                     create_more_puzzle_hashes_result = await self.create_more_puzzle_hashes(
@@ -600,7 +605,7 @@ class WalletStateManager:
                     assert unused is not None
 
                 self.log.debug("Fetching derivation record for: %s %s %s", unused, wallet_id, hardened)
-                record: Optional[DerivationRecord] = await self.puzzle_store.get_derivation_record(
+                record: DerivationRecord | None = await self.puzzle_store.get_derivation_record(
                     unused, wallet_id, hardened
                 )
                 if record is None:
@@ -625,10 +630,10 @@ class WalletStateManager:
         await result.commit(self)
         return result.record
 
-    async def get_current_derivation_record_for_wallet(self, wallet_id: uint32) -> Optional[DerivationRecord]:
+    async def get_current_derivation_record_for_wallet(self, wallet_id: uint32) -> DerivationRecord | None:
         async with self.puzzle_store.lock:
             # If we have no unused public keys, we will create new ones
-            current: Optional[DerivationRecord] = await self.puzzle_store.get_current_derivation_record_for_wallet(
+            current: DerivationRecord | None = await self.puzzle_store.get_current_derivation_record_for_wallet(
                 wallet_id
             )
             return current
@@ -646,7 +651,7 @@ class WalletStateManager:
         self.pending_tx_callback = callback
 
     def state_changed(
-        self, state: str, wallet_id: Optional[int] = None, data_object: Optional[dict[str, Any]] = None
+        self, state: str, wallet_id: int | None = None, data_object: dict[str, Any] | None = None
     ) -> None:
         """
         Calls the callback if it's present.
@@ -669,7 +674,7 @@ class WalletStateManager:
 
         self.pending_tx_callback()
 
-    async def synced(self, block_is_current_at: Optional[int] = None) -> bool:
+    async def synced(self, block_is_current_at: int | None = None) -> bool:
         if block_is_current_at is None:
             block_is_current_at = int(time.time() - 60 * 5)
         if len(self.server.get_connections(NodeType.FULL_NODE)) == 0:
@@ -697,7 +702,7 @@ class WalletStateManager:
         return self._sync_target is not None
 
     @property
-    def sync_target(self) -> Optional[uint32]:
+    def sync_target(self) -> uint32 | None:
         return self._sync_target
 
     @asynccontextmanager
@@ -727,7 +732,7 @@ class WalletStateManager:
                 self._sync_target = None
 
     async def get_confirmed_spendable_balance_for_wallet(
-        self, wallet_id: int, unspent_records: Optional[set[WalletCoinRecord]] = None
+        self, wallet_id: int, unspent_records: set[WalletCoinRecord] | None = None
     ) -> uint128:
         """
         Returns the balance amount of all coins that are spendable.
@@ -753,7 +758,7 @@ class WalletStateManager:
     async def get_confirmed_balance_for_wallet(
         self,
         wallet_id: int,
-        unspent_coin_records: Optional[set[WalletCoinRecord]] = None,
+        unspent_coin_records: set[WalletCoinRecord] | None = None,
     ) -> uint128:
         """
         Returns the confirmed balance, including coinbase rewards that are not spendable.
@@ -768,7 +773,7 @@ class WalletStateManager:
         return uint128(sum(cr.coin.amount for cr in unspent_coin_records))
 
     async def get_unconfirmed_balance(
-        self, wallet_id: int, unspent_coin_records: Optional[set[WalletCoinRecord]] = None
+        self, wallet_id: int, unspent_coin_records: set[WalletCoinRecord] | None = None
     ) -> uint128:
         """
         Returns the balance, including coinbase rewards that are not spendable, and unconfirmed
@@ -825,8 +830,8 @@ class WalletStateManager:
         return {**removals, **{coin_id: cr.coin for coin_id, cr in trade_removals.items() if cr.wallet_id == wallet_id}}
 
     async def determine_coin_type(
-        self, peer: WSChiaConnection, coin_state: CoinState, fork_height: Optional[uint32]
-    ) -> tuple[Optional[WalletIdentifier], Optional[Streamable]]:
+        self, peer: WSChiaConnection, coin_state: CoinState, fork_height: uint32 | None
+    ) -> tuple[WalletIdentifier | None, Streamable | None]:
         if coin_state.created_height is not None and (
             self.is_pool_reward(uint32(coin_state.created_height), coin_state.coin)
             or self.is_farmer_reward(uint32(coin_state.created_height), coin_state.coin)
@@ -883,7 +888,7 @@ class WalletStateManager:
             p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = did_curried_args
             did_data: DIDCoinData = DIDCoinData(
                 p2_puzzle,
-                bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.to(None) else None,
+                bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.NIL else None,
                 uint16(num_verification.as_int()),
                 singleton_struct,
                 metadata,
@@ -964,7 +969,7 @@ class WalletStateManager:
         coin_spends: list[CoinSpend] = []
         message: bytes32 = std_hash(b"".join([c.name() for c in clawback_coins.keys()]))
         now: uint64 = uint64(time.time())
-        derivation_record: Optional[DerivationRecord] = None
+        derivation_record: DerivationRecord | None = None
         amount: uint64 = uint64(0)
         for coin, metadata in clawback_coins.items():
             try:
@@ -1113,8 +1118,8 @@ class WalletStateManager:
         coin_state: CoinState,
         coin_spend: CoinSpend,
         peer: WSChiaConnection,
-        fork_height: Optional[uint32],
-    ) -> Optional[WalletIdentifier]:
+        fork_height: uint32 | None,
+    ) -> WalletIdentifier | None:
         """
         Handle the new coin when it is a CAT
         :param parent_data: Parent CAT coin uncurried metadata
@@ -1210,7 +1215,7 @@ class WalletStateManager:
                     cat_wallet: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
                         self,
                         self.main_wallet,
-                        crcat.tail_hash.hex(),
+                        crcat.tail_hash,
                         authorized_providers=crcat.authorized_providers,
                         proofs_checker=ProofsChecker.from_program(uncurry_puzzle(crcat.proofs_checker)),
                     )
@@ -1218,20 +1223,20 @@ class WalletStateManager:
                     cat_wallet = await RCATWallet.get_or_create_wallet_for_cat(
                         self,
                         self.main_wallet,
-                        parent_data.tail_program_hash.hex(),
+                        parent_data.tail_program_hash,
                         # too complicated for mypy but semantics guarantee this not to be None
                         hidden_puzzle_hash=revocation_layer_match[0],  # type: ignore[index]
                     )
                 else:
                     cat_wallet = await CATWallet.get_or_create_wallet_for_cat(
-                        self, self.main_wallet, parent_data.tail_program_hash.hex()
+                        self, self.main_wallet, parent_data.tail_program_hash
                     )
                 return WalletIdentifier.create(cat_wallet)
             else:
                 # Found unacknowledged CAT, save it in the database.
                 await self.interested_store.add_unacknowledged_token(
                     asset_id,
-                    CATWallet.default_wallet_name_for_unknown_cat(asset_id.hex()),
+                    CATWallet.default_wallet_name_for_unknown_cat(asset_id),
                     None if parent_coin_state.spent_height is None else uint32(parent_coin_state.spent_height),
                     parent_coin_state.coin.puzzle_hash,
                 )
@@ -1250,7 +1255,7 @@ class WalletStateManager:
         coin_state: CoinState,
         coin_spend: CoinSpend,
         peer: WSChiaConnection,
-    ) -> Optional[WalletIdentifier]:
+    ) -> WalletIdentifier | None:
         """
         Handle the new coin when it is a DID
         :param parent_data: Curried data of the DID coin
@@ -1309,7 +1314,7 @@ class WalletStateManager:
             )
             alt_did_puzzle_empty_recovery = DID_INNERPUZ_MOD.curry(
                 our_inner_puzzle,
-                NIL,
+                Program.NIL,
                 uint64(0),
                 parent_data.singleton_struct,
                 parent_data.metadata,
@@ -1367,12 +1372,12 @@ class WalletStateManager:
             )
             return None
 
-    async def get_minter_did(self, launcher_coin: Coin, peer: WSChiaConnection) -> Optional[bytes32]:
+    async def get_minter_did(self, launcher_coin: Coin, peer: WSChiaConnection) -> bytes32 | None:
         # Get minter DID
         eve_coin = (await self.wallet_node.fetch_children(launcher_coin.name(), peer=peer))[0]
         eve_coin_spend = await fetch_coin_spend_for_coin_state(eve_coin, peer)
         eve_full_puzzle: Program = Program.from_bytes(bytes(eve_coin_spend.puzzle_reveal))
-        eve_uncurried_nft: Optional[UncurriedNFT] = UncurriedNFT.uncurry(*eve_full_puzzle.uncurry())
+        eve_uncurried_nft: UncurriedNFT | None = UncurriedNFT.uncurry(*eve_full_puzzle.uncurry())
         if eve_uncurried_nft is None:
             raise ValueError("Couldn't get minter DID for NFT")
         if not eve_uncurried_nft.supports_did:
@@ -1410,7 +1415,7 @@ class WalletStateManager:
     async def handle_nft(
         self,
         nft_data: NFTCoinData,
-    ) -> Optional[WalletIdentifier]:
+    ) -> WalletIdentifier | None:
         """
         Handle the new coin when it is a NFT
         :param nft_data: all necessary data to process a NFT coin
@@ -1418,7 +1423,7 @@ class WalletStateManager:
         """
         wallet_identifier = None
         # DID ID determines which NFT wallet should process the NFT
-        new_did_id: Optional[bytes32] = None
+        new_did_id: bytes32 | None = None
         old_did_id = None
         # P2 puzzle hash determines if we should ignore the NFT
         uncurried_nft: UncurriedNFT = nft_data.uncurried_nft
@@ -1446,12 +1451,12 @@ class WalletStateManager:
             old_p2_puzhash,
             new_p2_puzhash,
         )
-        new_derivation_record: Optional[
-            DerivationRecord
-        ] = await self.puzzle_store.get_derivation_record_for_puzzle_hash(new_p2_puzhash)
-        old_derivation_record: Optional[
-            DerivationRecord
-        ] = await self.puzzle_store.get_derivation_record_for_puzzle_hash(old_p2_puzhash)
+        new_derivation_record: DerivationRecord | None = await self.puzzle_store.get_derivation_record_for_puzzle_hash(
+            new_p2_puzhash
+        )
+        old_derivation_record: DerivationRecord | None = await self.puzzle_store.get_derivation_record_for_puzzle_hash(
+            old_p2_puzhash
+        )
         if new_derivation_record is None and old_derivation_record is None:
             self.log.debug(
                 "Cannot find a P2 puzzle hash for NFT:%s, this NFT belongs to others.",
@@ -1511,7 +1516,7 @@ class WalletStateManager:
         coin_state: CoinState,
         coin_spend: CoinSpend,
         peer: WSChiaConnection,
-    ) -> Optional[WalletIdentifier]:
+    ) -> WalletIdentifier | None:
         """
         Handle Clawback coins
         :param metadata: Clawback metadata for spending the merkle coin
@@ -1522,11 +1527,11 @@ class WalletStateManager:
         """
         # Record metadata
         assert coin_state.created_height is not None
-        is_recipient: Optional[bool] = None
+        is_recipient: bool | None = None
         # Check if the wallet is the sender
-        sender_derivation_record: Optional[
-            DerivationRecord
-        ] = await self.puzzle_store.get_derivation_record_for_puzzle_hash(metadata.sender_puzzle_hash)
+        sender_derivation_record: (
+            DerivationRecord | None
+        ) = await self.puzzle_store.get_derivation_record_for_puzzle_hash(metadata.sender_puzzle_hash)
         # Check if the wallet is the recipient
         recipient_derivation_record = await self.puzzle_store.get_derivation_record_for_puzzle_hash(
             metadata.recipient_puzzle_hash
@@ -1623,9 +1628,9 @@ class WalletStateManager:
             await self.tx_store.add_transaction_record(tx_record)
         return None
 
-    async def handle_vc(self, vc: VerifiedCredential) -> Optional[WalletIdentifier]:
+    async def handle_vc(self, vc: VerifiedCredential) -> WalletIdentifier | None:
         # Check the ownership
-        derivation_record: Optional[DerivationRecord] = await self.puzzle_store.get_derivation_record_for_puzzle_hash(
+        derivation_record: DerivationRecord | None = await self.puzzle_store.get_derivation_record_for_puzzle_hash(
             vc.inner_puzzle_hash
         )
         if derivation_record is None:
@@ -1644,7 +1649,7 @@ class WalletStateManager:
         self,
         coin_states: list[CoinState],
         peer: WSChiaConnection,
-        fork_height: Optional[uint32],
+        fork_height: uint32 | None,
     ) -> None:
         # TODO: add comment about what this method does
         # Input states should already be sorted by cs_height, with reorgs at the beginning
@@ -1676,7 +1681,7 @@ class WalletStateManager:
                     await self.retry_store.remove_state(coin_state)
 
                     wallet_identifier = await self.get_wallet_identifier_for_puzzle_hash(coin_state.coin.puzzle_hash)
-                    coin_data: Optional[Streamable] = None
+                    coin_data: Streamable | None = None
                     # If we already have this coin, & it was spent & confirmed at the same heights, then return (done)
                     if local_record is not None:
                         local_spent = None
@@ -1781,7 +1786,7 @@ class WalletStateManager:
                             )
                             await self.coin_store.add_coin_record(record)
                             # Coin first received
-                            parent_coin_record: Optional[WalletCoinRecord] = await self.coin_store.get_coin_record(
+                            parent_coin_record: WalletCoinRecord | None = await self.coin_store.get_coin_record(
                                 coin_state.coin.parent_coin_info
                             )
                             if (
@@ -1826,8 +1831,8 @@ class WalletStateManager:
                                 fee = 0
 
                                 to_puzzle_hash = None
-                                coin_spend: Optional[CoinSpend] = None
-                                clawback_metadata: Optional[ClawbackMetadata] = None
+                                coin_spend: CoinSpend | None = None
+                                clawback_metadata: ClawbackMetadata | None = None
                                 # Find coin that doesn't belong to us
                                 amount = 0
                                 for coin in additions:
@@ -2072,7 +2077,7 @@ class WalletStateManager:
         self,
         coin_states: list[CoinState],
         peer: WSChiaConnection,
-        fork_height: Optional[uint32],
+        fork_height: uint32 | None,
     ) -> bool:
         try:
             await self._add_coin_states(coin_states, peer, fork_height)
@@ -2122,7 +2127,7 @@ class WalletStateManager:
                 return True
         return False
 
-    async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
+    async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> WalletIdentifier | None:
         wallet_identifier = await self.puzzle_store.get_wallet_identifier_for_puzzle_hash(puzzle_hash)
         if wallet_identifier is not None:
             return wallet_identifier
@@ -2138,7 +2143,7 @@ class WalletStateManager:
 
     async def get_wallet_identifier_for_coin(
         self, coin: Coin, hint_dict: dict[bytes32, bytes32] = {}
-    ) -> Optional[WalletIdentifier]:
+    ) -> WalletIdentifier | None:
         wallet_identifier = await self.puzzle_store.get_wallet_identifier_for_puzzle_hash(coin.puzzle_hash)
         if (
             wallet_identifier is None
@@ -2153,7 +2158,7 @@ class WalletStateManager:
 
         return wallet_identifier
 
-    async def get_wallet_identifier_for_hinted_coin(self, coin: Coin, hint: bytes32) -> Optional[WalletIdentifier]:
+    async def get_wallet_identifier_for_hinted_coin(self, coin: Coin, hint: bytes32) -> WalletIdentifier | None:
         for wallet in self.wallets.values():
             if await wallet.match_hinted_coin(coin, hint):
                 return WalletIdentifier(wallet.id(), wallet.type())
@@ -2168,7 +2173,7 @@ class WalletStateManager:
         wallet_type: WalletType,
         peer: WSChiaConnection,
         coin_name: bytes32,
-        coin_data: Optional[Streamable],
+        coin_data: object | None,
     ) -> None:
         """
         Adding coin to DB
@@ -2198,7 +2203,7 @@ class WalletStateManager:
                     coin_confirmed_transaction = True
                     break
 
-        parent_coin_record: Optional[WalletCoinRecord] = await self.coin_store.get_coin_record(coin.parent_coin_info)
+        parent_coin_record: WalletCoinRecord | None = await self.coin_store.get_coin_record(coin.parent_coin_info)
         change = parent_coin_record is not None and wallet_type.value == parent_coin_record.wallet_type
         # If the coin is from a Clawback spent, we want to add the INCOMING_TX,
         # no matter if there is another TX updated.
@@ -2246,9 +2251,9 @@ class WalletStateManager:
         tx_records: list[TransactionRecord],
         push: bool = True,
         merge_spends: bool = True,
-        sign: Optional[bool] = None,
-        additional_signing_responses: Optional[list[SigningResponse]] = None,
-        extra_spends: Optional[list[WalletSpendBundle]] = None,
+        sign: bool | None = None,
+        additional_signing_responses: list[SigningResponse] | None = None,
+        extra_spends: list[WalletSpendBundle] | None = None,
         singleton_records: list[SingletonRecord] = [],
     ) -> list[TransactionRecord]:
         """
@@ -2321,7 +2326,7 @@ class WalletStateManager:
         spendbundle_id: bytes32,
         name: str,
         send_status: MempoolInclusionStatus,
-        error: Optional[Err],
+        error: Err | None,
     ) -> None:
         """
         Full node received our transaction, no need to keep it in queue anymore, unless there was an error
@@ -2329,7 +2334,7 @@ class WalletStateManager:
 
         updated = await self.tx_store.increment_sent(spendbundle_id, name, send_status, error)
         if updated:
-            tx: Optional[TransactionRecord] = await self.get_transaction(spendbundle_id)
+            tx: TransactionRecord | None = await self.get_transaction(spendbundle_id)
             if tx is not None and tx.spend_bundle is not None:
                 self.log.info("Checking if we need to cancel trade for tx: %s", tx.name)
                 # we're only interested in errors that are not temporary
@@ -2385,7 +2390,7 @@ class WalletStateManager:
         records = await self.tx_store.get_all_transactions_for_wallet(wallet_id)
         return records
 
-    async def get_transaction(self, tx_id: bytes32) -> Optional[TransactionRecord]:
+    async def get_transaction(self, tx_id: bytes32) -> TransactionRecord | None:
         return await self.tx_store.get_transaction_record(tx_id)
 
     async def get_coin_record_by_wallet_record(self, wr: WalletCoinRecord) -> CoinRecord:
@@ -2396,7 +2401,7 @@ class WalletStateManager:
         result = await self.coin_store.get_coin_records(**kwargs)
         return [await self.get_coin_record_by_wallet_record(record) for record in result.records]
 
-    async def get_wallet_for_coin(self, coin_id: bytes32) -> Optional[WalletProtocol[Any]]:
+    async def get_wallet_for_coin(self, coin_id: bytes32) -> WalletProtocol[Any] | None:
         coin_record = await self.coin_store.get_coin_record(coin_id)
         if coin_record is None:
             return None
@@ -2448,10 +2453,10 @@ class WalletStateManager:
     def unlink_db(self) -> None:
         Path(self.db_path).unlink()
 
-    async def get_all_wallet_info_entries(self, wallet_type: Optional[WalletType] = None) -> list[WalletInfo]:
+    async def get_all_wallet_info_entries(self, wallet_type: WalletType | None = None) -> list[WalletInfo]:
         return await self.user_store.get_all_wallet_info_entries(wallet_type)
 
-    async def get_wallet_for_asset_id(self, asset_id: str) -> Optional[WalletProtocol[Any]]:
+    async def get_wallet_for_asset_id(self, asset_id: bytes32) -> WalletProtocol[Any] | None:
         for wallet_id, wallet in self.wallets.items():
             if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
                 assert isinstance(wallet, CATWallet)
@@ -2459,16 +2464,16 @@ class WalletStateManager:
                     return wallet
             elif wallet.type() == WalletType.DATA_LAYER:
                 assert isinstance(wallet, DataLayerWallet)
-                if await wallet.get_latest_singleton(bytes32.from_hexstr(asset_id)) is not None:
+                if await wallet.get_latest_singleton(asset_id) is not None:
                     return wallet
             elif wallet.type() == WalletType.NFT:
                 assert isinstance(wallet, NFTWallet)
-                nft_coin = await self.nft_store.get_nft_by_id(bytes32.from_hexstr(asset_id), wallet_id)
+                nft_coin = await self.nft_store.get_nft_by_id(asset_id, wallet_id)
                 if nft_coin:
                     return wallet
         return None
 
-    async def get_wallet_for_puzzle_info(self, puzzle_driver: PuzzleInfo) -> Optional[WalletProtocol[Any]]:
+    async def get_wallet_for_puzzle_info(self, puzzle_driver: PuzzleInfo) -> WalletProtocol[Any] | None:
         for wallet in self.wallets.values():
             match_function = getattr(wallet, "match_puzzle_info", None)
             if match_function is not None and callable(match_function):
@@ -2476,7 +2481,7 @@ class WalletStateManager:
                     return wallet
         return None
 
-    async def create_wallet_for_puzzle_info(self, puzzle_driver: PuzzleInfo, name: Optional[str] = None) -> None:
+    async def create_wallet_for_puzzle_info(self, puzzle_driver: PuzzleInfo, name: str | None = None) -> None:
         if AssetType(puzzle_driver.type()) in self.asset_to_wallet_map:
             await self.asset_to_wallet_map[AssetType(puzzle_driver.type())].create_from_puzzle_info(
                 self,
@@ -2495,10 +2500,29 @@ class WalletStateManager:
         await result.commit(self)
         self.state_changed("wallet_created")
 
+    async def unconfirmed_additions_or_removals_for_wallet(
+        self, *, wallet_id: uint32, get: Literal["additions", "removals"]
+    ) -> set[Coin]:
+        unconfirmed_tx: list[TransactionRecord] = await self.tx_store.get_unconfirmed_for_wallet(wallet_id)
+        return_set: set[Coin] = set()
+        for tx in unconfirmed_tx:
+            hint_dict = tx.hint_dict()
+            checked_set = tx.removals if get == "removals" else tx.additions
+            for coin in checked_set:
+                if await self.does_coin_belong_to_wallet(coin, wallet_id, hint_dict):
+                    return_set.add(coin)
+
+        return return_set
+
     async def get_spendable_coins_for_wallet(
-        self, wallet_id: int, records: Optional[set[WalletCoinRecord]] = None
+        self,
+        wallet_id: int,
+        records: set[WalletCoinRecord] | None = None,
+        pending_removals: set[bytes32] | None = None,
+        in_one_block: bool = False,
     ) -> set[WalletCoinRecord]:
-        wallet_type = self.wallets[uint32(wallet_id)].type()
+        wallet = self.wallets[uint32(wallet_id)]
+        wallet_type = wallet.type()
         if records is None:
             if wallet_type == WalletType.CRCAT:
                 records = await self.coin_store.get_unspent_coins_for_wallet(wallet_id, CoinType.CRCAT)
@@ -2506,25 +2530,30 @@ class WalletStateManager:
                 records = await self.coin_store.get_unspent_coins_for_wallet(wallet_id)
 
         # Coins that are currently part of a transaction
-        unconfirmed_tx: list[TransactionRecord] = await self.tx_store.get_unconfirmed_for_wallet(wallet_id)
-        removal_dict: dict[bytes32, Coin] = {}
-        for tx in unconfirmed_tx:
-            for coin in tx.removals:
-                # TODO, "if" might not be necessary once unconfirmed tx doesn't contain coins for other wallets
-                if await self.does_coin_belong_to_wallet(coin, wallet_id, tx.hint_dict()):
-                    removal_dict[coin.name()] = coin
+        if pending_removals is None:
+            pending_removals = {
+                coin.name()
+                for coin in await self.unconfirmed_additions_or_removals_for_wallet(
+                    wallet_id=uint32(wallet_id), get="removals"
+                )
+            }
 
         # Coins that are part of the trade
         offer_locked_coins: dict[bytes32, WalletCoinRecord] = await self.trade_manager.get_locked_coins()
 
         filtered = set()
         for record in records:
-            if record.coin.name() in offer_locked_coins:
+            if record.coin.name() in {*offer_locked_coins.keys(), *pending_removals}:
                 continue
-            if record.coin.name() in removal_dict:
+            if hasattr(wallet, "is_coin_spendable") and not await wallet.is_coin_spendable(record):
                 continue
             filtered.add(record)
 
+        if hasattr(wallet, "max_send_quantity") and in_one_block:
+            filtered_as_list = list(filtered)
+            filtered_as_list.sort(reverse=True, key=lambda rec: rec.coin.amount)
+            return set(filtered_as_list[0 : min(len(filtered_as_list), wallet.max_send_quantity)])
+
         return filtered
 
     async def new_peak(self, height: uint32) -> None:
@@ -2601,10 +2630,10 @@ class WalletStateManager:
 
         return vc_wallet
 
-    async def sum_hint_for_pubkey(self, pk: bytes) -> Optional[SumHint]:
+    async def sum_hint_for_pubkey(self, pk: bytes) -> SumHint | None:
         return await self.main_wallet.sum_hint_for_pubkey(pk)
 
-    async def path_hint_for_pubkey(self, pk: bytes) -> Optional[PathHint]:
+    async def path_hint_for_pubkey(self, pk: bytes) -> PathHint | None:
         return await self.main_wallet.path_hint_for_pubkey(pk)
 
     async def key_hints_for_pubkeys(self, pks: list[bytes]) -> KeyHints:
@@ -2757,10 +2786,10 @@ class WalletStateManager:
         tx_config: TXConfig,
         push: bool = False,
         merge_spends: bool = True,
-        sign: Optional[bool] = None,
+        sign: bool | None = None,
         additional_signing_responses: list[SigningResponse] = [],
         extra_spends: list[WalletSpendBundle] = [],
-        puzzle_for_pk: Optional[Callable[[G1Element], Program]] = None,
+        puzzle_for_pk: Callable[[G1Element], Program] | None = None,
     ) -> AsyncIterator[WalletActionScope]:
         async with new_wallet_action_scope(
             self,
@@ -2780,3 +2809,200 @@ class WalletStateManager:
 
     def encode_puzzle_hash(self, puzzle_hash: bytes32) -> str:
         return encode_puzzle_hash(puzzle_hash, AddressType.XCH.hrp(self.config))
+
+    def new_outgoing_transaction(
+        self,
+        *,
+        wallet_id: uint32,
+        puzzle_hash: bytes32,
+        amount: uint64,
+        fee: uint64,
+        spend_bundle: WalletSpendBundle,
+        additions: list[Coin],
+        removals: list[Coin],
+        name: bytes32,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+        trade_id: bytes32 | None = None,
+    ) -> TransactionRecord:
+        return TransactionRecord(
+            confirmed_at_height=uint32(0),
+            created_at_time=uint64(time.time()),
+            to_puzzle_hash=puzzle_hash,
+            to_address=self.encode_puzzle_hash(puzzle_hash),
+            amount=amount,
+            fee_amount=fee,
+            confirmed=False,
+            sent=uint32(0),
+            spend_bundle=spend_bundle,
+            additions=additions,
+            removals=removals,
+            wallet_id=wallet_id,
+            sent_to=[],
+            trade_id=trade_id,
+            type=uint32(TransactionType.OUTGOING_TX.value),
+            name=name,
+            memos=compute_memos(spend_bundle),
+            valid_times=parse_timelock_info(extra_conditions),
+        )
+
+    async def split_coins(
+        self,
+        *,
+        action_scope: WalletActionScope,
+        wallet_id: uint32,
+        target_coin_id: bytes32,
+        amount_per_coin: uint64,
+        number_of_coins: uint16,
+        fee: uint64,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> None:
+        optional_coin = await self.coin_store.get_coin_record(target_coin_id)
+        if optional_coin is None:
+            raise ValueError(f"Could not find coin with ID {target_coin_id}")
+        else:
+            coin = optional_coin.coin
+
+        total_amount = amount_per_coin * number_of_coins
+
+        if coin.amount < total_amount:
+            raise ValueError(f"Coin amount: {coin.amount} is less than the total amount of the split: {total_amount}.")
+
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet with ID {wallet_id} does not exist")
+        wallet = self.wallets[wallet_id]
+        if not isinstance(wallet, (Wallet, CATWallet)):
+            raise ValueError("Cannot split coins from non-fungible wallet types")
+
+        outputs = [
+            CreateCoin(
+                await action_scope.get_puzzle_hash(self, override_reuse_puzhash_with=False),
+                amount_per_coin,
+            )
+            for _ in range(number_of_coins)
+        ]
+
+        if wallet.type() == WalletType.STANDARD_WALLET and coin.amount < total_amount + fee:
+            async with action_scope.use() as interface:
+                interface.side_effects.selected_coins.append(coin)
+            coins = await wallet.select_coins(
+                uint64(total_amount + fee - coin.amount),
+                action_scope,
+            )
+            coins.add(coin)
+        else:
+            coins = {coin}
+
+        await wallet.generate_signed_transaction(
+            [output.amount for output in outputs],
+            [output.puzzle_hash for output in outputs],
+            action_scope,
+            fee,
+            coins=coins,
+            extra_conditions=extra_conditions,
+        )
+
+    async def combine_coins(
+        self,
+        *,
+        action_scope: WalletActionScope,
+        wallet_id: uint32,
+        number_of_coins: uint16,
+        largest_first: bool,
+        coin_num_limit: uint16,
+        fee: uint64,
+        target_coin_amount: uint64 | None = None,
+        target_coin_ids: list[bytes32] | None = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> None:
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet with ID {wallet_id} does not exist")
+        wallet = self.wallets[wallet_id]
+        if not isinstance(wallet, (Wallet, CATWallet)):
+            raise ValueError("Cannot combine coins from non-fungible wallet types")
+
+        coins: list[Coin] = []
+
+        # First get the coin IDs specified
+        if target_coin_ids is not None:
+            coins.extend(
+                cr.coin
+                for cr in (
+                    await self.coin_store.get_coin_records(
+                        wallet_id=wallet_id,
+                        coin_id_filter=HashFilter(target_coin_ids, mode=uint8(FilterMode.include.value)),
+                    )
+                ).records
+            )
+
+        async with action_scope.use() as interface:
+            interface.side_effects.selected_coins.extend(coins)
+
+        # Next let's select enough coins to meet the target + fee if there is one
+        fungible_amount_needed = uint64(0) if target_coin_amount is None else target_coin_amount
+        if isinstance(wallet, Wallet):
+            fungible_amount_needed = uint64(fungible_amount_needed + fee)
+        amount_selected = sum(c.amount for c in coins)
+        if amount_selected < fungible_amount_needed:  # implicit fungible_amount_needed > 0 here
+            coins.extend(
+                await wallet.select_coins(
+                    amount=uint64(fungible_amount_needed - amount_selected), action_scope=action_scope
+                )
+            )
+
+        if len(coins) > number_of_coins:
+            raise ValueError(
+                f"Options specified cannot be met without selecting more coins than specified: {len(coins)}"
+            )
+
+        # Now let's select enough coins to get to the target number to combine
+        if len(coins) < number_of_coins:
+            async with action_scope.use() as interface:
+                coins.extend(
+                    cr.coin
+                    for cr in (
+                        await self.coin_store.get_coin_records(
+                            wallet_id=wallet_id,
+                            limit=uint32(number_of_coins - len(coins)),
+                            order=CoinRecordOrder.amount,
+                            coin_id_filter=HashFilter(
+                                [c.name() for c in interface.side_effects.selected_coins],
+                                mode=uint8(FilterMode.exclude.value),
+                            ),
+                            reverse=largest_first,
+                        )
+                    ).records
+                )
+
+        async with action_scope.use() as interface:
+            interface.side_effects.selected_coins.extend(coins)
+
+        primary_output_amount = (
+            uint64(sum(c.amount for c in coins)) if target_coin_amount is None else target_coin_amount
+        )
+        if isinstance(wallet, Wallet):
+            primary_output_amount = uint64(primary_output_amount - fee)
+
+        await wallet.generate_signed_transaction(
+            [primary_output_amount],
+            [await action_scope.get_puzzle_hash(self)],
+            action_scope,
+            fee,
+            coins=set(coins),
+            extra_conditions=extra_conditions,
+        )
+
+    def new_pool_wallet_pubkey(self) -> G1Element:
+        # We assign a pseudo unique id to each pool wallet, so that each one gets its own deterministic
+        # owner and auth keys. The public keys will go on the blockchain, and the private keys can be found
+        # using the root SK and trying each index from zero. The indexes are not fully unique though,
+        # because the PoolWallet is not created until the tx gets confirmed on chain. Therefore if we
+        # make multiple pool wallets at the same time, they will have the same ID.
+        max_pwi = 1
+        for _, wallet in self.wallets.items():
+            if wallet.type() == WalletType.POOLING_WALLET:
+                max_pwi += 1
+
+        if max_pwi + 1 >= (MAX_POOL_WALLETS - 1):
+            raise ValueError(f"Too many pool wallets ({max_pwi}), cannot create any more on this key.")
+
+        return master_sk_to_singleton_owner_sk(self.get_master_private_key(), uint32(max_pwi)).get_g1()