chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/wallet/trade_manager.py

@@ -4,7 +4,7 @@ import dataclasses
 import logging
 import time
 from collections import deque
-from typing import TYPE_CHECKING, Any, Deque, Dict, List, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from typing_extensions import Literal
 
@@ -72,20 +72,20 @@ class TradeManager:
                 {
                     "coin": bytes
                     "parent_spend": bytes
-                    "siblings": List[bytes]  # other coins of the same type being offered
-                    "sibling_spends": List[bytes]  # The parent spends for the siblings
-                    "sibling_puzzles": List[Program]  # The inner puzzles of the siblings (always OFFER_MOD)
-                    "sibling_solutions": List[Program]  # The inner solution of the siblings
+                    "siblings": list[bytes]  # other coins of the same type being offered
+                    "sibling_spends": list[bytes]  # The parent spends for the siblings
+                    "sibling_puzzles": list[Program]  # The inner puzzles of the siblings (always OFFER_MOD)
+                    "sibling_solutions": list[Program]  # The inner solution of the siblings
             }
             )
 
     Wallet:
       - Segments in this code that call general wallet methods are highlighted by comments: # ATTENTION: new wallets
       - To be able to be traded, a wallet must implement these methods on itself:
-        - generate_signed_transaction(...) -> List[TransactionRecord]  (See cat_wallet.py for full API)
+        - generate_signed_transaction(...) -> list[TransactionRecord]  (See cat_wallet.py for full API)
         - convert_puzzle_hash(puzzle_hash: bytes32) -> bytes32  # Converts a puzzlehash from outer to inner puzzle
         - get_puzzle_info(asset_id: bytes32) -> PuzzleInfo
-        - get_coins_to_offer(asset_id: bytes32, amount: uint64) -> Set[Coin]
+        - get_coins_to_offer(asset_id: bytes32, amount: uint64) -> set[Coin]
       - If you would like assets from your wallet to be referenced with just a wallet ID, you must also implement:
         - get_asset_id() -> bytes32
       - Finally, you must make sure that your wallet will respond appropriately when these WSM methods are called:
@@ -97,7 +97,7 @@ class TradeManager:
     wallet_state_manager: WalletStateManager
     log: logging.Logger
     trade_store: TradeStore
-    most_recently_deserialized_trade: Optional[Tuple[bytes32, Offer]]
+    most_recently_deserialized_trade: Optional[tuple[bytes32, Offer]]
 
     @staticmethod
     async def create(
@@ -116,13 +116,13 @@ class TradeManager:
         self.most_recently_deserialized_trade = None
         return self
 
-    async def get_offers_with_status(self, status: TradeStatus) -> List[TradeRecord]:
+    async def get_offers_with_status(self, status: TradeStatus) -> list[TradeRecord]:
         records = await self.trade_store.get_trade_record_with_status(status)
         return records
 
     async def get_coins_of_interest(
         self,
-    ) -> Set[bytes32]:
+    ) -> set[bytes32]:
         """
         Returns list of coins we want to check if they are included in filter,
         These will include coins that belong to us and coins that that on other side of treade
@@ -132,14 +132,15 @@ class TradeManager:
         )
         return coin_ids
 
-    async def get_trade_by_coin(self, coin: Coin) -> Optional[TradeRecord]:
+    async def get_trades_by_coin(self, coin: Coin) -> list[TradeRecord]:
         all_trades = await self.get_all_trades()
+        trades_by_coin = []
         for trade in all_trades:
             if trade.status == TradeStatus.CANCELLED.value:
                 continue
             if coin in trade.coins_of_interest:
-                return trade
-        return None
+                trades_by_coin.append(trade)
+        return trades_by_coin
 
     async def coins_of_interest_farmed(
         self, coin_state: CoinState, fork_height: Optional[uint32], peer: WSChiaConnection
@@ -151,64 +152,65 @@ class TradeManager:
         If our coins got farmed but coins from other side didn't, we successfully canceled trade by spending inputs.
         """
         self.log.info(f"coins_of_interest_farmed: {coin_state}")
