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

chia/wallet/vc_wallet/cr_outer_puzzle.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Callable, Optional
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -16,14 +17,14 @@ from chia.wallet.vc_wallet.cr_cat_drivers import PROOF_FLAGS_CHECKER, construct_
 
 @dataclass(frozen=True)
 class CROuterPuzzle:
-    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _match: Callable[[UncurriedPuzzle], PuzzleInfo | None]
     _construct: Callable[[PuzzleInfo, Program], Program]
     _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
-    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Optional[Program]], Optional[Program]]
-    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Program | None], Program | None]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Program | None]
 
-    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
-        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle)
+    def match(self, puzzle: UncurriedPuzzle) -> PuzzleInfo | None:
+        args: tuple[list[bytes32], Program, Program] | None = match_cr_layer(puzzle)
         if args is None:
             return None
         authorized_providers, proofs_checker, inner_puzzle = args
@@ -38,29 +39,29 @@ class CROuterPuzzle:
         return PuzzleInfo(constructor_dict)
 
     def get_inner_puzzle(
-        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
-    ) -> Optional[Program]:
-        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle_reveal)
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = None
+    ) -> Program | None:
+        args: tuple[list[bytes32], Program, Program] | None = match_cr_layer(puzzle_reveal)
         if args is None:
             raise ValueError("This driver is not for the specified puzzle reveal")  # pragma: no cover
         _, _, inner_puzzle = args
         also = constructor.also()
         if also is not None:
-            deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
+            deep_inner_puzzle: Program | None = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
             return deep_inner_puzzle
         else:
             return inner_puzzle
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None:
         my_inner_solution: Program = solution.at("rrrrrrf")
         also = constructor.also()
         if also:
-            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            deep_inner_solution: Program | None = self._get_inner_solution(also, my_inner_solution)
             return deep_inner_solution
         else:
             return my_inner_solution
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None:
         return None
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:

chia/wallet/vc_wallet/vc_drivers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
-from typing import Any, Optional
+from typing import Any
 
 from chia_puzzles_py.programs import ACS_TRANSFER_PROGRAM as ACS_TRANSFER_PROGRAM_BYTES
 from chia_puzzles_py.programs import COVENANT_LAYER as COVENANT_LAYER_BYTES
@@ -89,7 +89,7 @@ def create_covenant_layer(initial_puzzle_hash: bytes32, parent_morpher: Program,
     )
 
 
