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

chia/wallet/util/signing.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs.sized_bytes import bytes32
+
+from chia.types.blockchain_format.program import Program
+from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
+from chia.util.bech32m import decode_puzzle_hash
+from chia.util.byte_types import hexstr_to_bytes
+from chia.wallet.puzzles import p2_delegated_conditions
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_synthetic_public_key
+from chia.wallet.wallet_request_types import VerifySignatureResponse
+
+# CHIP-0002 message signing as documented at:
+# https://github.com/Chia-Network/chips/blob/80e4611fe52b174bf1a0382b9dff73805b18b8c6/CHIPs/chip-0002.md
+
+
+def verify_signature(
+    *, signing_mode: SigningMode, public_key: G1Element, message: str, signature: G2Element, address: str | None
+) -> VerifySignatureResponse:
+    """
+    Given a public key, message and signature, verify if it is valid.
+    :param request:
+    :return:
+    """
+    if signing_mode in {SigningMode.CHIP_0002, SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS}:
+        # CHIP-0002 message signatures are made over the tree hash of:
+        #   ("Chia Signed Message", message)
+        message_to_verify: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message)).get_tree_hash()
+    elif signing_mode == SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT:
+        # Message is expected to be a hex string
+        message_to_verify = hexstr_to_bytes(message)
+    elif signing_mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
+        # Message is expected to be a UTF-8 string
+        message_to_verify = bytes(message, "utf-8")
+    else:
+        raise ValueError(f"Unsupported signing mode: {signing_mode!r}")
+
+    # Verify using the BLS message augmentation scheme
+    is_valid = AugSchemeMPL.verify(
+        public_key,
+        message_to_verify,
+        signature,
+    )
+    if address is not None:
+        # For signatures made by the sign_message_by_address/sign_message_by_id
+        # endpoints, the "address" field should contain the p2_address of the NFT/DID
+        # that was used to sign the message.
+        puzzle_hash: bytes32 = decode_puzzle_hash(address)
+        expected_puzzle_hash: bytes32 | None = None
+        if signing_mode == SigningMode.CHIP_0002_P2_DELEGATED_CONDITIONS:
+            puzzle = p2_delegated_conditions.puzzle_for_pk(Program.to(public_key))
+            expected_puzzle_hash = bytes32(puzzle.get_tree_hash())
+        else:
+            expected_puzzle_hash = puzzle_hash_for_synthetic_public_key(public_key)
+        if puzzle_hash != expected_puzzle_hash:
+            return VerifySignatureResponse(isValid=False, error="Public key doesn't match the address")
+    if is_valid:
+        return VerifySignatureResponse(isValid=is_valid)
+    else:
+        return VerifySignatureResponse(isValid=False, error="Signature is invalid.")
+
+
+@dataclass(kw_only=True, frozen=True)
+class SignMessageResponse:
+    pubkey: G1Element
+    signature: G2Element
+
+
+def sign_message(secret_key: PrivateKey, message: str, mode: SigningMode) -> SignMessageResponse:
+    public_key = secret_key.get_g1()
+    if mode == SigningMode.CHIP_0002_HEX_INPUT:
+        hex_message: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message))).get_tree_hash()
+    elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
+        hex_message = bytes(message, "utf-8")
+    elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT:
+        hex_message = bytes.fromhex(message)
+    else:
+        hex_message = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message)).get_tree_hash()
+    return SignMessageResponse(
+        pubkey=public_key,
+        signature=AugSchemeMPL.sign(secret_key, hex_message),
+    )

chia/wallet/util/tx_config.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 from chia_rs.sized_bytes import bytes32
@@ -32,6 +32,15 @@ class CoinSelectionConfig:
     def override(self, **kwargs: Any) -> CoinSelectionConfig:
         return dataclasses.replace(self, **kwargs)
 
+    def filter_coins(self, coins: set[Coin]) -> set[Coin]:
+        return {
+            coin
+            for coin in coins
+            if self.min_coin_amount <= coin.amount <= self.max_coin_amount
+            and coin.amount not in self.excluded_coin_amounts
+            and coin.name() not in self.excluded_coin_ids
+        }
+
 
 @dataclasses.dataclass(frozen=True)
 class TXConfig(CoinSelectionConfig):