-        trade = await self.get_trade_by_coin(coin_state.coin)
-        if trade is None:
-            self.log.error(f"Coin: {coin_state.coin}, not in any trade")
-            return
-        if coin_state.spent_height is None:
-            self.log.error(f"Coin: {coin_state.coin}, has not been spent so trade can remain valid")
-        # Then let's filter the offer into coins that WE offered
-        if (
-            self.most_recently_deserialized_trade is not None
-            and trade.trade_id == self.most_recently_deserialized_trade[0]
-        ):
-            offer = self.most_recently_deserialized_trade[1]
-        else:
-            offer = Offer.from_bytes(trade.offer)
-            self.most_recently_deserialized_trade = (trade.trade_id, offer)
-        primary_coin_ids = [c.name() for c in offer.removals()]
-        # TODO: Add `WalletCoinStore.get_coins`.
-        result = await self.wallet_state_manager.coin_store.get_coin_records(
-            coin_id_filter=HashFilter.include(primary_coin_ids)
-        )
-        our_primary_coins: List[Coin] = [cr.coin for cr in result.records]
-        our_additions: List[Coin] = list(
-            filter(lambda c: offer.get_root_removal(c) in our_primary_coins, offer.additions())
-        )
-        our_addition_ids: List[bytes32] = [c.name() for c in our_additions]
-
-        # And get all relevant coin states
-        coin_states = await self.wallet_state_manager.wallet_node.get_coin_state(
-            our_addition_ids,
-            peer=peer,
-            fork_height=fork_height,
-        )
-        assert coin_states is not None
-        coin_state_names: List[bytes32] = [cs.coin.name() for cs in coin_states]
-        # If any of our settlement_payments were spent, this offer was a success!
-        if set(our_addition_ids) == set(coin_state_names):
-            height = coin_state.spent_height
-            assert height is not None
-            await self.trade_store.set_status(trade.trade_id, TradeStatus.CONFIRMED, index=height)
-            tx_records: List[TransactionRecord] = await self.calculate_tx_records_for_offer(offer, False)
-            for tx in tx_records:
-                if TradeStatus(trade.status) == TradeStatus.PENDING_ACCEPT:
-                    await self.wallet_state_manager.add_transaction(
-                        dataclasses.replace(tx, confirmed_at_height=height, confirmed=True)
-                    )
+        trades = await self.get_trades_by_coin(coin_state.coin)
+        for trade in trades:
+            if trade is None:
+                self.log.error(f"Coin: {coin_state.coin}, not in any trade")
+                continue
+            if coin_state.spent_height is None:
+                self.log.error(f"Coin: {coin_state.coin}, has not been spent so trade can remain valid")
+            # Then let's filter the offer into coins that WE offered
+            if (
+                self.most_recently_deserialized_trade is not None
+                and trade.trade_id == self.most_recently_deserialized_trade[0]
+            ):
+                offer = self.most_recently_deserialized_trade[1]
+            else:
+                offer = Offer.from_bytes(trade.offer)
+                self.most_recently_deserialized_trade = (trade.trade_id, offer)
+            primary_coin_ids = [c.name() for c in offer.removals()]
+            # TODO: Add `WalletCoinStore.get_coins`.
+            result = await self.wallet_state_manager.coin_store.get_coin_records(
+                coin_id_filter=HashFilter.include(primary_coin_ids)
+            )
+            our_primary_coins: list[Coin] = [cr.coin for cr in result.records]
+            our_additions: list[Coin] = list(
+                filter(lambda c: offer.get_root_removal(c) in our_primary_coins, offer.additions())
+            )
+            our_addition_ids: list[bytes32] = [c.name() for c in our_additions]
 