-def match_covenant_layer(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, Program, Program]]:
+def match_covenant_layer(uncurried_puzzle: UncurriedPuzzle) -> tuple[bytes32, Program, Program] | None:
     if uncurried_puzzle.mod == COVENANT_LAYER:
         return (
             bytes32(uncurried_puzzle.args.at("f").as_atom()),
@@ -129,7 +129,7 @@ def create_tp_covenant_adapter(covenant_layer: Program) -> Program:
     return EML_TP_COVENANT_ADAPTER.curry(covenant_layer)
 
 
-def match_tp_covenant_adapter(uncurried_puzzle: UncurriedPuzzle) -> Optional[Program]:  # pragma: no cover
+def match_tp_covenant_adapter(uncurried_puzzle: UncurriedPuzzle) -> Program | None:  # pragma: no cover
     if uncurried_puzzle.mod == EML_TP_COVENANT_ADAPTER:
         return uncurried_puzzle.args.at("f")
     else:
@@ -152,7 +152,7 @@ def create_did_tp(
 EML_DID_TP_FULL_HASH = create_did_tp().get_tree_hash()
 
 
-def match_did_tp(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[()]]:
+def match_did_tp(uncurried_puzzle: UncurriedPuzzle) -> tuple[()] | None:
     if uncurried_puzzle.mod == EML_DID_TP:
         return ()
     else:
@@ -184,7 +184,7 @@ def create_revocation_layer(hidden_puzzle_hash: bytes32, inner_puzzle_hash: byte
     )
 
 
-def match_revocation_layer(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, bytes32]]:
+def match_revocation_layer(uncurried_puzzle: UncurriedPuzzle) -> tuple[bytes32, bytes32] | None:
     if uncurried_puzzle.mod == REVOCATION_LAYER:
         return bytes32(uncurried_puzzle.args.at("rf").as_atom()), bytes32(uncurried_puzzle.args.at("rrf").as_atom())
     else:
@@ -223,7 +223,7 @@ def create_eml_covenant_morpher(
 
 
 def construct_exigent_metadata_layer(
-    metadata: Optional[Program], transfer_program: Program, inner_puzzle: Program
+    metadata: Program | None, transfer_program: Program, inner_puzzle: Program
 ) -> Program:
     return EXTIGENT_METADATA_LAYER.curry(
         EXTIGENT_METADATA_LAYER_HASH, metadata, transfer_program, transfer_program.get_tree_hash(), inner_puzzle
@@ -237,7 +237,7 @@ class VCLineageProof(LineageProof, Streamable):
     The covenant layer for exigent metadata layers requires to be passed the previous parent's metadata too
     """
 
-    parent_proof_hash: Optional[bytes32] = None
+    parent_proof_hash: bytes32 | None = None
 
 
 def solve_std_vc_backdoor(
@@ -249,7 +249,7 @@ def solve_std_vc_backdoor(
     eml_lineage_proof: VCLineageProof,
     provider_innerpuzhash: bytes32,
     coin_id: bytes32,
-    announcement_nonce: Optional[bytes32] = None,
+    announcement_nonce: bytes32 | None = None,
 ) -> Program:
     """
     Solution to the STANDARD_BRICK_PUZZLE above. Requires proof info about pretty much the whole puzzle stack.
@@ -309,7 +309,7 @@ class VerifiedCredential(Streamable):
     launcher_id: bytes32
     inner_puzzle_hash: bytes32
     proof_provider: bytes32
-    proof_hash: Optional[bytes32]
+    proof_hash: bytes32 | None
 
     @classmethod
     def launch(
@@ -562,7 +562,7 @@ class VerifiedCredential(Streamable):
             amount=uint64(parent_coin.amount),
         )
         if layer_below_singleton == OWNERSHIP_LAYER_LAUNCHER:
-            proof_hash: Optional[bytes32] = None
+            proof_hash: bytes32 | None = None
             eml_lineage_proof: VCLineageProof = VCLineageProof(
                 parent_name=parent_coin.parent_coin_info, amount=uint64(parent_coin.amount)
             )
@@ -587,14 +587,14 @@ class VerifiedCredential(Streamable):
             )
             inner_puzzle_hash = bytes32(new_singleton_condition.at("rf").as_atom())
             magic_condition = next(c for c in conditions if c.at("f").as_int() == -10)
-            if magic_condition.at("rrrf") == Program.to(None):
+            if magic_condition.at("rrrf") == Program.NIL:
                 proof_hash_as_prog: Program = metadata_layer.args.at("rfr")
             elif magic_condition.at("rrrf").atom is not None:
                 raise ValueError("Specified VC was cleared")
             else:
                 proof_hash_as_prog = magic_condition.at("rrrfrrf")
 
-            proof_hash = None if proof_hash_as_prog == Program.to(None) else bytes32(proof_hash_as_prog.as_atom())
+            proof_hash = None if proof_hash_as_prog == Program.NIL else bytes32(proof_hash_as_prog.as_atom())
 
             proof_provider = bytes32(metadata_layer.args.at("rff").as_atom())
 
@@ -606,7 +606,7 @@ class VerifiedCredential(Streamable):
                     bytes32(uncurry_puzzle(metadata_layer.args.at("rrrrf")).args.at("rrf").as_atom()),
                 ).get_tree_hash(),
                 amount=uint64(parent_coin.amount),
-                parent_proof_hash=None if parent_proof_hash == Program.to(None) else parent_proof_hash,
+                parent_proof_hash=None if parent_proof_hash == Program.NIL else parent_proof_hash,
             )
 
         new_vc: Self = cls(
@@ -627,9 +627,9 @@ class VerifiedCredential(Streamable):
     # The methods in this section are useful for spending an existing VC
     def magic_condition_for_new_proofs(
         self,
-        new_proof_hash: Optional[bytes32],
+        new_proof_hash: bytes32 | None,
         provider_innerpuzhash: bytes32,
-        new_proof_provider: Optional[bytes32] = None,
+        new_proof_provider: bytes32 | None = None,
     ) -> Program:
         """
         Returns the 'magic' condition that can update the metadata with a new proof hash. Returning this condition from
@@ -690,9 +690,9 @@ class VerifiedCredential(Streamable):
         self,
         inner_puzzle: Program,
         inner_solution: Program,
-        new_proof_hash: Optional[bytes32] = None,
-        new_proof_provider: Optional[bytes32] = None,
-    ) -> tuple[Optional[CreatePuzzleAnnouncement], CoinSpend, VerifiedCredential]:
+        new_proof_hash: bytes32 | None = None,
+        new_proof_provider: bytes32 | None = None,
+    ) -> tuple[CreatePuzzleAnnouncement | None, CoinSpend, VerifiedCredential]:
         """
         Given an inner puzzle reveal and solution, spend the VC (potentially updating the proofs in the process).
         Note that the inner puzzle is already expected to output the 'magic' condition (which can be created above).
@@ -714,7 +714,7 @@ class VerifiedCredential(Streamable):
         )
 
         if new_proof_hash is not None:
-            expected_announcement: Optional[CreatePuzzleAnnouncement] = CreatePuzzleAnnouncement(
+            expected_announcement: CreatePuzzleAnnouncement | None = CreatePuzzleAnnouncement(
                 std_hash(
                     self.coin.name()
                     + Program.to(new_proof_hash).get_tree_hash()
@@ -744,7 +744,7 @@ class VerifiedCredential(Streamable):
         )
 
     def activate_backdoor(
-        self, provider_innerpuzhash: bytes32, announcement_nonce: Optional[bytes32] = None
+        self, provider_innerpuzhash: bytes32, announcement_nonce: bytes32 | None = None
     ) -> tuple[CreatePuzzleAnnouncement, CoinSpend]:
         """
         Activates the backdoor in the VC to revoke the credentials and remove the provider's DID.
@@ -778,7 +778,7 @@ class VerifiedCredential(Streamable):
         )
 
         expected_announcement: CreatePuzzleAnnouncement = CreatePuzzleAnnouncement(
-            std_hash(self.coin.name() + Program.to(None).get_tree_hash() + ACS_TRANSFER_PROGRAM.get_tree_hash())
+            std_hash(self.coin.name() + Program.NIL.get_tree_hash() + ACS_TRANSFER_PROGRAM.get_tree_hash())
         )
 
         return (
@@ -789,7 +789,7 @@ class VerifiedCredential(Streamable):
     ####################################################################################################################
 
     def _next_vc(
-        self, next_inner_puzzle_hash: bytes32, new_proof_hash: Optional[bytes32], next_amount: uint64
+        self, next_inner_puzzle_hash: bytes32, new_proof_hash: bytes32 | None, next_amount: uint64
     ) -> VerifiedCredential:
         """
         Private method that creates the next VC class instance.
@@ -830,7 +830,7 @@ class VerifiedCredential(Streamable):
 # inside of a CAT.
 @dataclass(frozen=True)
 class RevocationOuterPuzzle:
-    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+    def match(self, puzzle: UncurriedPuzzle) -> PuzzleInfo | None:
         args = match_revocation_layer(puzzle)
         if args is None:
             return None
@@ -842,17 +842,17 @@ class RevocationOuterPuzzle:
         return PuzzleInfo(constructor_dict)
 
     def get_inner_puzzle(
-        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
-    ) -> Optional[Program]:
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = None
+    ) -> Program | None:
         if solution is None:
             raise ValueError("Cannot get_inner_puzzle of revocation layer without solution")
 
         return solution.at("rf")
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None:
         return solution.at("rrf")
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None:
         return bytes32(constructor["hidden_puzzle_hash"])
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:

chia/wallet/vc_wallet/vc_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import dataclasses
 from functools import cmp_to_key
-from typing import Optional
 
 from aiosqlite import Row
 from chia_rs.sized_bytes import bytes32
@@ -24,7 +23,7 @@ class VCProofs:
 
     def as_program(self) -> Program:
         def byte_sort_pairs(f1: tuple[str, str], f2: tuple[str, str]) -> int:
-            return 1 if Program.to([10, (1, f1[0]), (1, f2[0])]).run([]) == Program.to(None) else -1
+            return 1 if Program.to([10, (1, f1[0]), (1, f2[0])]).run([]) == Program.NIL else -1
 
         prog: Program = Program.to(
             list_to_binary_tree(
@@ -55,7 +54,7 @@ class VCProofs:
         else:
             raise ValueError("Malformatted VCProofs program")  # pragma: no cover
 
-    def prove_keys(self, keys: list[str], tree: Optional[Program] = None) -> Program:
+    def prove_keys(self, keys: list[str], tree: Program | None = None) -> Program:
         if tree is None:
             tree = self.as_program()
 
@@ -177,7 +176,7 @@ class VCStore:
                 ),
             )
 
-    async def get_vc_record(self, launcher_id: bytes32) -> Optional[VCRecord]:
+    async def get_vc_record(self, launcher_id: bytes32) -> VCRecord | None:
         """
         Checks DB for VC with specified launcher_id and returns it.
         """
@@ -235,7 +234,7 @@ class VCStore:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             await (await conn.execute("DELETE FROM vc_records WHERE launcher_id=?", (launcher_id.hex(),))).close()
 
-    async def get_vc_record_by_coin_id(self, coin_id: bytes32) -> Optional[VCRecord]:
+    async def get_vc_record_by_coin_id(self, coin_id: bytes32) -> VCRecord | None:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute("SELECT * from vc_records WHERE coin_id=? LIMIT 1000", (coin_id.hex(),))
             row = await cursor.fetchone()
@@ -250,7 +249,7 @@ class VCStore:
                 "INSERT OR IGNORE INTO vc_proofs VALUES(?, ?)", (vc_proofs.root().hex(), bytes(vc_proofs.as_program()))
             )
 
