chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/_tests/wallet/cat_wallet/test_offer_lifecycle.py

@@ -10,7 +10,6 @@ from chia_rs.sized_ints import uint64
 from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.coin_spend import make_spend
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.wallet.cat_wallet.cat_utils import (
@@ -265,11 +264,9 @@ async def test_complex_offer(cost_logger: CostLogger) -> None:
         valid_spend = tail_offer.to_valid_spend(random_hash)
         real_blue_spend = next(spend for spend in valid_spend.coin_spends if b"hey there" in bytes(spend))
         real_blue_spend_replaced = real_blue_spend.replace(
-            solution=SerializedProgram.from_program(
-                real_blue_spend.solution.to_program().replace(
-                    ffrfrf=Program.to(-113), ffrfrr=Program.to([str_to_tail("blue"), []])
-                )
-            ),
+            solution=Program.from_serialized(real_blue_spend.solution)
+            .replace(ffrfrf=Program.to(-113), ffrfrr=Program.to([str_to_tail("blue"), []]))
+            .to_serialized(),
         )
         valid_spend = WalletSpendBundle(
             [real_blue_spend_replaced, *[spend for spend in valid_spend.coin_spends if spend != real_blue_spend]],

chia/_tests/wallet/cat_wallet/test_trades.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Union
+from typing import Any
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -12,23 +12,23 @@ from chia._tests.conftest import SOFTFORK_HEIGHTS
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.time_out_assert import time_out_assert
+from chia._tests.wallet.cat_wallet.test_cat_wallet import mint_cat
 from chia._tests.wallet.vc_wallet.test_vc_wallet import mint_cr_cat
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.rpc.wallet_request_types import VCAddProofs, VCGetList, VCGetProofsForRoot, VCMint, VCSpend
-from chia.types.blockchain_format.program import INFINITE_COST, Program
-from chia.types.spend_bundle import SpendBundle
+from chia.types.blockchain_format.program import INFINITE_COST, Program, run
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.hash import std_hash
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.cat_wallet.r_cat_wallet import RCATWallet
 from chia.wallet.conditions import CreateCoinAnnouncement, parse_conditions_non_consensus
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 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
+from chia.wallet.trading.offer import Offer, OfferSummary
 from chia.wallet.trading.trade_status import TradeStatus
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
@@ -36,10 +36,9 @@ 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_spend_bundle import WalletSpendBundle
 
-OfferSummary = dict[Union[int, bytes32], int]
-
 
 async def get_trade_and_status(trade_manager: TradeManager, trade: TradeRecord) -> TradeStatus:
     trade_rec = await trade_manager.get_trade_by_id(trade.trade_id)
@@ -99,10 +98,12 @@ async def get_trade_and_status(trade_manager: TradeManager, trade: TradeRecord)
     ],
     indirect=["wallet_environments"],
 )
+@pytest.mark.parametrize("wallet_type", [CATWallet, RCATWallet])
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
 async def test_cat_trades(
     wallet_environments: WalletTestFramework,
     credential_restricted: bool,
+    wallet_type: type[CATWallet],
     active_softfork_height: uint32,
 ) -> None:
     # Setup
