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

chia/_tests/wallet/cat_wallet/test_cat_wallet.py

@@ -19,7 +19,7 @@ from chia._tests.environments.wallet import (
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
 from chia.simulator.simulator_protocol import ReorgProtocol
 from chia.types.blockchain_format.coin import Coin, coin_as_list
-from chia.types.blockchain_format.program import NIL, Program
+from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.db_wrapper import DBWrapper2
@@ -82,7 +82,9 @@ async def mint_cat(
                 1,
                 [
                     CreateCoin(wrapped_inner_puzzle_hash, amount, memos=[inner_puzzle_hash]).to_program(),
-                    UnknownCondition(opcode=Program.to(51), args=[NIL, Program.to(-113), tail, NIL]).to_program(),
+                    UnknownCondition(
+                        opcode=Program.to(51), args=[Program.NIL, Program.to(-113), tail, Program.NIL]
+                    ).to_program(),
                 ],
             )
         )
@@ -112,14 +114,14 @@ async def mint_cat(
                             cat_addition,
                             tail_hash,
                             eve_inner_puzzle,
-                            NIL,
+                            Program.NIL,
                         )
                     ],
                 )
             )
 
     cat_wallet = await wallet_type.get_or_create_wallet_for_cat(
-        environment.wallet_state_manager, environment.xch_wallet, tail_hash.hex(), *extra_args
+        environment.wallet_state_manager, environment.xch_wallet, tail_hash, *extra_args
     )
 
     await wallet_environments.process_pending_states(
@@ -575,7 +577,7 @@ async def test_get_wallet_for_asset_id(wallet_environments: WalletTestFramework,
 
     # Test that the a default CAT will initialize correctly
     asset = DEFAULT_CATS[next(iter(DEFAULT_CATS))]
-    asset_id = asset["asset_id"]
+    asset_id = bytes32.from_hexstr(asset["asset_id"])
     if wallet_type is RCATWallet:
         extra_args: Any = (bytes32.zeros,)
     else:
@@ -1087,7 +1089,9 @@ async def test_cat_max_amount_send(wallet_environments: WalletTestFramework, wal
         for i in range(1, 50):
             amounts.append(uint64(i))
             puzzle_hashes.append(cat_2_hash)
-        spent_coin = (await cat_wallet.get_cat_spendable_coins())[0].coin
+        spent_coin = next(
+            iter(await cat_wallet.wallet_state_manager.get_spendable_coins_for_wallet(cat_wallet.id()))
+        ).coin
         await cat_wallet.generate_signed_transaction(amounts, puzzle_hashes, action_scope, coins={spent_coin})
 
     await wallet_environments.process_pending_states(
@@ -1118,7 +1122,7 @@ async def test_cat_max_amount_send(wallet_environments: WalletTestFramework, wal
     )
 
     async def check_all_there() -> bool:
-        spendable = await cat_wallet.get_cat_spendable_coins()
+        spendable = await cat_wallet.wallet_state_manager.get_spendable_coins_for_wallet(cat_wallet.id())
         spendable_name_set = set()
         for record in spendable:
             spendable_name_set.add(record.coin.name())
@@ -1411,7 +1415,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
     if wallet_type is RCATWallet:
         inner_puzhash = create_revocation_layer(bytes32.zeros, inner_puzhash).get_tree_hash()
     puzzlehash_unhardened = construct_cat_puzzle(
-        CAT_MOD, Program.to(None).get_tree_hash(), inner_puzhash
+        CAT_MOD, Program.NIL.get_tree_hash(), inner_puzhash
     ).get_tree_hash_precalc(inner_puzhash)
     change_derivation = DerivationRecord(
         uint32(0), puzzlehash_unhardened, pubkey_unhardened, WalletType.CAT, uint32(2), False
@@ -1422,7 +1426,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
         our_puzzle = await action_scope.get_puzzle(wallet.wallet_state_manager)
     cat_puzzle = construct_cat_puzzle(
         CAT_MOD,
-        Program.to(None).get_tree_hash(),
+        Program.NIL.get_tree_hash(),
         Program.to(1),
     )
     addr = encode_puzzle_hash(cat_puzzle.get_tree_hash(), "txch")
@@ -1451,7 +1455,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
     cat_coin = next(c for c in spend_bundle.additions() if c.amount == cat_amount_0)
     next_coin = Coin(
         cat_coin.name(),
-        construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle).get_tree_hash(),
+        construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), our_puzzle).get_tree_hash(),
         cat_amount_0,
     )
     eve_spend, _ = await wsm.sign_bundle(
@@ -1478,7 +1482,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
             ),
             make_spend(
                 next_coin,
-                construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle),
+                construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), our_puzzle),
                 Program.to(
                     [
                         [
@@ -1647,7 +1651,9 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
     # Let's test that continuing to melt this CAT results in the correct balance changes
     for _ in range(5):
         tx_amount -= 1
-        new_coin = (await cat_wallet.get_cat_spendable_coins())[0].coin
+        new_coin = next(
+            iter(await cat_wallet.wallet_state_manager.get_spendable_coins_for_wallet(cat_wallet.id()))
+        ).coin
         new_spend = unsigned_spend_bundle_for_spendable_cats(
             CAT_MOD,
             [
@@ -1660,7 +1666,7 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
                         conditions=(
                             UnknownCondition(
                                 opcode=Program.to(51),
-                                args=[Program.to(None), Program.to(-113), Program.to(ACS_TAIL), Program.to(None)],
+                                args=[Program.NIL, Program.to(-113), Program.to(ACS_TAIL), Program.NIL],
                             ),
                         ),
                     ),

chia/_tests/wallet/cat_wallet/test_offer_lifecycle.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs import G2Element
@@ -43,8 +43,8 @@ def str_to_cat_hash(tail_str: str) -> bytes32:
 
 # This method takes a dictionary of strings mapping to amounts and generates the appropriate CAT/XCH coins
 async def generate_coins(
-    sim: SpendSim, sim_client: SimClient, requested_coins: dict[Optional[str], list[int]]
-) -> dict[Optional[str], list[Coin]]:
+    sim: SpendSim, sim_client: SimClient, requested_coins: dict[str | None, list[int]]
+) -> dict[str | None, list[Coin]]:
     await sim.farm_block(acs_ph)
     parent_coin = next(cr.coin for cr in await sim_client.get_coin_records_by_puzzle_hash(acs_ph))
 
@@ -85,7 +85,7 @@ async def generate_coins(
     await sim.farm_block()
 
     # Search for all of the coins and put them into a dictionary
-    coin_dict: dict[Optional[str], list[Coin]] = {}
+    coin_dict: dict[str | None, list[Coin]] = {}
     for tail_str, _ in requested_coins.items():
         if tail_str:
             tail_hash = str_to_tail_hash(tail_str)
@@ -113,7 +113,7 @@ def generate_secure_bundle(
     selected_coins: list[Coin],
     announcements: list[AssertPuzzleAnnouncement],
     offered_amount: uint64,
-    tail_str: Optional[str] = None,
+    tail_str: str | None = None,
 ) -> WalletSpendBundle:
     announcement_assertions = [a.to_program() for a in announcements]
     selected_coin_amount = sum(c.amount for c in selected_coins)
@@ -173,10 +173,10 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
                 {"type": AssetType.CAT.value, "tail": "0x" + str_to_tail_hash("blue").hex()}
             ),
         }
-        driver_dict_as_infos = {key.hex(): value.info for key, value in driver_dict.items()}
+        driver_dict_as_summary = {key.hex(): value for key, value in driver_dict.items()}
 
         # Create an XCH Offer for RED
-        chia_requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {
+        chia_requested_payments: dict[bytes32 | None, list[CreateCoin]] = {
             str_to_tail_hash("red"): [
                 CreateCoin(acs_ph, uint64(100), [b"memo"]),
                 CreateCoin(acs_ph, uint64(200), [b"memo"]),
@@ -191,7 +191,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         # Create a RED Offer for XCH
         red_coins_1 = red_coins[0:1]
         red_coins_2 = red_coins[1:]
-        red_requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {
+        red_requested_payments: dict[bytes32 | None, list[CreateCoin]] = {
             None: [CreateCoin(acs_ph, uint64(300), [b"red memo"]), CreateCoin(acs_ph, uint64(350), [b"red memo"])]
         }
         red_notarized_payments = Offer.notarize_payments(red_requested_payments, red_coins_1)
@@ -202,7 +202,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         red_offer = Offer(red_notarized_payments, red_secured_bundle, driver_dict)
         assert not red_offer.is_valid()
 
-        red_requested_payments_2: dict[Optional[bytes32], list[CreateCoin]] = {
+        red_requested_payments_2: dict[bytes32 | None, list[CreateCoin]] = {
             None: [CreateCoin(acs_ph, uint64(50), [b"red memo"])]
         }
         red_notarized_payments_2 = Offer.notarize_payments(red_requested_payments_2, red_coins_2)
@@ -220,7 +220,7 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         assert new_offer.is_valid()
 
         # Create yet another offer of BLUE for XCH and RED
-        blue_requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {
+        blue_requested_payments: dict[bytes32 | None, list[CreateCoin]] = {
             None: [CreateCoin(acs_ph, uint64(200), [b"blue memo"])],
             str_to_tail_hash("red"): [CreateCoin(acs_ph, uint64(50), [b"blue memo"])],
         }
@@ -239,9 +239,9 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         }
         assert new_offer.get_requested_amounts() == {None: 900, str_to_tail_hash("red"): 350}
         assert new_offer.summary() == (
-            {"xch": 1000, str_to_tail_hash("red").hex(): 350, str_to_tail_hash("blue").hex(): 2000},
-            {"xch": 900, str_to_tail_hash("red").hex(): 350},
-            driver_dict_as_infos,
+            {"xch": "1000", str_to_tail_hash("red").hex(): "350", str_to_tail_hash("blue").hex(): "2000"},
+            {"xch": "900", str_to_tail_hash("red").hex(): "350"},
+            driver_dict_as_summary,
             ConditionValidTimes(),
         )
         assert new_offer.get_pending_amounts() == {

chia/_tests/wallet/cat_wallet/test_trades.py

@@ -28,7 +28,7 @@ from chia.wallet.outer_puzzles import AssetType
 from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.trade_manager import TradeManager
 from chia.wallet.trade_record import TradeRecord
-from chia.wallet.trading.offer import Offer, OfferSummary
+from chia.wallet.trading.offer import Offer, OfferSpecification
 from chia.wallet.trading.trade_status import TradeStatus
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
@@ -36,7 +36,14 @@ from chia.wallet.vc_wallet.cr_cat_drivers import ProofsChecker
 from chia.wallet.vc_wallet.cr_cat_wallet import CRCATWallet
 from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.wallet_node import WalletNode
-from chia.wallet.wallet_request_types import VCAddProofs, VCGetList, VCGetProofsForRoot, VCMint, VCSpend
+from chia.wallet.wallet_request_types import (
+    CRCATApprovePending,
+    VCAddProofs,
+    VCGetList,
+    VCGetProofsForRoot,
+    VCMint,
+    VCSpend,
+)
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
@@ -119,7 +126,7 @@ async def test_cat_trades(
 
     trusted = len(wallet_node_maker.config["trusted_peers"]) > 0
 
-    # Because making/taking CR-CATs is asymetrical, approving the hacked together aggregation test will fail
+    # Because making/taking CR-CATs is asymmetrical, approving the hacked together aggregation test will fail
     # The taker is "making" offers that it is approving with a VC which multiple actual makers would never do
     # This is really a test of CATOuterPuzzle anyways and is not correlated with any of our params
     test_aggregation = not credential_restricted and not wallet_environments.tx_config.reuse_puzhash and trusted
@@ -173,7 +180,7 @@ async def test_cat_trades(
         cat_wallet_maker: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
             wallet_node_maker.wallet_state_manager,
             wallet_maker,
-            tail_maker.get_tree_hash().hex(),
+            tail_maker.get_tree_hash(),
             None,
             authorized_providers,
             proofs_checker_maker,
@@ -181,7 +188,7 @@ async def test_cat_trades(
         new_cat_wallet_taker: CATWallet = await CRCATWallet.get_or_create_wallet_for_cat(
             wallet_node_taker.wallet_state_manager,
             wallet_taker,
-            tail_taker.get_tree_hash().hex(),
+            tail_taker.get_tree_hash(),
             None,
             authorized_providers,
             proofs_checker_taker,
@@ -415,29 +422,29 @@ async def test_cat_trades(
     await env_maker.check_balances()
 
     # Create the trade parameters
-    chia_for_cat: OfferSummary = {
+    chia_for_cat: OfferSpecification = {
         wallet_maker.id(): -1,
-        bytes32.from_hexstr(new_cat_wallet_maker.get_asset_id()): 2,  # This is the CAT that the taker made
+        new_cat_wallet_maker.get_asset_id(): 2,  # This is the CAT that the taker made
     }
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         wallet_maker.id(): 3,
         cat_wallet_maker.id(): -4,  # The taker has no knowledge of this CAT yet
     }
-    cat_for_cat: OfferSummary = {
-        bytes32.from_hexstr(cat_wallet_maker.get_asset_id()): -5,
+    cat_for_cat: OfferSpecification = {
+        cat_wallet_maker.get_asset_id(): -5,
         new_cat_wallet_maker.id(): 6,
     }
-    chia_for_multiple_cat: OfferSummary = {
+    chia_for_multiple_cat: OfferSpecification = {
         wallet_maker.id(): -7,
         cat_wallet_maker.id(): 8,
         new_cat_wallet_maker.id(): 9,
     }
-    multiple_cat_for_chia: OfferSummary = {
+    multiple_cat_for_chia: OfferSpecification = {
         wallet_maker.id(): 10,
         cat_wallet_maker.id(): -11,
         new_cat_wallet_maker.id(): -12,
     }
-    chia_and_cat_for_cat: OfferSummary = {
+    chia_and_cat_for_cat: OfferSpecification = {
         wallet_maker.id(): -13,
         cat_wallet_maker.id(): -14,
         new_cat_wallet_maker.id(): 15,
@@ -445,10 +452,10 @@ async def test_cat_trades(
 
     driver_dict: dict[bytes32, PuzzleInfo] = {}
     for wallet in (cat_wallet_maker, new_cat_wallet_maker):
-        asset_id: str = wallet.get_asset_id()
+        asset_id = wallet.get_asset_id()
         driver_item: dict[str, Any] = {
             "type": AssetType.CAT.value,
-            "tail": "0x" + asset_id,
+            "tail": "0x" + asset_id.hex(),
         }
         if credential_restricted:
             driver_item["also"] = {
@@ -460,7 +467,7 @@ async def test_cat_trades(
                     else proofs_checker_taker.as_program()
                 ),
             }
-        driver_dict[bytes32.from_hexstr(asset_id)] = PuzzleInfo(driver_item)
+        driver_dict[asset_id] = PuzzleInfo(driver_item)
 
     trade_manager_maker = env_maker.wallet_state_manager.trade_manager
     trade_manager_taker = env_taker.wallet_state_manager.trade_manager
@@ -559,7 +566,7 @@ async def test_cat_trades(
                         "pending_coin_removal_count": 1,
                         "<=#spendable_balance": -2,
                         "<=#max_send_amount": -2,
-                        # Unconfirmed balance doesn't change because receiveing 1 XCH and spending 1 in fee
+                        # Unconfirmed balance doesn't change because receiving 1 XCH and spending 1 in fee
                         "unconfirmed_wallet_balance": 0,
                         ">=#pending_change": 1,  # any amount increase
                     },
@@ -586,7 +593,7 @@ async def test_cat_trades(
                         "unspent_coin_count": 1,
                         ">#spendable_balance": 0,
                         ">#max_send_amount": 0,
-                        # Confirmed balance doesn't change because receiveing 1 XCH and spending 1 in fee
+                        # Confirmed balance doesn't change because receiving 1 XCH and spending 1 in fee
                         "confirmed_wallet_balance": 0,
                         "<=#pending_change": 1,  # any amount decrease
                     },
@@ -613,8 +620,7 @@ async def test_cat_trades(
 
     if credential_restricted:
         await client_maker.crcat_approve_pending(
-            new_cat_wallet_maker.id(),
-            uint64(2),
+            CRCATApprovePending(wallet_id=new_cat_wallet_maker.id(), min_amount_to_claim=uint64(2), push=True),
             wallet_environments.tx_config,
         )
 
@@ -953,8 +959,7 @@ async def test_cat_trades(
 
     if credential_restricted:
         await client_maker.crcat_approve_pending(
-            new_cat_wallet_maker.id(),
-            uint64(6),
+            CRCATApprovePending(wallet_id=new_cat_wallet_maker.id(), min_amount_to_claim=uint64(6), push=True),
             wallet_environments.tx_config,
         )
 
@@ -1191,8 +1196,7 @@ async def test_cat_trades(
 
     if credential_restricted:
         await client_maker.crcat_approve_pending(
-            cat_wallet_maker.id(),
-            uint64(8),
+            CRCATApprovePending(wallet_id=cat_wallet_maker.id(), min_amount_to_claim=uint64(8), push=True),
             wallet_environments.tx_config,
         )
 
@@ -1238,8 +1242,7 @@ async def test_cat_trades(
         )
 
         await client_maker.crcat_approve_pending(
-            new_cat_wallet_maker.id(),
-            uint64(9),
+            CRCATApprovePending(wallet_id=new_cat_wallet_maker.id(), min_amount_to_claim=uint64(9), push=True),
             wallet_environments.tx_config,
         )
 
@@ -1561,8 +1564,7 @@ async def test_cat_trades(
 
     if credential_restricted:
         await client_maker.crcat_approve_pending(
-            new_cat_wallet_maker.id(),
-            uint64(15),
+            CRCATApprovePending(wallet_id=new_cat_wallet_maker.id(), min_amount_to_claim=uint64(15), push=True),
             wallet_environments.tx_config,
         )
 
@@ -1673,12 +1675,12 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework, wall
         ]
     )
 
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: 1,
         env_maker.wallet_aliases["cat"]: -2,
     }
 
-    chia_for_cat: OfferSummary = {
+    chia_for_cat: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: -3,
         env_maker.wallet_aliases["cat"]: 4,
     }
@@ -1805,7 +1807,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework, wall
     # This take should fail since we have no CATs to fulfill it with
     with pytest.raises(
         ValueError,
-        match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id()} to fulfill offer",
+        match=f"Do not have a wallet for asset ID: {cat_wallet_maker.get_asset_id().hex()} to fulfill offer",
     ):
         async with env_taker.wallet_state_manager.new_action_scope(
             wallet_environments.tx_config, push=False
@@ -1846,7 +1848,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework, wall
     await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
 
     # Now let's test the case where two coins need to be spent in order to cancel
-    chia_and_cat_for_something: OfferSummary = {
+    chia_and_cat_for_something: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: -5,
         env_maker.wallet_aliases["cat"]: -6,
         bytes32.zeros: 1,  # Doesn't matter
@@ -1991,7 +1993,7 @@ async def test_trade_conflict(wallet_environments: WalletTestFramework, wallet_t
         ]
     )
 
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: 1000,
         env_maker.wallet_aliases["cat"]: -4,
     }
@@ -2182,7 +2184,7 @@ async def test_trade_bad_spend(wallet_environments: WalletTestFramework, wallet_
         ]
     )
 
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: 1000,
         env_maker.wallet_aliases["cat"]: -4,
     }
@@ -2304,7 +2306,7 @@ async def test_trade_high_fee(wallet_environments: WalletTestFramework, wallet_t
         ]
     )
 
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: 1000,
         env_maker.wallet_aliases["cat"]: -4,
     }
@@ -2449,15 +2451,15 @@ async def test_aggregated_trade_state(wallet_environments: WalletTestFramework,
         ]
     )
 
-    cat_for_chia: OfferSummary = {
+    cat_for_chia: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: 2,
         env_maker.wallet_aliases["cat"]: -2,
     }
-    chia_for_cat: OfferSummary = {
+    chia_for_cat: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: -1,
         env_maker.wallet_aliases["cat"]: 1,
     }
-    combined_summary: OfferSummary = {
+    combined_summary: OfferSpecification = {
         env_maker.wallet_aliases["xch"]: cat_for_chia[env_maker.wallet_aliases["xch"]]
         + chia_for_cat[env_maker.wallet_aliases["xch"]],
         env_maker.wallet_aliases["cat"]: cat_for_chia[env_maker.wallet_aliases["cat"]]

chia/_tests/wallet/clawback/test_clawback_lifecycle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
 from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
@@ -48,8 +46,8 @@ async def do_spend(
     sim: SpendSim,
     sim_client: SimClient,
     spend_bundle: WalletSpendBundle,
-    expected_result: tuple[MempoolInclusionStatus, Optional[Err]],
-    cost_logger: Optional[CostLogger] = None,
+    expected_result: tuple[MempoolInclusionStatus, Err | None],
+    cost_logger: CostLogger | None = None,
     cost_log_msg: str = "",
 ) -> int:
     if cost_logger is not None:

chia/_tests/wallet/conftest.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 import contextlib
 import unittest
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import AsyncExitStack
 from dataclasses import replace
-from typing import Any, Callable, Optional
+from typing import Any
 
 import pytest
 from chia_rs import (
@@ -34,7 +34,7 @@ from chia.wallet.wallet_state_manager import WalletStateManager
 @pytest.fixture(scope="function", autouse=True)
 def block_is_current_at(monkeypatch: pytest.MonkeyPatch) -> None:
     def make_new_synced(func: Callable[..., Awaitable[bool]]) -> Any:
-        async def mocked_synced(self: Any, block_is_current_at: Optional[uint64] = uint64(0)) -> bool:
+        async def mocked_synced(self: Any, block_is_current_at: uint64 | None = uint64(0)) -> bool:
             return await func(self, block_is_current_at)
 
         return mocked_synced
@@ -83,11 +83,11 @@ async def ignore_block_validation(
         return new_create
 
     def run_block(
-        block: FullBlock, prev_generators: list[bytes], constants: ConsensusConstants
-    ) -> tuple[Optional[int], Optional[SpendBundleConditions]]:
+        block: FullBlock, prev_generators: list[bytes], prev_tx_height: uint32, constants: ConsensusConstants
+    ) -> tuple[int | None, SpendBundleConditions | None]:
         assert block.transactions_generator is not None
         assert block.transactions_info is not None
-        flags = get_flags_for_height_and_constants(block.height, constants) | DONT_VALIDATE_SIGNATURE
+        flags = get_flags_for_height_and_constants(prev_tx_height, constants) | DONT_VALIDATE_SIGNATURE
         if block.height >= constants.HARD_FORK_HEIGHT:
             run_block = run_block_generator2
         else:

chia/_tests/wallet/db_wallet/test_db_graftroot.py

@@ -31,7 +31,7 @@ ACS = Program.fromhex(
 )
 ACS_PH = ACS.get_tree_hash()
 
-NIL_PH = Program.to(None).get_tree_hash()
+NIL_PH = Program.NIL.get_tree_hash()
 
 
 @pytest.mark.anyio

chia/_tests/wallet/db_wallet/test_dl_offers.py

@@ -8,7 +8,7 @@ from chia_rs.sized_ints import uint64
 
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.data_layer.data_layer_wallet import DataLayerWallet
+from chia.data_layer.data_layer_wallet import DataLayerSummary, DataLayerWallet, SingletonDependencies, SingletonSummary
 from chia.wallet.puzzle_drivers import Solver
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer
@@ -179,20 +179,20 @@ async def test_dl_offers(wallet_environments: WalletTestFramework) -> None:
     assert success is True
     assert offer_maker is not None
 
-    assert await trade_manager_taker.get_offer_summary(Offer.from_bytes(offer_maker.offer)) == {
-        "offered": [
-            {
-                "launcher_id": launcher_id_maker.hex(),
-                "new_root": maker_root.hex(),
-                "dependencies": [
-                    {
-                        "launcher_id": launcher_id_taker.hex(),
-                        "values_to_prove": [taker_branch.hex()],
-                    }
+    assert await trade_manager_taker.get_dl_offer_summary(Offer.from_bytes(offer_maker.offer)) == DataLayerSummary(
+        offered=[
+            SingletonSummary(
+                launcher_id=launcher_id_maker,
+                new_root=maker_root,
+                dependencies=[
+                    SingletonDependencies(
+                        launcher_id=launcher_id_taker,
+                        values_to_prove=[taker_branch],
+                    )
                 ],
-            }
+            )
         ]
-    }
+    )
 
     [_maker_offer], signing_response = await wsm_maker.sign_offers([Offer.from_bytes(offer_maker.offer)])
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -231,30 +231,30 @@ async def test_dl_offers(wallet_environments: WalletTestFramework) -> None:
         )
     assert offer_taker is not None
 
-    assert await trade_manager_maker.get_offer_summary(Offer.from_bytes(offer_taker.offer)) == {
-        "offered": [
-            {
-                "launcher_id": launcher_id_maker.hex(),
-                "new_root": maker_root.hex(),
-                "dependencies": [
-                    {
-                        "launcher_id": launcher_id_taker.hex(),
-                        "values_to_prove": [taker_branch.hex()],
-                    }
+    assert await trade_manager_maker.get_dl_offer_summary(Offer.from_bytes(offer_taker.offer)) == DataLayerSummary(
+        offered=[
+            SingletonSummary(
+                launcher_id=launcher_id_maker,
+                new_root=maker_root,
+                dependencies=[
+                    SingletonDependencies(
+                        launcher_id=launcher_id_taker,
+                        values_to_prove=[taker_branch],
+                    )
                 ],
-            },
-            {
-                "launcher_id": launcher_id_taker.hex(),
-                "new_root": taker_root.hex(),
-                "dependencies": [
-                    {
-                        "launcher_id": launcher_id_maker.hex(),
-                        "values_to_prove": [maker_branch.hex()],
-                    }
+            ),
+            SingletonSummary(
+                launcher_id=launcher_id_taker,
+                new_root=taker_root,
+                dependencies=[
+                    SingletonDependencies(
+                        launcher_id=launcher_id_maker,
+                        values_to_prove=[maker_branch],
+                    ),
                 ],
-            },
+            ),
         ]
-    }
+    )
 
     await wallet_environments.process_pending_states(
         [

chia/_tests/wallet/did_wallet/test_did.py

@@ -34,7 +34,14 @@ from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_action_scope import WalletActionScope
 from chia.wallet.wallet_node import WalletNode
-from chia.wallet.wallet_request_types import DIDFindLostDID, DIDGetCurrentCoinInfo, DIDGetInfo
+from chia.wallet.wallet_request_types import (
+    CreateNewWallet,
+    CreateNewWalletType,
+    DIDFindLostDID,
+    DIDGetCurrentCoinInfo,
+    DIDGetInfo,
+    DIDType,
+)
 from chia.wallet.wallet_rpc_api import WalletRpcApi
 
 
@@ -284,11 +291,14 @@ async def test_creation_from_backup_file(wallet_environments: WalletTestFramewor
     backup_data = did_wallet_1.create_backup()
 
     # Wallet2 recovers DIDWallet2 to a new set of keys
-    await env_2.rpc_client.create_new_did_wallet(
-        uint64(1),
-        DEFAULT_TX_CONFIG,
-        type="recovery",
-        backup_data=backup_data,
+    await env_2.rpc_client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.DID_WALLET,
+            did_type=DIDType.RECOVERY,
+            backup_data=backup_data,
+            push=True,
+        ),
+        wallet_environments.tx_config,
     )
     did_wallet_2 = env_2.wallet_state_manager.get_wallet(id=uint32(2), required_type=DIDWallet)
     current_coin_info_response = await env_0.rpc_client.did_get_current_coin_info(