-    async def get_proofs_for_root(self, root: bytes32) -> Optional[VCProofs]:
+    async def get_proofs_for_root(self, root: bytes32) -> VCProofs | None:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute("SELECT proofs FROM vc_proofs WHERE root=?", (root.hex(),))
             row = await cursor.fetchone()

chia/wallet/vc_wallet/vc_wallet.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import logging
-import time
 import traceback
-from typing import TYPE_CHECKING, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, TypeVar
 
 from chia_rs import CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -17,7 +16,6 @@ from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.coin_spend import make_spend
 from chia.util.casts import int_to_bytes
 from chia.util.hash import std_hash
-from chia.util.streamable import Streamable
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
@@ -25,16 +23,12 @@ from chia.wallet.conditions import (
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     UnknownCondition,
-    parse_timelock_info,
 )
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.puzzle_drivers import Solver
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import solution_for_delegated_puzzle
 from chia.wallet.trading.offer import Offer
-from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
-from chia.wallet.util.compute_memos import compute_memos
-from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.wallet_sync_utils import fetch_coin_spend_for_coin_state
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.vc_wallet.cr_cat_drivers import CRCAT, CRCATSpend, ProofsChecker, construct_pending_approval_state
@@ -65,7 +59,7 @@ class VCWallet:
         cls: type[_T_VCWallet],
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> _T_VCWallet:
         name = "VCWallet" if name is None else name
         new_wallet: _T_VCWallet = await cls.create(
@@ -83,7 +77,7 @@ class VCWallet:
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         wallet_info: WalletInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> _T_VCWallet:
         self = cls()
         self.wallet_state_manager = wallet_state_manager
@@ -100,16 +94,14 @@ class VCWallet:
     def id(self) -> uint32:
         return self.wallet_info.id
 
-    async def coin_added(
-        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[Streamable]
-    ) -> None:
+    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: object | None) -> None:
         """
         An unspent coin has arrived to our wallet. Get the parent spend to construct the current VerifiedCredential
         representation of the coin and add it to the DB if it's the newest version of the singleton.
         """
         # TODO Use coin_data instead of calling peer API
         wallet_node = self.wallet_state_manager.wallet_node
