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

chia/_tests/wallet/test_wallet_action_scope.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 import pytest
 from chia_rs import G2Element, Program
@@ -36,7 +35,7 @@ def test_back_and_forth_serialization() -> None:
 
 @dataclass
 class MockWalletStateManager:
-    most_recent_call: Optional[
+    most_recent_call: (
         tuple[
             list[TransactionRecord],
             bool,
@@ -45,8 +44,9 @@ class MockWalletStateManager:
             list[SigningResponse],
             list[WalletSpendBundle],
             list[SingletonRecord],
-        ],
-    ] = None
+        ]
+        | None
+    ) = None
 
     async def add_pending_transactions(
         self,

chia/_tests/wallet/test_wallet_blockchain.py

@@ -22,22 +22,22 @@ async def test_wallet_blockchain(
 ) -> None:
     [full_node_api], [(wallet_node, _)], bt = simulator_and_wallet
 
-    await add_blocks_in_batches(default_1000_blocks[:600], full_node_api.full_node)
+    await add_blocks_in_batches(default_1000_blocks[:700], full_node_api.full_node)
     resp = await full_node_api.request_proof_of_weight(
         full_node_protocol.RequestProofOfWeight(
-            uint32(default_1000_blocks[499].height + 1), default_1000_blocks[499].header_hash
+            uint32(default_1000_blocks[599].height + 1), default_1000_blocks[599].header_hash
         )
     )
     assert resp is not None
     resp_2 = await full_node_api.request_proof_of_weight(
         full_node_protocol.RequestProofOfWeight(
-            uint32(default_1000_blocks[460].height + 1), default_1000_blocks[460].header_hash
+            uint32(default_1000_blocks[560].height + 1), default_1000_blocks[560].header_hash
         )
     )
     assert resp_2 is not None
     resp_3 = await full_node_api.request_proof_of_weight(
         full_node_protocol.RequestProofOfWeight(
-            uint32(default_1000_blocks[505].height + 1), default_1000_blocks[505].header_hash
+            uint32(default_1000_blocks[605].height + 1), default_1000_blocks[605].header_hash
         )
     )
     assert resp_3 is not None
@@ -59,18 +59,18 @@ async def test_wallet_blockchain(
         await chain.new_valid_weight_proof(weight_proof, records)
         peak_block = await chain.get_peak_block()
         assert peak_block is not None
-        assert peak_block.height == 499
+        assert peak_block.height == 599
         assert chain.get_latest_timestamp() > 0
 
         await chain.new_valid_weight_proof(weight_proof_short, records_short)
         peak_block = await chain.get_peak_block()
         assert peak_block is not None
-        assert peak_block.height == 499
+        assert peak_block.height == 599
 
         await chain.new_valid_weight_proof(weight_proof_long, records_long)
         peak_block = await chain.get_peak_block()
         assert peak_block is not None
-        assert peak_block.height == 505
+        assert peak_block.height == 605
 
         header_blocks: list[HeaderBlock] = []
         for block in default_1000_blocks:
@@ -81,24 +81,24 @@ async def test_wallet_blockchain(
         print(res, err)
         assert res == AddBlockResult.DISCONNECTED_BLOCK
 
-        res, err = await chain.add_block(header_blocks[400])
+        res, err = await chain.add_block(header_blocks[500])
         print(res, err)
         assert res == AddBlockResult.ALREADY_HAVE_BLOCK
 
-        res, err = await chain.add_block(header_blocks[507])
+        res, err = await chain.add_block(header_blocks[607])
         print(res, err)
         assert res == AddBlockResult.DISCONNECTED_BLOCK
 
         res, err = await chain.add_block(
-            header_blocks[506].replace(challenge_chain_ip_proof=VDFProof(uint8(2), b"123", True))
+            header_blocks[606].replace(challenge_chain_ip_proof=VDFProof(uint8(2), b"123", True))
         )
         assert res == AddBlockResult.INVALID_BLOCK
 
         peak_block = await chain.get_peak_block()
         assert peak_block is not None
-        assert peak_block.height == 505
+        assert peak_block.height == 605
 
-        for header_block in header_blocks[506:]:
+        for header_block in header_blocks[606:]:
             res, err = await chain.add_block(header_block)
             assert res == AddBlockResult.NEW_PEAK
             peak_block = await chain.get_peak_block()

chia/_tests/wallet/test_wallet_coin_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field, replace
-from typing import Optional
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -14,7 +13,7 @@ from chia.util.streamable import Streamable, UInt32Range, UInt64Range, Versioned
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
 from chia.wallet.util.query_filter import AmountFilter, HashFilter
 from chia.wallet.util.wallet_types import CoinType, WalletType
-from chia.wallet.wallet_coin_record import WalletCoinRecord
+from chia.wallet.wallet_coin_record import WalletCoinRecord, WalletCoinRecordMetadataParsingError
 from chia.wallet.wallet_coin_store import CoinRecordOrder, GetCoinRecords, GetCoinRecordsResult, WalletCoinStore
 
 clawback_metadata = ClawbackMetadata(uint64(0), bytes32(b"1" * 32), bytes32(b"2" * 32))
@@ -134,7 +133,7 @@ class DummyWalletCoinRecords:
     ],
 )
 def test_wallet_coin_record_parsed_metadata_failures(invalid_record: WalletCoinRecord, error: str) -> None:
-    with pytest.raises(ValueError, match=error):
+    with pytest.raises(WalletCoinRecordMetadataParsingError, match=error):
         invalid_record.parsed_metadata()
 
 
@@ -632,7 +631,7 @@ get_coin_records_mixed_tests: list[tuple[GetCoinRecords, int, list[WalletCoinRec
 
 
 async def run_get_coin_records_test(
-    request: GetCoinRecords, total_count: Optional[int], coin_records: list[WalletCoinRecord]
+    request: GetCoinRecords, total_count: int | None, coin_records: list[WalletCoinRecord]
 ) -> None:
     async with DBConnection(1) as db_wrapper:
         store = await WalletCoinStore.create(db_wrapper)

chia/_tests/wallet/test_wallet_node.py

@@ -5,7 +5,7 @@ import sys
 import time
 import types
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs import CoinState, FullBlock, G1Element, PrivateKey
@@ -72,7 +72,7 @@ async def test_get_private_key_default_key(root_path_populated_with_config: Path
 @pytest.mark.anyio
 @pytest.mark.parametrize("fingerprint", [None, 1234567890])
 async def test_get_private_key_missing_key(
-    root_path_populated_with_config: Path, get_temp_keyring: Keychain, fingerprint: Optional[int]
+    root_path_populated_with_config: Path, get_temp_keyring: Keychain, fingerprint: int | None
 ) -> None:
     root_path = root_path_populated_with_config
     keychain = get_temp_keyring  # empty keyring
@@ -163,7 +163,7 @@ async def test_get_public_key_default_key(root_path_populated_with_config: Path,
 @pytest.mark.anyio
 @pytest.mark.parametrize("fingerprint", [None, 1234567890])
 async def test_get_public_key_missing_key(
-    root_path_populated_with_config: Path, get_temp_keyring: Keychain, fingerprint: Optional[int]
+    root_path_populated_with_config: Path, get_temp_keyring: Keychain, fingerprint: int | None
 ) -> None:
     root_path: Path = root_path_populated_with_config
     keychain: Keychain = get_temp_keyring  # empty keyring
@@ -357,7 +357,7 @@ def test_get_last_used_fingerprint_file_cant_read_win32(
         m.setattr(WindowsPath, "read_text", patched_pathlib_path_read_text)
 
         # Calling get_last_used_fingerprint() should not throw an exception
-        last_used_fingerprint: Optional[int] = node.get_last_used_fingerprint()
+        last_used_fingerprint: int | None = node.get_last_used_fingerprint()
 
         # Verify that the file is unreadable
         assert called_read_text is True
@@ -432,7 +432,7 @@ async def test_get_timestamp_for_height_from_peer(
 ) -> None:
     [full_node_api], [(wallet_node, wallet_server)], _ = simulator_and_wallet
 
-    async def get_timestamp(height: int) -> Optional[uint64]:
+    async def get_timestamp(height: int) -> uint64 | None:
         return await wallet_node.get_timestamp_for_height_from_peer(uint32(height), full_node_peer)
 
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
@@ -492,7 +492,7 @@ async def test_unique_puzzle_hash_subscriptions(simulator_and_wallet: OldSimulat
 @pytest.mark.anyio
 @pytest.mark.standard_block_tools
 async def test_get_balance(
-    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: list[FullBlock]
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_1000_blocks: list[FullBlock]
 ) -> None:
     [full_node_api], [(wallet_node, wallet_server)], _bt = simulator_and_wallet
     full_node_server = full_node_api.full_node.server
@@ -500,7 +500,7 @@ async def test_get_balance(
     def wallet_synced() -> bool:
         return full_node_server.node_id in wallet_node.synced_peers
 
-    async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
+    async def restart_with_fingerprint(fingerprint: int | None) -> None:
         wallet_node._close()
         await wallet_node._await_closed(shutting_down=False)
         await wallet_node._start_with_fingerprint(fingerprint=fingerprint)
@@ -512,7 +512,7 @@ async def test_get_balance(
     #       with that to a KeyError when applying the race cache if there are less than WEIGHT_PROOF_RECENT_BLOCKS
     #       blocks but we still have a peak stored in the DB. So we need to add enough blocks for a weight proof here to
     #       be able to restart the wallet in this test.
-    await add_blocks_in_batches(default_400_blocks, full_node_api.full_node)
+    await add_blocks_in_batches(default_1000_blocks[:600], full_node_api.full_node)
     # Initially there should be no sync and no balance
     assert not wallet_synced()
     assert await wallet_node.get_balance(wallet_id) == Balance()
@@ -611,7 +611,7 @@ async def test_transaction_send_cache(
 ) -> None:
     """
     The purpose of this test is to test that calling _resend_queue on the wallet node does not result in resending a
-    spend to a peer that has already recieved that spend and is currently processing it. It also tests that once we
+    spend to a peer that has already received that spend and is currently processing it. It also tests that once we
     have heard that the peer is done processing the spend, we _do_ properly resend it.
     """
     [full_node_api], [(wallet_node, wallet_server)], _ = simulator_and_wallet
@@ -625,7 +625,7 @@ async def test_transaction_send_cache(
 
     async def send_transaction(
         self: Self, request: wallet_protocol.SendTransaction, *, test: bool = False
-    ) -> Optional[Message]:
+    ) -> Message | None:
         logged_spends.append(request.transaction.name())
         return None
 
@@ -649,7 +649,7 @@ async def test_transaction_send_cache(
         with pytest.raises(AssertionError):
             await time_out_assert(5, logged_spends_len, 2)
 
-        # Tell the wallet that we recieved the spend (but failed to process it so it should send again)
+        # Tell the wallet that we received the spend (but failed to process it so it should send again)
         msg = make_msg(
             ProtocolMessageTypes.transaction_ack,
             wallet_protocol.TransactionAck(
@@ -688,7 +688,7 @@ async def test_wallet_node_bad_coin_state_ignore(
 
     async def register_for_coin_updates(
         self: Self, request: wallet_protocol.RegisterForCoinUpdates, *, test: bool = False
-    ) -> Optional[Message]:
+    ) -> Message | None:
         return make_msg(
             ProtocolMessageTypes.respond_to_coin_updates,
             wallet_protocol.RespondToCoinUpdates(
@@ -721,7 +721,7 @@ async def test_start_with_multiple_key_types(
 ) -> None:
     [_full_node_api], [(wallet_node, _wallet_server)], _bt = simulator_and_wallet
 
-    async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
+    async def restart_with_fingerprint(fingerprint: int | None) -> None:
         wallet_node._close()
         await wallet_node._await_closed(shutting_down=False)
         await wallet_node._start_with_fingerprint(fingerprint=fingerprint)
@@ -752,7 +752,7 @@ async def test_start_with_multiple_keys(
 ) -> None:
     [_full_node_api], [(wallet_node, _wallet_server)], _bt = simulator_and_wallet
 
-    async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
+    async def restart_with_fingerprint(fingerprint: int | None) -> None:
         wallet_node._close()
         await wallet_node._await_closed(shutting_down=False)
         await wallet_node._start_with_fingerprint(fingerprint=fingerprint)

chia/_tests/wallet/test_wallet_test_framework.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import pytest
 from chia_rs import BlockRecord
+from chia_rs.sized_bytes import bytes32
 
 from chia._tests.environments.wallet import (
     BalanceCheckingError,
@@ -145,7 +146,7 @@ async def test_balance_checking(
             )
         ]
     )
-    await CATWallet.get_or_create_wallet_for_cat(env_0.wallet_state_manager, env_0.xch_wallet, "00" * 32)
+    await CATWallet.get_or_create_wallet_for_cat(env_0.wallet_state_manager, env_0.xch_wallet, bytes32.zeros)
     with pytest.raises(KeyError, match="No wallet state for wallet id 2"):
         await env_0.check_balances()
 

chia/_tests/wallet/test_wallet_utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Collection
-from typing import Optional
 
 import pytest
 from chia_rs import Coin, CoinState
@@ -32,7 +31,7 @@ def assert_race_cache(cache: PeerRequestCache, expected_entries: dict[int, set[C
                 cache.get_race_cache(i)
 
 
-def dummy_coin_state(*, created_height: Optional[int], spent_height: Optional[int]) -> CoinState:
+def dummy_coin_state(*, created_height: int | None, spent_height: int | None) -> CoinState:
     return CoinState(
         Coin(bytes(b"0" * 32), bytes(b"0" * 32), uint64(0)),
         uint32.construct_optional(spent_height),
@@ -40,7 +39,7 @@ def dummy_coin_state(*, created_height: Optional[int], spent_height: Optional[in
     )
 
 
-def heights(coin_states: Collection[CoinState]) -> list[tuple[Optional[int], Optional[int]]]:
+def heights(coin_states: Collection[CoinState]) -> list[tuple[int | None, int | None]]:
     return [(coin_state.created_height, coin_state.spent_height) for coin_state in coin_states]
 
 

chia/_tests/wallet/vc_wallet/test_cr_outer_puzzle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
@@ -22,18 +20,18 @@ from chia.wallet.vc_wallet.cr_cat_drivers import construct_cr_layer
 
 def test_cat_outer_puzzle() -> None:
     authorized_providers: list[bytes32] = [bytes32.zeros, bytes32.zeros]
-    proofs_checker: Program = Program.to(None)
+    proofs_checker: Program = Program.NIL
     ACS: Program = Program.to(1)
     cr_puzzle: Program = construct_cr_layer(authorized_providers, proofs_checker, ACS)
     double_cr_puzzle: Program = construct_cr_layer(authorized_providers, proofs_checker, cr_puzzle)
     uncurried_cr_puzzle = uncurry_puzzle(double_cr_puzzle)
-    cr_driver: Optional[PuzzleInfo] = match_puzzle(uncurried_cr_puzzle)
+    cr_driver: PuzzleInfo | None = match_puzzle(uncurried_cr_puzzle)
 
     assert cr_driver is not None
     assert cr_driver.type() == "credential restricted"
     assert cr_driver["authorized_providers"] == authorized_providers
     assert cr_driver["proofs_checker"] == proofs_checker
-    inside_cr_driver: Optional[PuzzleInfo] = cr_driver.also()
+    inside_cr_driver: PuzzleInfo | None = cr_driver.also()
     assert inside_cr_driver is not None
     assert inside_cr_driver.type() == "credential restricted"
     assert inside_cr_driver["authorized_providers"] == authorized_providers

chia/_tests/wallet/vc_wallet/test_vc_lifecycle.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import itertools
-from typing import Optional
 
 import pytest
 from chia_rs import CoinSpend, G2Element
@@ -105,7 +104,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
         ].coin
 
         # With the honest coin, attempt to spend the non-eve case too soon
-        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Err | None] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -117,7 +116,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                 inner_puzzle_hash=ACS_PH,
                                 amount=uint64(acs_coin.amount),
                             ),
-                            Program.to(None),
+                            Program.NIL,
                             Program.to([[51, covenant_puzzle_hash, acs_coin.amount]]),
                         ),
                     ),
@@ -139,7 +138,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                 covenant_puzzle,
                                 solve_covenant_layer(
                                     LineageProof(parent_name=parent.parent_coin_info, amount=uint64(parent.amount)),
-                                    Program.to(None),
+                                    Program.NIL,
                                     Program.to([[51, covenant_puzzle_hash, cov.amount]]),
                                 ),
                             ),
@@ -173,7 +172,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                     inner_puzzle_hash=ACS_PH,
                                     amount=uint64(acs_cov.amount),
                                 ),
-                                Program.to(None),
+                                Program.NIL,
                                 Program.to([[51, covenant_puzzle_hash, new_acs_cov.amount]]),
                             ),
                         ),
@@ -213,7 +212,7 @@ async def test_did_tp(cost_logger: CostLogger) -> None:
         bad_data: bytes32 = bytes32.zeros
 
         # Try to update metadata and tp without any announcement
-        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Err | None] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -327,7 +326,7 @@ async def test_revocation_layer(cost_logger: CostLogger) -> None:
         )[0].coin
 
         # Reveal the wrong puzzle
-        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Err | None] = await client.push_tx(
             WalletSpendBundle(
                 [
                     make_spend(
@@ -335,7 +334,7 @@ async def test_revocation_layer(cost_logger: CostLogger) -> None:
                         p2_either_puzzle,
                         solve_revocation_layer(
                             ACS,
-                            Program.to(None),
+                            Program.NIL,
                             hidden=True,
                         ),
                     )
@@ -415,7 +414,7 @@ async def test_proofs_checker(cost_logger: CostLogger, num_proofs: int) -> None:
 
         block_height: uint32 = sim.block_height
         for i, proof_list in enumerate(itertools.permutations(flags, num_proofs)):
-            result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+            result: tuple[MempoolInclusionStatus, Err | None] = await client.push_tx(
                 cost_logger.add_cost(
                     f"Proofs Checker only - num_proofs: {num_proofs} - permutation: {i}",
                     WalletSpendBundle(
@@ -506,7 +505,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
             ACS_PH,
             [bytes32.zeros],
         )
-        result: tuple[MempoolInclusionStatus, Optional[Err]] = await client.push_tx(
+        result: tuple[MempoolInclusionStatus, Err | None] = await client.push_tx(
             cost_logger.add_cost(
                 "Launch VC",
                 WalletSpendBundle(
@@ -616,16 +615,16 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
             dpuz_1, launch_crcat_spend_1, cr_1 = CRCAT.launch(
                 cr_coin_1,
                 CreateCoin(ACS_PH, uint64(cr_coin_1.amount)),
-                Program.to(None),
-                Program.to(None),
+                Program.NIL,
+                Program.NIL,
                 AUTHORIZED_PROVIDERS,
                 proofs_checker.as_program(),
             )
             dpuz_2, launch_crcat_spend_2, cr_2 = CRCAT.launch(
                 cr_coin_2,
                 CreateCoin(ACS_PH, uint64(cr_coin_2.amount)),
-                Program.to(None),
-                Program.to(None),
+                Program.NIL,
+                Program.NIL,
                 AUTHORIZED_PROVIDERS,
                 proofs_checker.as_program(),
             )
@@ -700,7 +699,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
                     ),
                 ],
                 NEW_PROOFS if error != "use_malicious_cats" else MALICIOUS_PROOFS,
-                Program.to(None),
+                Program.NIL,
                 launcher_id,
                 vc.launcher_id,
                 vc.wrap_inner_with_backdoor().get_tree_hash(),

chia/_tests/wallet/vc_wallet/test_vc_wallet.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 import dataclasses
-from collections.abc import Awaitable
-from typing import Any, Callable, Optional
+from collections.abc import Awaitable, Callable
+from typing import Any, Literal
 
 import pytest
 from chia_rs import G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
-from typing_extensions import Literal
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert_not_none
@@ -31,7 +30,10 @@ from chia.wallet.vc_wallet.vc_store import VCProofs, VCRecord
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_request_types import (
+    Addition,
     CATSpend,
+    CRCATApprovePending,
+    CreateSignedTransaction,
     GetTransactions,
     GetWallets,
     VCAddProofs,
@@ -55,7 +57,7 @@ async def mint_cr_cat(
     full_node_api: FullNodeSimulator,
     tx_config: TXConfig,
     authorized_providers: list[bytes32] = [],
-    tail: Program = Program.to(None),
+    tail: Program = Program.NIL,
     proofs_checker: ProofsChecker = ProofsChecker(["foo", "bar"]),
 ) -> None:
     async with wallet_0.wallet_state_manager.new_action_scope(tx_config, push=True) as action_scope:
@@ -70,14 +72,16 @@ async def mint_cr_cat(
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
     tx = (
         await client_0.create_signed_transactions(
-            [
-                {
-                    "puzzle_hash": cat_puzzle.get_tree_hash(),
-                    "amount": CAT_AMOUNT_0,
-                }
-            ],
+            CreateSignedTransaction(
+                wallet_id=uint32(1),
+                additions=[
+                    Addition(
+                        puzzle_hash=cat_puzzle.get_tree_hash(),
+                        amount=CAT_AMOUNT_0,
+                    )
+                ],
+            ),
             tx_config,
-            wallet_id=1,
         )
     ).signed_tx
     spend_bundle = tx.spend_bundle
@@ -165,7 +169,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     }
 
     # Generate DID as an "authorized provider"
-    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         did_id: bytes32 = bytes32.from_hexstr(
             (
                 await DIDWallet.create_new_did_wallet(
@@ -173,9 +177,10 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
                 )
             ).get_my_DID()
         )
+    await full_node_api.wait_for_wallet_synced(wallet_node_0)
 
     # Mint a VC
-    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
     vc_record = (
         await client_0.vc_mint(
@@ -235,7 +240,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             WalletStateTransition(),
         ]
     )
-    new_vc_record: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
+    new_vc_record: VCRecord | None = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert new_vc_record is not None
 
     # Spend VC
@@ -291,7 +296,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
             WalletStateTransition(),
         ]
     )
-    vc_record_updated: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
+    vc_record_updated: VCRecord | None = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert vc_record_updated is not None
     assert vc_record_updated.vc.proof_hash == proof_root
 
@@ -463,8 +468,8 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
         await client_1.get_transactions(
             GetTransactions(
                 uint32(env_1.dealias_wallet_id("crcat")),
-                uint16(0),
-                uint16(1),
+                uint32(0),
+                uint32(1),
                 reverse=True,
                 type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CRCAT_PENDING]),
             )
@@ -505,10 +510,10 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
 
     # Claim the pending approval to our wallet
     await client_1.crcat_approve_pending(
-        env_1.dealias_wallet_id("crcat"),
-        uint64(90),
+        CRCATApprovePending(
+            wallet_id=env_1.dealias_wallet_id("crcat"), min_amount_to_claim=uint64(90), fee=uint64(90), push=True
+        ),
         wallet_environments.tx_config,
-        fee=uint64(90),
     )
     await wallet_environments.process_pending_states(
         [
@@ -748,7 +753,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
             )
         ]
     )
-    new_vc_record: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
+    new_vc_record: VCRecord | None = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert new_vc_record is not None
 
     # Test a negative case real quick (mostly unrelated)
@@ -804,7 +809,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
             )
         ]
     )
-    vc_record_revoked: Optional[VCRecord] = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
+    vc_record_revoked: VCRecord | None = (await client_0.vc_get(VCGet(vc_record.vc.launcher_id))).vc_record
     assert vc_record_revoked is None
     assert (
         len(await (await wallet_node_0.wallet_state_manager.get_or_create_vc_wallet()).store.get_unconfirmed_vcs()) == 0
@@ -849,7 +854,7 @@ async def test_cat_wallet_conversion(
 
     # Key point of test: create a normal CAT wallet first, and see if it gets converted to CR-CAT wallet
     await CATWallet.get_or_create_wallet_for_cat(
-        wallet_node_0.wallet_state_manager, wallet_0, Program.to(None).get_tree_hash().hex()
+        wallet_node_0.wallet_state_manager, wallet_0, Program.NIL.get_tree_hash()
     )
 
     did_id = bytes32.zeros
@@ -857,7 +862,7 @@ async def test_cat_wallet_conversion(
     await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
 
-    async def check_length(length: int, func: Callable[..., Awaitable[Any]], *args: Any) -> Optional[Literal[True]]:
+    async def check_length(length: int, func: Callable[..., Awaitable[Any]], *args: Any) -> Literal[True] | None:
         if len(await func(*args)) == length:
             return True
         return None  # pragma: no cover