-            self.log.info(f"Trade with id: {trade.trade_id} confirmed at height: {height}")
-        else:
-            # In any other scenario this trade failed
-            await self.wallet_state_manager.delete_trade_transactions(trade.trade_id)
-            if trade.status == TradeStatus.PENDING_CANCEL.value:
-                await self.trade_store.set_status(trade.trade_id, TradeStatus.CANCELLED)
-                self.log.info(f"Trade with id: {trade.trade_id} canceled")
-            elif trade.status == TradeStatus.PENDING_CONFIRM.value:
-                await self.trade_store.set_status(trade.trade_id, TradeStatus.FAILED)
-                self.log.warning(f"Trade with id: {trade.trade_id} failed")
+            # And get all relevant coin states
+            coin_states = await self.wallet_state_manager.wallet_node.get_coin_state(
+                our_addition_ids,
+                peer=peer,
+                fork_height=fork_height,
+            )
+            assert coin_states is not None
+            coin_state_names: list[bytes32] = [cs.coin.name() for cs in coin_states]
+            # If any of our settlement_payments were spent, this offer was a success!
+            if set(our_addition_ids) == set(coin_state_names):
+                height = coin_state.spent_height
+                assert height is not None
+                await self.trade_store.set_status(trade.trade_id, TradeStatus.CONFIRMED, index=height)
+                tx_records: list[TransactionRecord] = await self.calculate_tx_records_for_offer(offer, False)
+                for tx in tx_records:
+                    if TradeStatus(trade.status) == TradeStatus.PENDING_ACCEPT:
+                        await self.wallet_state_manager.add_transaction(
+                            dataclasses.replace(tx, confirmed_at_height=height, confirmed=True)
+                        )
 
-    async def get_locked_coins(self) -> Dict[bytes32, WalletCoinRecord]:
+                self.log.info(f"Trade with id: {trade.trade_id} confirmed at height: {height}")
+            else:
+                # In any other scenario this trade failed
+                await self.wallet_state_manager.delete_trade_transactions(trade.trade_id)
+                if trade.status == TradeStatus.PENDING_CANCEL.value:
+                    await self.trade_store.set_status(trade.trade_id, TradeStatus.CANCELLED)
+                    self.log.info(f"Trade with id: {trade.trade_id} canceled")
+                elif trade.status == TradeStatus.PENDING_CONFIRM.value:
+                    await self.trade_store.set_status(trade.trade_id, TradeStatus.FAILED)
+                    self.log.warning(f"Trade with id: {trade.trade_id} failed")
+
+    async def get_locked_coins(self) -> dict[bytes32, WalletCoinRecord]:
         """Returns a dictionary of confirmed coins that are locked by a trade."""
         all_pending = []
         pending_accept = await self.get_offers_with_status(TradeStatus.PENDING_ACCEPT)
@@ -230,8 +232,8 @@ class TradeManager:
             )
         ).coin_id_to_record
 
-    async def get_all_trades(self) -> List[TradeRecord]:
-        all: List[TradeRecord] = await self.trade_store.get_all_trades()
+    async def get_all_trades(self) -> list[TradeRecord]:
+        all: list[TradeRecord] = await self.trade_store.get_all_trades()
         return all
 
     async def get_trade_by_id(self, trade_id: bytes32) -> Optional[TradeRecord]:
@@ -244,22 +246,22 @@ class TradeManager:
 
     async def cancel_pending_offers(
         self,
-        trades: List[bytes32],
+        trade_ids: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         secure: bool = True,  # Cancel with a transaction on chain
-        trade_cache: Dict[bytes32, TradeRecord] = {},  # Optional pre-fetched trade records for optimization
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        trade_cache: dict[bytes32, TradeRecord] = {},  # Optional pre-fetched trade records for optimization
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         """This will create a transaction that includes coins that were offered"""
 
         # Need to do some pre-figuring of announcements that will be need to be made
-        announcement_nonce: bytes32 = std_hash(b"".join(trades))
-        trade_records: List[TradeRecord] = []
-        all_cancellation_coins: List[List[Coin]] = []
-        announcement_creations: Deque[CreateCoinAnnouncement] = deque()
-        announcement_assertions: Deque[AssertCoinAnnouncement] = deque()
-        for trade_id in trades:
+        announcement_nonce: bytes32 = std_hash(b"".join(trade_ids))
+        trade_records: list[TradeRecord] = []
+        all_cancellation_coins: list[list[Coin]] = []
+        announcement_creations: deque[CreateCoinAnnouncement] = deque()
+        announcement_assertions: deque[AssertCoinAnnouncement] = deque()
+        for trade_id in trade_ids:
             if trade_id in trade_cache:
                 trade = trade_cache[trade_id]
             else:
@@ -282,7 +284,7 @@ class TradeManager:
         # Make every coin assert the announcement from the one before them
         announcement_assertions.rotate(1)
 
-        all_txs: List[TransactionRecord] = []
+        all_txs: list[TransactionRecord] = []
         fee_to_pay: uint64 = fee
         for trade, cancellation_coins in zip(trade_records, all_cancellation_coins):
             self.log.info(f"Secure-Cancel pending offer with id trade_id {trade.trade_id.hex()}")
@@ -292,8 +294,9 @@ class TradeManager:
                 await self.trade_store.set_status(trade.trade_id, TradeStatus.CANCELLED)
                 continue
 
-            cancellation_additions: List[Coin] = []
+            cancellation_additions: list[Coin] = []
             valid_times: ConditionValidTimes = parse_timelock_info(extra_conditions)
+            trades_to_cancel: list[TradeRecord] = []
             for coin in cancellation_coins:
                 wallet = await self.wallet_state_manager.get_wallet_for_coin(coin.name())
 
@@ -306,7 +309,7 @@ class TradeManager:
                 )
 
                 if len(trade_records) > 1 or len(cancellation_coins) > 1:
-                    announcement_conditions: Tuple[Condition, ...] = (
+                    announcement_conditions: tuple[Condition, ...] = (
                         announcement_creations.popleft(),
                         announcement_assertions.popleft(),
                     )
@@ -318,7 +321,7 @@ class TradeManager:
                 if wallet.type() == WalletType.STANDARD_WALLET:
                     assert isinstance(wallet, Wallet)
                     if fee_to_pay > coin.amount:
-                        selected_coins: Set[Coin] = await wallet.select_coins(
+                        selected_coins: set[Coin] = await wallet.select_coins(
                             uint64(fee_to_pay - coin.amount),
                             action_scope,
                         )
@@ -391,7 +394,14 @@ class TradeManager:
                 )
                 all_txs.append(incoming_tx)
 
+                # The statuses of trades which offer cancellation coin needs to be set to `PENDING_CANCEL`
+                trades_to_cancel.extend(await self.get_trades_by_coin(coin))
+
             await self.trade_store.set_status(trade.trade_id, TradeStatus.PENDING_CANCEL)
+            self.log.info(f"Cancelling trade: {trade.trade_id}")
+            for t in trades_to_cancel:
+                await self.trade_store.set_status(t.trade_id, TradeStatus.PENDING_CANCEL)
+                self.log.info(f"Cancelling trade: {t.trade_id} along with {trade.trade_id}")
 
         if secure:
             async with action_scope.use() as interface:
@@ -415,9 +425,9 @@ class TradeManager:
         await self.trade_store.add_trade_record(trade, offer_name)
 
         # We want to subscribe to the coin IDs of all coins that are not the ephemeral offer coins
-        offered_coins: Set[Coin] = {value for values in offer.get_offered_coins().values() for value in values}
-        non_offer_additions: Set[Coin] = set(offer.additions()) ^ offered_coins
-        non_offer_removals: Set[Coin] = set(offer.removals()) ^ offered_coins
+        offered_coins: set[Coin] = {value for values in offer.get_offered_coins().values() for value in values}
+        non_offer_additions: set[Coin] = set(offer.additions()) ^ offered_coins
+        non_offer_removals: set[Coin] = set(offer.removals()) ^ offered_coins
         await self.wallet_state_manager.add_interested_coin_ids(
             [coin.name() for coin in (*non_offer_removals, *non_offer_additions)]
         )
@@ -426,15 +436,15 @@ class TradeManager:
 
     async def create_offer_for_ids(
         self,
-        offer: Dict[Union[int, bytes32], int],
+        offer: dict[Union[int, bytes32], int],
         action_scope: WalletActionScope,
-        driver_dict: Optional[Dict[bytes32, PuzzleInfo]] = None,
+        driver_dict: Optional[dict[bytes32, PuzzleInfo]] = None,
         solver: Optional[Solver] = None,
         fee: uint64 = uint64(0),
         validate_only: bool = False,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
         taking: bool = False,
-    ) -> Union[Tuple[Literal[True], TradeRecord, None], Tuple[Literal[False], None, str]]:
+    ) -> Union[tuple[Literal[True], TradeRecord, None], tuple[Literal[False], None, str]]:
         if driver_dict is None:
             driver_dict = {}
         if solver is None:
@@ -476,14 +486,14 @@ class TradeManager:
 
     async def _create_offer_for_ids(
         self,
-        offer_dict: Dict[Union[int, bytes32], int],
+        offer_dict: dict[Union[int, bytes32], int],
         action_scope: WalletActionScope,
-        driver_dict: Optional[Dict[bytes32, PuzzleInfo]] = None,
+        driver_dict: Optional[dict[bytes32, PuzzleInfo]] = None,
         solver: Optional[Solver] = None,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
         taking: bool = False,
-    ) -> Union[Tuple[Literal[True], Offer, None], Tuple[Literal[False], None, str]]:
+    ) -> Union[tuple[Literal[True], Offer, None], tuple[Literal[False], None, str]]:
         """
         Offer is dictionary of wallet ids and amount
         """
@@ -492,23 +502,28 @@ class TradeManager:
         if solver is None:
             solver = Solver({})
         try:
-            coins_to_offer: Dict[Union[int, bytes32], Set[Coin]] = {}
-            requested_payments: Dict[Optional[bytes32], List[Payment]] = {}
-            offer_dict_no_ints: Dict[Optional[bytes32], int] = {}
+            coins_to_offer: dict[Union[int, bytes32], set[Coin]] = {}
+            requested_payments: dict[Optional[bytes32], list[Payment]] = {}
+            offer_dict_no_ints: dict[Optional[bytes32], int] = {}
             for id, amount in offer_dict.items():
                 asset_id: Optional[bytes32] = None
                 # asset_id can either be none if asset is XCH or
                 # bytes32 if another asset (e.g. NFT, CAT)
                 if amount > 0:
                     # this is what we are receiving in the trade
-                    memos: List[bytes] = []
+                    memos: list[bytes] = []
                     if isinstance(id, int):
                         wallet_id = uint32(id)
                         wallet = self.wallet_state_manager.wallets.get(wallet_id)
                         assert isinstance(wallet, (CATWallet, Wallet))
-                        p2_ph: bytes32 = await wallet.get_puzzle_hash(
-                            new=not action_scope.config.tx_config.reuse_puzhash
-                        )
+                        if isinstance(wallet, Wallet):
+                            p2_ph: bytes32 = await wallet.get_puzzle_hash(
+                                new=not action_scope.config.tx_config.reuse_puzhash
+                            )
+                        else:
+                            p2_ph = await wallet.standard_wallet.get_puzzle_hash(
+                                new=not action_scope.config.tx_config.reuse_puzhash
+                            )
                         if wallet.type() != WalletType.STANDARD_WALLET:
                             if callable(getattr(wallet, "get_asset_id", None)):  # ATTENTION: new wallets
                                 assert isinstance(wallet, CATWallet)
@@ -601,13 +616,13 @@ class TradeManager:
             if potential_special_offer is not None:
                 return True, potential_special_offer, None
 