-        coin_states: Optional[list[CoinState]] = await wallet_node.get_coin_state([coin.parent_coin_info], peer=peer)
+        coin_states: list[CoinState] | None = await wallet_node.get_coin_state([coin.parent_coin_info], peer=peer)
         if coin_states is None:
             self.log.error(
                 f"Cannot find parent coin of the verified credential coin: {coin.name().hex()}"
@@ -142,7 +134,7 @@ class VCWallet:
         :param height:
         :return:
         """
-        vc_record: Optional[VCRecord] = await self.store.get_vc_record_by_coin_id(coin.name())
+        vc_record: VCRecord | None = await self.store.get_vc_record_by_coin_id(coin.name())
         if vc_record is not None:
             await self.store.delete_vc_record(vc_record.vc.launcher_id)
             self.wallet_state_manager.state_changed(
@@ -162,7 +154,7 @@ class VCWallet:
         self,
         provider_did: bytes32,
         action_scope: WalletActionScope,
-        inner_puzzle_hash: Optional[bytes32] = None,
+        inner_puzzle_hash: bytes32 | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> VCRecord:
@@ -196,35 +188,25 @@ class VCWallet:
             extra_conditions=extra_conditions,
         )
         for dpuz, coin in zip(dpuzs, coins):
-            solution = solution_for_delegated_puzzle(dpuz, Program.to(None))
+            solution = solution_for_delegated_puzzle(dpuz, Program.NIL)
             puzzle = await self.standard_wallet.puzzle_for_puzzle_hash(coin.puzzle_hash)
             coin_spends.append(make_spend(coin, puzzle, solution))
         spend_bundle = WalletSpendBundle(coin_spends, G2Element())
-        now = uint64(time.time())
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
         vc_record: VCRecord = VCRecord(vc, uint32(0))
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=now,
-                    to_puzzle_hash=inner_puzzle_hash,
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(inner_puzzle_hash),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=uint32(1),
+                    puzzle_hash=inner_puzzle_hash,
                     amount=uint64(1),
-                    fee_amount=uint64(fee),
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=spend_bundle,
                     additions=add_list,
                     removals=rem_list,
-                    wallet_id=uint32(1),
-                    sent_to=[],
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=compute_memos(spend_bundle),
-                    valid_times=parse_timelock_info(extra_conditions),
+                    extra_conditions=extra_conditions,
                 )
             )
 
@@ -236,17 +218,17 @@ class VCWallet:
         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:
-        new_proof_hash: Optional[bytes32] = kwargs.get(
+        new_proof_hash: bytes32 | None = kwargs.get(
             "new_proof_hash", None
         )  # Requires that this key possesses the DID to update the specified VC
-        provider_inner_puzhash: Optional[bytes32] = kwargs.get("provider_inner_puzhash", None)
-        self_revoke: Optional[bool] = kwargs.get("self_revoke", False)
-        potential_vc_id: Optional[bytes32] = kwargs.get("vc_id", None)
+        provider_inner_puzhash: bytes32 | None = kwargs.get("provider_inner_puzhash", None)
+        self_revoke: bool | None = kwargs.get("self_revoke", False)
+        potential_vc_id: bytes32 | None = kwargs.get("vc_id", None)
         """
         Entry point for two standard actions:
          - Cycle the singleton and make an announcement authorizing something
@@ -340,29 +322,19 @@ class VCWallet:
                 )  # pragma: no cover
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
-        now = uint64(time.time())
 
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=now,
-                    to_puzzle_hash=puzzle_hashes[0],
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(puzzle_hashes[0]),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=self.id(),
+                    puzzle_hash=puzzle_hashes[0],
                     amount=uint64(1),