@@ -69,10 +78,10 @@ class AutofillArgs(TypedDict):
 @streamable
 @dataclasses.dataclass(frozen=True)
 class CoinSelectionConfigLoader(Streamable):
-    min_coin_amount: Optional[uint64] = None
-    max_coin_amount: Optional[uint64] = None
-    excluded_coin_amounts: Optional[list[uint64]] = None
-    excluded_coin_ids: Optional[list[bytes32]] = None
+    min_coin_amount: uint64 | None = None
+    max_coin_amount: uint64 | None = None
+    excluded_coin_amounts: list[uint64] | None = None
+    excluded_coin_ids: list[bytes32] | None = None
 
     def autofill(
         self,
@@ -106,7 +115,7 @@ class CoinSelectionConfigLoader(Streamable):
 @streamable
 @dataclasses.dataclass(frozen=True)
 class TXConfigLoader(CoinSelectionConfigLoader):
-    reuse_puzhash: Optional[bool] = None
+    reuse_puzhash: bool | None = None
 
     def autofill(
         self,

chia/wallet/util/wallet_sync_utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import random
-from typing import Any, Optional, Union
+from typing import Any
 
 from chia_rs import (
     CoinSpend,
@@ -60,7 +60,7 @@ async def subscribe_to_phs(
     Tells full nodes that we are interested in puzzle hashes, and returns the response.
     """
     msg = RegisterForPhUpdates(puzzle_hashes, uint32(max(min_height, uint32(0))))
-    all_coins_state: Optional[RespondToPhUpdates] = await peer.call_api(
+    all_coins_state: RespondToPhUpdates | None = await peer.call_api(
         FullNodeAPI.register_for_ph_updates, msg, timeout=300
     )
     if all_coins_state is None:
@@ -77,7 +77,7 @@ async def subscribe_to_coin_updates(
     Tells full nodes that we are interested in coin ids, and returns the response.
     """
     msg = RegisterForCoinUpdates(coin_names, uint32(max(0, min_height)))
-    all_coins_state: Optional[RespondToCoinUpdates] = await peer.call_api(
+    all_coins_state: RespondToCoinUpdates | None = await peer.call_api(
         FullNodeAPI.register_for_coin_updates, msg, timeout=300
     )
 
@@ -88,7 +88,7 @@ async def subscribe_to_coin_updates(
 
 def validate_additions(
     coins: list[tuple[bytes32, list[Coin]]],
-    proofs: Optional[list[tuple[bytes32, bytes, Optional[bytes]]]],
+    proofs: list[tuple[bytes32, bytes, bytes | None]] | None,
     root: bytes32,
 ) -> bool:
     if proofs is None:
@@ -107,8 +107,8 @@ def validate_additions(
         for i in range(len(coins)):
             assert coins[i][0] == proofs[i][0]
             coin_list_1: list[Coin] = coins[i][1]
-            puzzle_hash_proof: Optional[bytes] = proofs[i][1]
-            coin_list_proof: Optional[bytes] = proofs[i][2]
+            puzzle_hash_proof: bytes | None = proofs[i][1]
+            coin_list_proof: bytes | None = proofs[i][2]
             if len(coin_list_1) == 0:
                 # Verify exclusion proof for puzzle hash
                 assert puzzle_hash_proof is not None
@@ -149,7 +149,7 @@ def validate_additions(
 
 
 def validate_removals(
-    coins: list[tuple[bytes32, Optional[Coin]]], proofs: Optional[list[tuple[bytes32, bytes]]], root: bytes32
+    coins: list[tuple[bytes32, Coin | None]], proofs: list[tuple[bytes32, bytes]] | None, root: bytes32
 ) -> bool:
     if proofs is None:
         # If there are no proofs, it means all removals were returned in the response.
@@ -198,7 +198,7 @@ async def request_and_validate_removals(
 ) -> bool:
     removals_request = RequestRemovals(height, header_hash, [coin_name])
 
-    removals_res: Optional[Union[RespondRemovals, RejectRemovalsRequest]] = await peer.call_api(
+    removals_res: RespondRemovals | RejectRemovalsRequest | None = await peer.call_api(
         FullNodeAPI.request_removals, removals_request
     )
     if removals_res is None or isinstance(removals_res, RejectRemovalsRequest):
@@ -217,7 +217,7 @@ async def request_and_validate_additions(
     if peer_request_cache.in_additions_in_block(header_hash, puzzle_hash):
         return True
     additions_request = RequestAdditions(height, header_hash, [puzzle_hash])
-    additions_res: Optional[Union[RespondAdditions, RejectAdditionsRequest]] = await peer.call_api(
+    additions_res: RespondAdditions | RejectAdditionsRequest | None = await peer.call_api(
         FullNodeAPI.request_additions, additions_request
     )
     if additions_res is None or isinstance(additions_res, RejectAdditionsRequest):
@@ -254,7 +254,7 @@ def sort_coin_states(coin_states: set[CoinState]) -> list[CoinState]:
 
 async def request_header_blocks(
     peer: WSChiaConnection, start_height: uint32, end_height: uint32
-) -> Optional[list[HeaderBlock]]:
+) -> list[HeaderBlock] | None:
     if Capability.BLOCK_HEADERS in peer.peer_capabilities:
         response = await peer.call_api(
             FullNodeAPI.request_block_headers, RequestBlockHeaders(start_height, end_height, False)
@@ -271,7 +271,7 @@ async def _fetch_header_blocks_inner(
     all_peers: list[tuple[WSChiaConnection, bool]],
     request_start: uint32,
     request_end: uint32,
-) -> Optional[Union[RespondHeaderBlocks, RespondBlockHeaders]]:
+) -> RespondHeaderBlocks | RespondBlockHeaders | None:
     # We will modify this list, don't modify passed parameters.
     bytes_api_peers = [peer for peer in all_peers if Capability.BLOCK_HEADERS in peer[0].peer_capabilities]
     other_peers = [peer for peer in all_peers if Capability.BLOCK_HEADERS not in peer[0].peer_capabilities]
@@ -305,19 +305,17 @@ async def fetch_header_blocks_in_range(
     end: uint32,
     peer_request_cache: PeerRequestCache,
     all_peers: list[tuple[WSChiaConnection, bool]],
-) -> Optional[list[HeaderBlock]]:
+) -> list[HeaderBlock] | None:
     blocks: list[HeaderBlock] = []
     for i in range(start - (start % 32), end + 1, 32):
         request_start = min(uint32(i), end)
         request_end = min(uint32(i + 31), end)
-        res_h_blocks_task: Optional[asyncio.Task[Any]] = peer_request_cache.get_block_request(
-            request_start, request_end
-        )
+        res_h_blocks_task: asyncio.Task[Any] | None = peer_request_cache.get_block_request(request_start, request_end)
 
         if res_h_blocks_task is not None:
             log.debug(f"Using cache for: {start}-{end}")
             if res_h_blocks_task.done():
-                res_h_blocks: Optional[Union[RespondBlockHeaders, RespondHeaderBlocks]] = res_h_blocks_task.result()
+                res_h_blocks: RespondBlockHeaders | RespondHeaderBlocks | None = res_h_blocks_task.result()
             else:
                 res_h_blocks = await res_h_blocks_task
         else:

chia/wallet/util/wallet_types.py

@@ -33,8 +33,8 @@ class WalletType(IntEnum):
     def to_json_dict(self) -> str:
         # yes, this isn't a `dict`, but it is json and
         # unfortunately the magic method name is misleading
-        # not sure this code is used
-        # TODO: determine if this code is used and if not, remove it
+
+        # This gets called with EnhancedJSONEncoder in the RPC
         return self.name
 
 

chia/wallet/vc_wallet/cr_cat_drivers.py

@@ -4,7 +4,6 @@ import functools
 from collections.abc import Iterable
 from dataclasses import dataclass, replace
 from enum import IntEnum
-from typing import Optional
 
 from chia_puzzles_py.programs import (
     CONDITIONS_W_FEE_ANNOUNCE,
@@ -65,7 +64,7 @@ CREDENTIAL_STRUCT: Program = Program.to(
             curry_and_treehash(
                 Program.to((1, EXTIGENT_METADATA_LAYER_HASH)).get_tree_hash_precalc(EXTIGENT_METADATA_LAYER_HASH),
                 Program.to(EXTIGENT_METADATA_LAYER_HASH).get_tree_hash(),
-                Program.to(None).get_tree_hash(),
+                Program.NIL.get_tree_hash(),
                 GUARANTEED_NIL_TP_HASH,
                 Program.to(GUARANTEED_NIL_TP_HASH).get_tree_hash(),
                 P2_ANNOUNCED_DELEGATED_PUZZLE_HASH,
@@ -127,7 +126,7 @@ def construct_cr_layer_hash(
 
 def match_cr_layer(
     uncurried_puzzle: UncurriedPuzzle,
-) -> Optional[tuple[list[bytes32], Program, Program]]:
+) -> tuple[list[bytes32], Program, Program] | None:
     extra_uncurried_puzzle = uncurry_puzzle(uncurried_puzzle.mod)
     if extra_uncurried_puzzle.mod == CREDENTIAL_RESTRICTION:
         return (
@@ -188,7 +187,7 @@ class CRCAT:
         authorized_providers: list[bytes32],
         proofs_checker: Program,
         # Probably never need this but some tail might
-        optional_lineage_proof: Optional[LineageProof] = None,
+        optional_lineage_proof: LineageProof | None = None,
     ) -> tuple[Program, CoinSpend, CRCAT]:
         """
         Launch a new CR-CAT from XCH.
@@ -327,7 +326,7 @@ class CRCAT:
     def get_next_from_coin_spend(
         cls,
         parent_spend: CoinSpend,
-        conditions: Optional[Program] = None,  # For optimization purposes, the conditions may already have been run
+        conditions: Program | None = None,  # For optimization purposes, the conditions may already have been run
     ) -> list[CRCAT]:
         """
         Given a coin spend, this will return the next CR-CATs that were created as an output of that spend.
@@ -342,7 +341,7 @@ class CRCAT:
 
         # Get info by uncurrying
         _, tail_hash_as_prog, potential_cr_layer = puzzle.uncurry()[1].as_iter()
-        new_inner_puzzle_hash: Optional[bytes32] = None
+        new_inner_puzzle_hash: bytes32 | None = None
         if potential_cr_layer.uncurry()[0].uncurry()[0] != CREDENTIAL_RESTRICTION:
             # If the previous spend is not a CR-CAT:
             # we look for a remark condition that tells us the authorized_providers and proofs_checker
@@ -428,12 +427,12 @@ class CRCAT:
         proof_checker_solution: Program,
         provider_id: bytes32,
         vc_launcher_id: bytes32,
-        vc_inner_puzhash: Optional[bytes32],  # Optional for incomplete spends
+        vc_inner_puzhash: bytes32 | None,  # Optional for incomplete spends
         # Inner puzzle and solution
         inner_puzzle: Program,
         inner_solution: Program,
         # For optimization purposes the conditions may already have been run
-        conditions: Optional[Iterable[Program]] = None,
+        conditions: Iterable[Program] | None = None,
     ) -> tuple[list[AssertCoinAnnouncement], CoinSpend, list[CRCAT]]:
         """
         Spend a CR-CAT.
@@ -521,7 +520,7 @@ class CRCAT:
         proof_checker_solution: Program,
         provider_id: bytes32,
         vc_launcher_id: bytes32,
-        vc_inner_puzhash: Optional[bytes32],  # Optional for incomplete spends
+        vc_inner_puzhash: bytes32 | None,  # Optional for incomplete spends
     ) -> tuple[list[AssertCoinAnnouncement], list[CoinSpend], list[CRCAT]]:
         """
         Spend a multiple CR-CATs.
@@ -615,7 +614,7 @@ class CRCATSpend:
             inner_puzzle,
             inner_solution,
             CRCAT.get_next_from_coin_spend(spend, conditions=inner_conditions),
-            Program.from_serialized(spend.solution).at("f").at("rrrrf") == Program.to(None),
+            Program.from_serialized(spend.solution).at("f").at("rrrrf") == Program.NIL,
             list(inner_conditions.as_iter()),
             Program.from_serialized(spend.solution).at("f").at("f"),
         )
@@ -628,7 +627,7 @@ class ProofsChecker(Streamable):
 
     def as_program(self) -> Program:
         def byte_sort_flags(f1: str, f2: str) -> int:
-            return 1 if Program.to([10, (1, f1), (1, f2)]).run([]) == Program.to(None) else -1
+            return 1 if Program.to([10, (1, f1), (1, f2)]).run([]) == Program.NIL else -1
 
         return PROOF_FLAGS_CHECKER.curry(
             [

chia/wallet/vc_wallet/cr_cat_wallet.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import time
 import traceback
-from typing import TYPE_CHECKING, Any, ClassVar, Optional
+from typing import TYPE_CHECKING, Any, ClassVar
 
 from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -72,8 +72,8 @@ class CRCATWallet(CATWallet):
     wallet_info_type: ClassVar[type[CRCATInfo]] = CRCATInfo
 
     @staticmethod
-    def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
-        return f"CAT {limitations_program_hash_hex[:16]}..."
+    def default_wallet_name_for_unknown_cat(limitations_program_hash: bytes32) -> str:
+        return f"CAT {limitations_program_hash.hex()[:16]}..."
 
     @property
     def cost_of_single_tx(self) -> int:
@@ -87,7 +87,7 @@ class CRCATWallet(CATWallet):
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        name: Optional[str] = None,
+        name: str | None = None,
         push: bool = False,
     ) -> CATWallet:  # pragma: no cover
         raise NotImplementedError("create_new_cat_wallet is a legacy method and is not available on CR-CAT wallets")
@@ -97,31 +97,29 @@ class CRCATWallet(CATWallet):
         cls,
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
-        limitations_program_hash_hex: str,
-        name: Optional[str] = None,
-        authorized_providers: Optional[list[bytes32]] = None,
-        proofs_checker: Optional[ProofsChecker] = None,
+        limitations_program_hash: bytes32,
+        name: str | None = None,
+        authorized_providers: list[bytes32] | None = None,
+        proofs_checker: ProofsChecker | None = None,
     ) -> Self:
         if authorized_providers is None or proofs_checker is None:  # pragma: no cover
             raise ValueError("get_or_create_wallet_for_cat was call on CRCATWallet without proper arguments")
         self = cls()
         self.standard_wallet = wallet
         if name is None:
-            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
+            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash)
         self.log = logging.getLogger(name)
 
-        tail_hash = bytes32.from_hexstr(limitations_program_hash_hex)
-
         for id, w in wallet_state_manager.wallets.items():
             if w.type() == cls.type():
                 assert isinstance(w, cls)
-                if w.get_asset_id() == limitations_program_hash_hex:
+                if w.get_asset_id() == limitations_program_hash:
                     self.log.warning("Not creating wallet for already existing CR-CAT wallet")
                     return w
 
         self.wallet_state_manager = wallet_state_manager
 
-        self.info = cls.wallet_info_type(tail_hash, None, authorized_providers, proofs_checker)
+        self.info = cls.wallet_info_type(limitations_program_hash, None, authorized_providers, proofs_checker)
         info_as_string = bytes(self.info).hex()
         self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, WalletType.CRCAT, info_as_string)
 
@@ -134,20 +132,20 @@ class CRCATWallet(CATWallet):
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         puzzle_driver: PuzzleInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
         # We're hinting this as Any for mypy by should explore adding this to the wallet protocol and hinting properly
-        potential_subclasses: Optional[dict[AssetType, Any]] = None,
+        potential_subclasses: dict[AssetType, Any] | None = None,
     ) -> Any:
         if potential_subclasses is None:
             potential_subclasses = {}
 
-        cr_layer: Optional[PuzzleInfo] = puzzle_driver.also()
+        cr_layer: PuzzleInfo | None = puzzle_driver.also()
         if cr_layer is None:  # pragma: no cover
             raise ValueError("create_from_puzzle_info called on CRCATWallet with a non CR-CAT puzzle driver")
         return await cls.get_or_create_wallet_for_cat(
             wallet_state_manager,
             wallet,
-            puzzle_driver["tail"].hex(),
+            puzzle_driver["tail"],
             name,
             [bytes32(provider) for provider in cr_layer["authorized_providers"]],
             ProofsChecker.from_program(uncurry_puzzle(cr_layer["proofs_checker"])),
@@ -201,14 +199,14 @@ class CRCATWallet(CATWallet):
     def id(self) -> uint32:
         return self.wallet_info.id
 
-    def get_asset_id(self) -> str:
-        return bytes(self.info.limitations_program_hash).hex()
+    def get_asset_id(self) -> bytes32:
+        return self.info.limitations_program_hash
 
     async def set_tail_program(self, tail_program: str) -> None:  # pragma: no cover
         raise NotImplementedError("set_tail_program is a legacy method and is not available on CR-CAT wallets")
 
     async def coin_added(
-        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[CATCoinData]
+        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: CATCoinData | None
     ) -> None:
         """Notification from wallet state manager that wallet has been received."""
         self.log.info(f"CR-CAT wallet has been notified that {coin.name().hex()} was added")
@@ -322,21 +320,13 @@ class CRCATWallet(CATWallet):
             "inner_puzzle_for_cat_puzhash is a legacy method and is not available on CR-CAT wallets"
         )
 
-    async def get_cat_spendable_coins(self, records: Optional[set[WalletCoinRecord]] = None) -> list[WalletCoinRecord]:
-        result: list[WalletCoinRecord] = []
-
-        record_list: set[WalletCoinRecord] = await self.wallet_state_manager.get_spendable_coins_for_wallet(
-            self.id(), records
-        )
-
-        for record in record_list:
-            crcat: CRCAT = self.coin_record_to_crcat(record)
-            if crcat.lineage_proof is not None and not crcat.lineage_proof.is_none():
-                result.append(record)
-
-        return result
+    async def is_coin_spendable(self, record: WalletCoinRecord) -> bool:
+        crcat: CRCAT = self.coin_record_to_crcat(record)
+        if crcat.lineage_proof is not None and not crcat.lineage_proof.is_none():
+            return True
+        return False
 
-    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_confirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         if record_list is None:
             record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
                 self.id(), CoinType.CRCAT
@@ -350,7 +340,7 @@ class CRCATWallet(CATWallet):
         self.log.info(f"Confirmed balance for cat wallet {self.id()} is {amount}")
         return uint128(amount)
 
-    async def get_pending_approval_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_pending_approval_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         if record_list is None:
             record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
                 self.id(), CoinType.CRCAT_PENDING
@@ -398,7 +388,7 @@ class CRCATWallet(CATWallet):
         except Exception as e:  # pragma: no cover
             raise ValueError(f"Error parsing CRCAT metadata: {e}")
 
-    async def get_lineage_proof_for_coin(self, coin: Coin) -> Optional[LineageProof]:  # pragma: no cover
+    async def get_lineage_proof_for_coin(self, coin: Coin) -> LineageProof | None:  # pragma: no cover
         raise RuntimeError("get_lineage_proof_for_coin is a legacy method and is not available on CR-CAT wallets")
 
     async def _generate_unsigned_spendbundle(
@@ -406,8 +396,8 @@ class CRCATWallet(CATWallet):
         payments: list[CreateCoin],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        cat_discrepancy: Optional[tuple[int, Program, Program]] = None,  # (extra_delta, tail_reveal, tail_solution)
-        coins: Optional[set[Coin]] = None,
+        cat_discrepancy: tuple[int, Program, Program] | None = None,  # (extra_delta, tail_reveal, tail_solution)
+        coins: set[Coin] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         add_authorizations_to_cr_cats: bool = True,
     ) -> WalletSpendBundle:
@@ -480,7 +470,7 @@ class CRCATWallet(CATWallet):
             raise RuntimeError("CR-CATs cannot be spent without an appropriate VC")  # pragma: no cover
 
         # Loop through the coins we've selected and gather the information we need to spend them
-        vc: Optional[VerifiedCredential] = None
+        vc: VerifiedCredential | None = None
         vc_announcements_to_make: list[bytes] = []
         inner_spends: list[tuple[CRCAT, int, Program, Program]] = []
         first = True
@@ -502,7 +492,7 @@ class CRCATWallet(CATWallet):
                 cat_condition = UnknownCondition(
                     opcode=Program.to(51),
                     args=[
-                        Program.to(None),
+                        Program.NIL,
                         Program.to(-113),
                         tail_reveal,
                         tail_solution,
@@ -583,7 +573,7 @@ class CRCATWallet(CATWallet):
         expected_announcements, coin_spends, _ = CRCAT.spend_many(
             inner_spends,
             proof_of_inclusions,
-            Program.to(None),  # TODO: With more proofs checkers, this may need to be flexible. For now, it's hardcoded.
+            Program.NIL,  # TODO: With more proofs checkers, this may need to be flexible. For now, it's hardcoded.
             vc.proof_provider,
             vc.launcher_id,
             vc.wrap_inner_with_backdoor().get_tree_hash() if add_authorizations_to_cr_cats else None,
@@ -609,13 +599,13 @@ class CRCATWallet(CATWallet):
         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:
         # (extra_delta, tail_reveal, tail_solution)
-        cat_discrepancy: Optional[tuple[int, Program, Program]] = kwargs.get("cat_discrepancy", None)
+        cat_discrepancy: tuple[int, Program, Program] | None = kwargs.get("cat_discrepancy", None)
         add_authorizations_to_cr_cats: bool = kwargs.get("add_authorizations_to_cr_cats", True)
         if memos is None:
             memos = [[] for _ in range(len(puzzle_hashes))]
@@ -659,25 +649,17 @@ class CRCATWallet(CATWallet):
                 addition for tx in interface.side_effects.transactions for addition in tx.additions
             }
             tx_list = [
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=uint64(time.time()),
-                    to_puzzle_hash=payment.puzzle_hash,
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(payment.puzzle_hash),
-                    amount=payment.amount,
-                    fee_amount=fee,
-                    confirmed=False,
-                    sent=uint32(0),
-                    spend_bundle=spend_bundle if i == 0 else None,
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=self.id(),
+                    puzzle_hash=payment.puzzle_hash,
+                    amount=uint64(payment.amount),
+                    fee=fee,
+                    # semantics guarantee not None here
+                    spend_bundle=spend_bundle if i == 0 else None,  # type: ignore[arg-type]
                     additions=list(set(spend_bundle.additions()) - other_tx_additions) if i == 0 else [],
                     removals=list(set(spend_bundle.removals()) - other_tx_removals) if i == 0 else [],
-                    wallet_id=self.id(),
-                    sent_to=[],
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name() if i == 0 else payment.to_program().get_tree_hash(),
-                    memos=compute_memos(spend_bundle),
-                    valid_times=parse_timelock_info(extra_conditions),
+                    extra_conditions=extra_conditions,
                 )
                 for i, payment in enumerate(payments)
             ]
@@ -689,11 +671,11 @@ class CRCATWallet(CATWallet):
         min_amount_to_claim: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        min_coin_amount: Optional[uint64] = None,
-        max_coin_amount: Optional[uint64] = None,
-        excluded_coin_amounts: Optional[list[uint64]] = None,
-        reuse_puzhash: Optional[bool] = None,
+        coins: set[Coin] | None = None,
+        min_coin_amount: uint64 | None = None,
+        max_coin_amount: uint64 | None = None,
+        excluded_coin_amounts: list[uint64] | None = None,
+        reuse_puzhash: bool | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         # Select the relevant CR-CAT coins
@@ -723,7 +705,7 @@ class CRCATWallet(CATWallet):
 
         # Select the relevant VC coin
         vc_wallet: VCWallet = await self.wallet_state_manager.get_or_create_vc_wallet()
-        vc: Optional[VerifiedCredential] = await vc_wallet.get_vc_with_provider_in_and_proofs(
+        vc: VerifiedCredential | None = await vc_wallet.get_vc_with_provider_in_and_proofs(
             self.info.authorized_providers, self.info.proofs_checker.flags
         )
         if vc is None:  # pragma: no cover
@@ -756,7 +738,7 @@ class CRCATWallet(CATWallet):
                 for crcat, inner_puzhash in crcats_and_puzhashes
             ],
             proof_of_inclusions,
-            Program.to(None),  # TODO: With more proofs checkers, this may need to be flexible. For now, it's hardcoded.
+            Program.NIL,  # TODO: With more proofs checkers, this may need to be flexible. For now, it's hardcoded.
             vc.proof_provider,
             vc.launcher_id,
             vc.wrap_inner_with_backdoor().get_tree_hash(),
@@ -818,7 +800,7 @@ class CRCATWallet(CATWallet):
             AssetType(puzzle_driver.type()) == AssetType.CAT
             and puzzle_driver["tail"] == self.info.limitations_program_hash
         ):
-            inner_puzzle_driver: Optional[PuzzleInfo] = puzzle_driver.also()
+            inner_puzzle_driver: PuzzleInfo | None = puzzle_driver.also()
             if inner_puzzle_driver is None:
                 raise ValueError("Malformed puzzle driver passed to CRCATWallet.match_puzzle_info")  # pragma: no cover
             return (