@@ -191,6 +192,7 @@ async def test_cat_trades(
             wallet_node_maker,
             client_maker,
             full_node,
+            wallet_environments.tx_config,
             authorized_providers,
             tail_maker,
             proofs_checker_maker,
@@ -201,6 +203,7 @@ async def test_cat_trades(
             wallet_node_taker,
             client_taker,
             full_node,
+            wallet_environments.tx_config,
             authorized_providers,
             tail_taker,
             proofs_checker_taker,
@@ -237,26 +240,36 @@ async def test_cat_trades(
         )
 
         # Mint some VCs that can spend the CR-CATs
-        vc_record_maker = (
-            await client_maker.vc_mint(
-                VCMint(
-                    did_id=encode_puzzle_hash(did_id_maker, "did"),
-                    target_address=encode_puzzle_hash(await wallet_maker.get_new_puzzlehash(), "txch"),
-                    push=True,
-                ),
-                wallet_environments.tx_config,
-            )
-        ).vc_record
-        vc_record_taker = (
-            await client_taker.vc_mint(
-                VCMint(
-                    did_id=encode_puzzle_hash(did_id_taker, "did"),
-                    target_address=encode_puzzle_hash(await wallet_taker.get_new_puzzlehash(), "txch"),
-                    push=True,
-                ),
-                wallet_environments.tx_config,
-            )
-        ).vc_record
+        async with env_maker.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
+            vc_record_maker = (
+                await client_maker.vc_mint(
+                    VCMint(
+                        did_id=encode_puzzle_hash(did_id_maker, "did"),
+                        target_address=encode_puzzle_hash(
+                            await action_scope.get_puzzle_hash(env_maker.wallet_state_manager), "txch"
+                        ),
+                        push=True,
+                    ),
+                    wallet_environments.tx_config,
+                )
+            ).vc_record
+        async with env_taker.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
+            vc_record_taker = (
+                await client_taker.vc_mint(
+                    VCMint(
+                        did_id=encode_puzzle_hash(did_id_taker, "did"),
+                        target_address=encode_puzzle_hash(
+                            await action_scope.get_puzzle_hash(env_taker.wallet_state_manager), "txch"
+                        ),
+                        push=True,
+                    ),
+                    wallet_environments.tx_config,
+                )
+            ).vc_record
         await wallet_environments.process_pending_states(
             [
                 # Balance checking for this scenario is covered in tests/wallet/vc_wallet/test_vc_lifecycle
@@ -343,52 +356,11 @@ async def test_cat_trades(
         }
 
         # Mint some standard CATs
-        async with wallet_maker.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            cat_wallet_maker = await CATWallet.create_new_cat_wallet(
-                wallet_node_maker.wallet_state_manager,
-                wallet_maker,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                action_scope,
-            )
-
-        async with wallet_taker.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            new_cat_wallet_taker = await CATWallet.create_new_cat_wallet(
-                wallet_node_taker.wallet_state_manager,
-                wallet_taker,
-                {"identifier": "genesis_by_id"},
-                uint64(100),
-                action_scope,
-            )
-
-        await wallet_environments.process_pending_states(
-            [
-                # Balance checking for this scenario is covered in test_cat_wallet
-                WalletStateTransition(
-                    pre_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "cat": {"init": True, "set_remainder": True},
-                    },
-                    post_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "cat": {"set_remainder": True},
-                    },
-                ),
-                WalletStateTransition(
-                    pre_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "new cat": {"init": True, "set_remainder": True},
-                    },
-                    post_block_balance_updates={
-                        "xch": {"set_remainder": True},
-                        "new cat": {"set_remainder": True},
-                    },
-                ),
-            ]
+        cat_wallet_maker = await mint_cat(
+            wallet_environments, env_maker, "xch", "cat", uint64(100), wallet_type, "cat maker"
+        )
+        new_cat_wallet_taker = await mint_cat(
+            wallet_environments, env_taker, "xch", "new cat", uint64(100), wallet_type, "cat taker"
         )
 
     if credential_restricted:
@@ -419,8 +391,12 @@ async def test_cat_trades(
             proofs_checker_taker,
         )
     else:
-        new_cat_wallet_maker = await CATWallet.get_or_create_wallet_for_cat(
-            wallet_node_maker.wallet_state_manager, wallet_maker, new_cat_wallet_taker.get_asset_id()
+        if wallet_type is RCATWallet:
+            extra_args: Any = (bytes32.zeros,)
+        else:
+            extra_args = tuple()
+        new_cat_wallet_maker = await wallet_type.get_or_create_wallet_for_cat(
+            wallet_node_maker.wallet_state_manager, wallet_maker, new_cat_wallet_taker.get_asset_id(), *extra_args
         )
 
     await env_maker.change_balances(
@@ -1906,7 +1882,7 @@ async def test_trade_cancellation(wallet_environments: WalletTestFramework) -> N
             [
                 c.to_program()
                 for c in parse_conditions_non_consensus(
-                    spend.puzzle_reveal.to_program().run(spend.solution.to_program()).as_iter(), abstractions=False
+                    run(spend.puzzle_reveal, Program.from_serialized(spend.solution)).as_iter(), abstractions=False
                 )
             ]
         )

chia/_tests/wallet/clawback/test_clawback_decorator.py

@@ -8,6 +8,7 @@ from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.peer_info import PeerInfo
 from chia.wallet.puzzles.clawback.puzzle_decorator import ClawbackPuzzleDecorator
 from chia.wallet.util.puzzle_decorator import PuzzleDecoratorManager
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_node import WalletNode
 
 
@@ -74,5 +75,6 @@ async def test_decorator(
     assert isinstance(wallet_node.wallet_state_manager.decorator_manager.decorator_list[0], ClawbackPuzzleDecorator)
     clawback_decorator: ClawbackPuzzleDecorator = wallet_node.wallet_state_manager.decorator_manager.decorator_list[0]
     assert clawback_decorator.time_lock == 3600
-    puzzle = await wallet.get_new_puzzle()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzzle = await action_scope.get_puzzle(wallet.wallet_state_manager)
     assert puzzle == wallet_node.wallet_state_manager.decorator_manager.decorate(puzzle)

chia/_tests/wallet/clawback/test_clawback_lifecycle.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
@@ -12,12 +12,12 @@ from chia._tests.clvm.test_puzzles import public_key_for_index, secret_exponent_
 from chia._tests.util.key_tool import KeyTool
 from chia._tests.util.spend_sim import CostLogger, SimClient, SpendSim, sim_and_client
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.consensus.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.program import INFINITE_COST, Program
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 from chia.util.errors import Err
 from chia.util.streamable import VersionedBlob
 from chia.wallet.puzzles.clawback.drivers import (

chia/_tests/wallet/clawback/test_clawback_metadata.py

@@ -11,6 +11,7 @@ from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.peer_info import PeerInfo
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_node import WalletNode
 
 
@@ -30,8 +31,9 @@ async def test_is_recipient(
     server_1: ChiaServer = full_node_api.full_node.server
     wallet_node, server_2 = wallets[0]
     wallet = wallet_node.wallet_state_manager.main_wallet
-    puzhash_1 = await wallet.get_new_puzzlehash()
-    puzhash_2 = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzhash_1 = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+        puzhash_2 = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
     invalid_data = ClawbackMetadata(uint64(500), bytes32.random(seeded_random), bytes32.random(seeded_random))
     both_data = ClawbackMetadata(uint64(500), puzhash_1, puzhash_2)

chia/_tests/wallet/conftest.py

@@ -5,30 +5,29 @@ import unittest
 from collections.abc import AsyncIterator, Awaitable
 from contextlib import AsyncExitStack
 from dataclasses import replace
-from typing import Any, Callable, Literal, Optional
+from typing import Any, Callable, Optional
 
 import pytest
 from chia_rs import (
     DONT_VALIDATE_SIGNATURE,
     ConsensusConstants,
+    FullBlock,
     SpendBundleConditions,
     get_flags_for_height_and_constants,
     run_block_generator,
     run_block_generator2,
 )
-from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 
 from chia._tests.environments.wallet import NewPuzzleHashError, WalletEnvironment, WalletState, WalletTestFramework
 from chia._tests.util.setup_nodes import setup_simulators_and_wallets_service
 from chia._tests.wallet.wallet_block_tools import WalletBlockTools
 from chia.full_node.full_node import FullNode
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
-from chia.rpc.wallet_rpc_client import WalletRpcClient
-from chia.types.full_block import FullBlock
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.types.peer_info import PeerInfo
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet_node import Balance
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_state_manager import WalletStateManager
 
 
@@ -65,7 +64,7 @@ async def ignore_block_validation(
     if "standard_block_tools" in request.keywords:
         return None
 
-    async def validate_block_body(*args: Any, **kwargs: Any) -> Literal[None]:
+    async def validate_block_body(*args: Any, **kwargs: Any) -> None:
         return None
 
     def create_wrapper(original_create: Any) -> Any:
@@ -121,10 +120,10 @@ async def ignore_block_validation(
         "chia.consensus.multiprocess_validation.validate_finished_header_block", lambda *_, **__: (uint64(1), None)
     )
     monkeypatch.setattr(
-        "chia.consensus.multiprocess_validation.verify_and_get_quality_string", lambda *_, **__: bytes32.zeros
+        "chia.consensus.multiprocess_validation.validate_pospace_and_get_required_iters", lambda *_, **__: uint64(0)
     )
-    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.sp_total_iters", lambda *_: uint128(0))
-    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.ip_sub_slot_total_iters", lambda *_: uint128(0))
+    monkeypatch.setattr("chia_rs.BlockRecord.sp_total_iters", lambda *_: uint128(0))
+    monkeypatch.setattr("chia_rs.BlockRecord.ip_sub_slot_total_iters", lambda *_: uint128(0))
     monkeypatch.setattr("chia.consensus.make_sub_epoch_summary.calculate_sp_iters", lambda *_: uint64(0))
     monkeypatch.setattr("chia.consensus.make_sub_epoch_summary.calculate_ip_iters", lambda *_: uint64(0))
     monkeypatch.setattr("chia.consensus.difficulty_adjustment._get_next_sub_slot_iters", lambda *_: uint64(1))
@@ -132,7 +131,7 @@ async def ignore_block_validation(
     monkeypatch.setattr("chia.full_node.full_node_store.calculate_sp_interval_iters", lambda *_: uint64(1))
     monkeypatch.setattr("chia.consensus.pot_iterations.calculate_sp_interval_iters", lambda *_: uint64(1))
     monkeypatch.setattr("chia.consensus.pot_iterations.calculate_ip_iters", lambda *_: uint64(1))
-    monkeypatch.setattr("chia.consensus.block_record.BlockRecord.sp_sub_slot_total_iters", lambda *_: uint64(1))
+    monkeypatch.setattr("chia_rs.BlockRecord.sp_sub_slot_total_iters", lambda *_: uint64(1))
 
 
 @pytest.fixture(scope="function", params=[True, False])
@@ -152,7 +151,7 @@ def new_action_scope_wrapper(func: Any) -> Any:
         # Take note of the number of puzzle hashes if we're supposed to be reusing
         ph_indexes: dict[uint32, int] = {}
         for wallet_id in self.wallets:
-            ph_indexes[wallet_id] = await self.puzzle_store.get_unused_count(wallet_id)
+            ph_indexes[wallet_id] = await self.puzzle_store.get_used_count(wallet_id)
 
         async with func(self, *args, **kwargs) as action_scope:
             yield action_scope
@@ -160,7 +159,7 @@ def new_action_scope_wrapper(func: Any) -> Any:
         # Finally, check that the number of puzzle hashes did or did not increase by the specified amount
         if action_scope.config.tx_config.reuse_puzhash:
             for wallet_id, ph_index in zip(self.wallets, ph_indexes):
-                if not ph_indexes[wallet_id] == (await self.puzzle_store.get_unused_count(wallet_id)):
+                if not ph_indexes[wallet_id] == (await self.puzzle_store.get_used_count(wallet_id)):
                     raise NewPuzzleHashError(
                         f"wallet ID {wallet_id} generated new puzzle hashes while reuse_puzhash was False"
                     )

chia/_tests/wallet/db_wallet/test_db_graftroot.py

@@ -38,7 +38,7 @@ NIL_PH = Program.to(None).get_tree_hash()
 async def test_graftroot(cost_logger: CostLogger) -> None:
     async with sim_and_client() as (sim, sim_client):
         # Create the coin we're testing
-        all_values: list[bytes32] = [bytes32([x] * 32) for x in range(0, 100)]
+        all_values: list[bytes32] = [bytes32([x] * 32) for x in range(100)]
         root, proofs = build_merkle_tree(all_values)
         p2_conditions = Program.to((1, [[51, ACS_PH, 0]]))  # An coin to create to make sure this hits the blockchain
         desired_key_values = ((bytes32.zeros, bytes32([1] * 32)), (bytes32([7] * 32), bytes32([8] * 32)))
@@ -125,9 +125,16 @@ async def test_graftroot(cost_logger: CostLogger) -> None:
                 await sim.rewind(same_height)
 
                 # try with a bad merkle root announcement
+                fake_puzzle_bad_announcement = ACS.curry(
+                    fake_struct, ACS.curry(ACS_PH, (bytes32.zeros, None), None, None)
+                )
+                await sim.farm_block(fake_puzzle_bad_announcement.get_tree_hash())
+                fake_coin_bad_announcement: Coin = (
+                    await sim_client.get_coin_records_by_puzzle_hash(fake_puzzle_bad_announcement.get_tree_hash())
+                )[0].coin
                 new_fake_spend = make_spend(
-                    fake_coin,
-                    ACS.curry(fake_struct, ACS.curry(ACS_PH, (bytes32.zeros, None), None, None)),
+                    fake_coin_bad_announcement,
+                    fake_puzzle_bad_announcement,
                     Program.to([[[62, "$"]]]),
                 )
                 new_final_bundle = WalletSpendBundle([new_fake_spend, graftroot_spend], G2Element())
@@ -136,4 +143,4 @@ async def test_graftroot(cost_logger: CostLogger) -> None:
             else:
                 assert result == (MempoolInclusionStatus.FAILED, Err.GENERATOR_RUNTIME_ERROR)
                 with pytest.raises(ValueError, match="clvm raise"):
-                    graftroot_puzzle.run(graftroot_spend.solution.to_program())
+                    graftroot_puzzle.run(Program.from_serialized(graftroot_spend.solution))