-                    fee_amount=uint64(fee),
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=spend_bundle,
                     additions=add_list,
                     removals=rem_list,
-                    wallet_id=self.id(),
-                    sent_to=[],
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=compute_memos(spend_bundle),
-                    valid_times=parse_timelock_info(extra_conditions),
+                    extra_conditions=extra_conditions,
                 )
             )
 
@@ -408,7 +380,7 @@ class VCWallet:
         if fee > 0:
             coins.update(await self.standard_wallet.select_coins(fee, action_scope))
         sorted_coins: list[Coin] = sorted(coins, key=Coin.name)
-        sorted_coin_list: list[list[Union[bytes32, uint64]]] = [coin_as_list(c) for c in sorted_coins]
+        sorted_coin_list: list[list[bytes32 | uint64]] = [coin_as_list(c) for c in sorted_coins]
         nonce: bytes32 = SerializedProgram.to(sorted_coin_list).get_tree_hash()
         vc_announcement: AssertCoinAnnouncement = AssertCoinAnnouncement(asserted_id=vc.coin.name(), asserted_msg=nonce)
 
@@ -497,7 +469,7 @@ class VCWallet:
                         bytes32(cc.at("rf").as_atom()) == crcat_spend.crcat.inner_puzzle_hash
                     )
                     or (  # it's going to the pending state
-                        cc.at("rrr") != Program.to(None)
+                        cc.at("rrr") != Program.NIL
                         and cc.at("rrrf").atom is None
                         and bytes32(cc.at("rf").as_atom())
                         == construct_pending_approval_state(
@@ -542,7 +514,7 @@ class VCWallet:
                             solution=Program.from_serialized(spend_to_fix.solution)
                             .replace(
                                 ff=coin_args[coin_name][0],
-                                frf=Program.to(None),  # not general
+                                frf=Program.NIL,  # not general
                                 frrf=bytes32.from_hexstr(coin_args[coin_name][2]),
                                 frrrf=bytes32.from_hexstr(coin_args[coin_name][3]),
                                 frrrrf=bytes32.from_hexstr(coin_args[coin_name][4]),
@@ -604,7 +576,7 @@ class VCWallet:
             for rec in vc_records:
                 if rec.vc.proof_hash is None:
                     continue  # pragma: no cover
-                vc_proofs: Optional[VCProofs] = await self.store.get_proofs_for_root(rec.vc.proof_hash)
+                vc_proofs: VCProofs | None = await self.store.get_proofs_for_root(rec.vc.proof_hash)
                 if vc_proofs is None:
                     continue  # pragma: no cover
                 if all(proof in vc_proofs.key_value_pairs for proof in proofs):
@@ -612,7 +584,7 @@ class VCWallet:
         raise ValueError(f"No authorized VC has the correct proofs: {proofs}")  # pragma: no cover
 
     async def proof_of_inclusions_for_root_and_keys(self, root: bytes32, keys: list[str]) -> Program:
-        vc_proofs: Optional[VCProofs] = await self.store.get_proofs_for_root(root)
+        vc_proofs: VCProofs | None = await self.store.get_proofs_for_root(root)
         if vc_proofs is None:
             raise RuntimeError(f"No proofs exist for VC root: {root.hex()}")  # pragma: no cover
         else:
@@ -625,22 +597,22 @@ class VCWallet:
     ) -> set[Coin]:
         raise RuntimeError("VCWallet does not support select_coins()")  # pragma: no cover
 
-    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:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
-    async def get_unconfirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
-    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)  # pragma: no cover
 
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None) -> uint128:
         """This is the confirmed balance, which we set to 0 as the VC wallet doesn't have one."""
         return uint128(0)  # pragma: no cover