-            all_coins: List[Coin] = [c for coins in coins_to_offer.values() for c in coins]
-            notarized_payments: Dict[Optional[bytes32], List[NotarizedPayment]] = Offer.notarize_payments(
+            all_coins: list[Coin] = [c for coins in coins_to_offer.values() for c in coins]
+            notarized_payments: dict[Optional[bytes32], list[NotarizedPayment]] = Offer.notarize_payments(
                 requested_payments, all_coins
             )
             announcements_to_assert = Offer.calculate_announcements(notarized_payments, driver_dict)
 
-            all_transactions: List[TransactionRecord] = []
+            all_transactions: list[TransactionRecord] = []
             fee_left_to_pay: uint64 = fee
             # The access of the sorted keys here makes sure we create the XCH transaction first to make sure we pay fee
             # with the XCH side of the offer and don't create an extra fee transaction in other wallets.
@@ -689,9 +704,9 @@ class TradeManager:
                 await wsm.create_wallet_for_puzzle_info(offer.driver_dict[key])
 
     async def check_offer_validity(self, offer: Offer, peer: WSChiaConnection) -> bool:
-        all_removals: List[Coin] = offer.removals()
-        all_removal_names: List[bytes32] = [c.name() for c in all_removals]
-        non_ephemeral_removals: List[Coin] = list(
+        all_removals: list[Coin] = offer.removals()
+        all_removal_names: list[bytes32] = [c.name() for c in all_removals]
+        non_ephemeral_removals: list[Coin] = list(
             filter(lambda c: c.parent_coin_info not in all_removal_names, all_removals)
         )
         coin_states = await self.wallet_state_manager.wallet_node.get_coin_state(
@@ -700,27 +715,27 @@ class TradeManager:
 
         return len(coin_states) == len(non_ephemeral_removals) and all([cs.spent_height is None for cs in coin_states])
 
-    async def calculate_tx_records_for_offer(self, offer: Offer, validate: bool) -> List[TransactionRecord]:
+    async def calculate_tx_records_for_offer(self, offer: Offer, validate: bool) -> list[TransactionRecord]:
         if validate:
             final_spend_bundle: WalletSpendBundle = offer.to_valid_spend()
-            hint_dict: Dict[bytes32, bytes32] = {}
-            additions_dict: Dict[bytes32, Coin] = {}
+            hint_dict: dict[bytes32, bytes32] = {}
+            additions_dict: dict[bytes32, Coin] = {}
             for hinted_coins, _ in (
                 compute_spend_hints_and_additions(spend) for spend in final_spend_bundle.coin_spends
             ):
                 hint_dict.update({id: hc.hint for id, hc in hinted_coins.items() if hc.hint is not None})
                 additions_dict.update({id: hc.coin for id, hc in hinted_coins.items()})
-            all_additions: List[Coin] = list(a for a in additions_dict.values())
+            all_additions: list[Coin] = list(a for a in additions_dict.values())
         else:
             final_spend_bundle = offer._bundle
             hint_dict = offer.hints()
             all_additions = offer.additions()
 
-        settlement_coins: List[Coin] = [c for coins in offer.get_offered_coins().values() for c in coins]
-        settlement_coin_ids: List[bytes32] = [c.name() for c in settlement_coins]
+        settlement_coins: list[Coin] = [c for coins in offer.get_offered_coins().values() for c in coins]
+        settlement_coin_ids: list[bytes32] = [c.name() for c in settlement_coins]
 
-        removals: List[Coin] = final_spend_bundle.removals()
-        additions: List[Coin] = list(a for a in all_additions if a not in removals)
+        removals: list[Coin] = final_spend_bundle.removals()
+        additions: list[Coin] = list(a for a in all_additions if a not in removals)
         valid_times: ConditionValidTimes = parse_timelock_info(
             parse_conditions_non_consensus(
                 condition
@@ -733,7 +748,7 @@ class TradeManager:
 
         txs = []
 
-        addition_dict: Dict[uint32, List[Coin]] = {}
+        addition_dict: dict[uint32, list[Coin]] = {}
         for addition in additions:
             wallet_identifier = await self.wallet_state_manager.get_wallet_identifier_for_coin(
                 addition,
@@ -770,7 +785,7 @@ class TradeManager:
                     addition_dict[wallet_identifier.id].append(addition)
 
         # While we want additions to show up as separate records, removals of the same wallet should show as one
-        removal_dict: Dict[uint32, List[Coin]] = {}
+        removal_dict: dict[uint32, list[Coin]] = {}
         for removal in removals:
             wallet_identifier = await self.wallet_state_manager.get_wallet_identifier_for_coin(
                 removal,
@@ -780,7 +795,7 @@ class TradeManager:
                 removal_dict.setdefault(wallet_identifier.id, [])
                 removal_dict[wallet_identifier.id].append(removal)
 
-        all_removals: List[bytes32] = [r.name() for removals in removal_dict.values() for r in removals]
+        all_removals: list[bytes32] = [r.name() for removals in removal_dict.values() for r in removals]
 
         for wid, grouped_removals in removal_dict.items():
             wallet = self.wallet_state_manager.wallets[wid]
@@ -788,12 +803,12 @@ class TradeManager:
             removal_tree_hash = Program.to([coin_as_list(rem) for rem in grouped_removals]).get_tree_hash()
             # We also need to calculate the sent amount
             removed: int = sum(c.amount for c in grouped_removals)
-            removed_ids: List[bytes32] = [c.name() for c in grouped_removals]
-            all_additions_from_grouped_removals: List[Coin] = [
+            removed_ids: list[bytes32] = [c.name() for c in grouped_removals]
+            all_additions_from_grouped_removals: list[Coin] = [
                 c for c in all_additions if c.parent_coin_info in removed_ids
             ]
-            potential_change_coins: List[Coin] = addition_dict[wid] if wid in addition_dict else []
-            change_coins: List[Coin] = [c for c in potential_change_coins if c.parent_coin_info in all_removals]
+            potential_change_coins: list[Coin] = addition_dict[wid] if wid in addition_dict else []
+            change_coins: list[Coin] = [c for c in potential_change_coins if c.parent_coin_info in all_removals]
             change_amount: int = sum(c.amount for c in change_coins)
             sent_amount: int = (
                 removed
@@ -835,12 +850,12 @@ class TradeManager:
         action_scope: WalletActionScope,
         solver: Optional[Solver] = None,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> TradeRecord:
         if solver is None:
             solver = Solver({})
-        take_offer_dict: Dict[Union[bytes32, int], int] = {}
-        arbitrage: Dict[Optional[bytes32], int] = offer.arbitrage()
+        take_offer_dict: dict[Union[bytes32, int], int] = {}
+        arbitrage: dict[Optional[bytes32], int] = offer.arbitrage()
 
         for asset_id, amount in arbitrage.items():
             if asset_id is None:
@@ -852,7 +867,7 @@ class TradeManager:
                 wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
                 if wallet is None and amount < 0:
                     raise ValueError(f"Do not have a wallet for asset ID: {asset_id} to fulfill offer")
-                elif wallet is None or wallet.type() in [WalletType.NFT, WalletType.DATA_LAYER]:
+                elif wallet is None or wallet.type() in {WalletType.NFT, WalletType.DATA_LAYER}:
                     key = asset_id
                 else:
                     key = int(wallet.id())
@@ -878,7 +893,7 @@ class TradeManager:
             if not result[0] or result[1] is None:
                 raise ValueError(result[2])
 
-            success, take_offer, error = result
+            _success, take_offer, _error = result
 
             complete_offer, valid_spend_solver = await self.check_for_final_modifications(
                 Offer.aggregate([offer, take_offer]), solver, inner_action_scope
@@ -890,7 +905,7 @@ class TradeManager:
         )
         await self.maybe_create_wallets_for_offer(complete_offer)
 
-        tx_records: List[TransactionRecord] = await self.calculate_tx_records_for_offer(complete_offer, True)
+        tx_records: list[TransactionRecord] = await self.calculate_tx_records_for_offer(complete_offer, True)
 
         trade_record: TradeRecord = TradeRecord(
             confirmed_at_index=uint32(0),
@@ -917,12 +932,12 @@ class TradeManager:
 
     async def check_for_special_offer_making(
         self,
-        offer_dict: Dict[Optional[bytes32], int],
-        driver_dict: Dict[bytes32, PuzzleInfo],
+        offer_dict: dict[Optional[bytes32], int],
+        driver_dict: dict[bytes32, PuzzleInfo],
         action_scope: WalletActionScope,
         solver: Solver,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> Optional[Offer]:
         for puzzle_info in driver_dict.values():
             if (
@@ -974,7 +989,7 @@ class TradeManager:
                 return True
         return False
 
-    async def get_offer_summary(self, offer: Offer) -> Dict[str, Any]:
+    async def get_offer_summary(self, offer: Offer) -> dict[str, Any]:
         for puzzle_info in offer.driver_dict.values():
             if (
                 puzzle_info.check_type(
@@ -999,18 +1014,18 @@ class TradeManager:
                 k: v
                 for k, v in valid_times.to_json_dict().items()
                 if k
-                not in (
+                not in {
                     "max_secs_after_created",
                     "min_secs_since_created",
                     "max_blocks_after_created",
                     "min_blocks_since_created",
-                )
+                }
             },
         }
 
     async def check_for_final_modifications(
         self, offer: Offer, solver: Solver, action_scope: WalletActionScope
-    ) -> Tuple[Offer, Solver]:
+    ) -> tuple[Offer, Solver]:
         for puzzle_info in offer.driver_dict.values():
             if (
                 puzzle_info.check_type(
@@ -1033,17 +1048,16 @@ class TradeManager:
                     if WalletType(wallet.type()) == WalletType.VC:
                         assert isinstance(wallet, VCWallet)
                         return await wallet.add_vc_authorization(offer, solver, action_scope)
-                else:
-                    raise ValueError("No VCs to approve CR-CATs with")  # pragma: no cover
+                raise ValueError("No VCs to approve CR-CATs with")  # pragma: no cover
 
         return offer, Solver({})
 
     async def check_for_requested_payment_modifications(
         self,
-        requested_payments: Dict[Optional[bytes32], List[Payment]],
-        driver_dict: Dict[bytes32, PuzzleInfo],
+        requested_payments: dict[Optional[bytes32], list[Payment]],
+        driver_dict: dict[bytes32, PuzzleInfo],
         taking: bool,
-    ) -> Dict[Optional[bytes32], List[Payment]]:
+    ) -> dict[Optional[bytes32], list[Payment]]:
         # This function exclusively deals with CR-CATs for now
         if not taking:
             for asset_id, puzzle_info in driver_dict.items():

chia/wallet/trade_record.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Optional, TypeVar
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -28,12 +28,12 @@ class TradeRecordOld(Streamable):
     sent: uint32
     offer: bytes
     taken_offer: Optional[bytes]
-    coins_of_interest: List[Coin]
+    coins_of_interest: list[Coin]
     trade_id: bytes32
     status: uint32  # TradeStatus, enum not streamable
-    sent_to: List[Tuple[str, uint8, Optional[str]]]  # MempoolSubmissionStatus.status enum not streamable
+    sent_to: list[tuple[str, uint8, Optional[str]]]  # MempoolSubmissionStatus.status enum not streamable
 
-    def to_json_dict_convenience(self) -> Dict[str, Any]:
+    def to_json_dict_convenience(self) -> dict[str, Any]:
         formatted = self.to_json_dict()
         formatted["status"] = TradeStatus(self.status).name
         offer_to_summarize: bytes = self.offer if self.taken_offer is None else self.taken_offer
@@ -51,7 +51,7 @@ class TradeRecordOld(Streamable):
 
     @classmethod
     def from_json_dict_convenience(
-        cls: Type[_T_TradeRecord], record: Dict[str, Any], offer: str = ""
+        cls: type[_T_TradeRecord], record: dict[str, Any], offer: str = ""
     ) -> _T_TradeRecord:
         new_record = record.copy()
         new_record["status"] = TradeStatus[record["status"]].value