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

chia/_tests/wallet/simple_sync/test_simple_sync_protocol.py

@@ -5,7 +5,6 @@ import asyncio
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_to_bytes
 from colorlog import getLogger
 
 from chia._tests.connection_utils import add_dummy_connection
@@ -14,14 +13,15 @@ from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.protocols import wallet_protocol
 from chia.protocols.full_node_protocol import RespondTransaction
+from chia.protocols.outbound_message import Message, NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.wallet_protocol import CoinStateUpdate, RespondToCoinUpdates
-from chia.server.outbound_message import Message, NodeType
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, ReorgProtocol
 from chia.types.blockchain_format.coin import Coin
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
 from chia.types.peer_info import PeerInfo
+from chia.util.casts import int_to_bytes
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet import Wallet
 
@@ -142,7 +142,8 @@ async def test_subscribe_for_ph(simulator_and_wallet: OldSimulatorsAndWallets, s
 
     wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
     assert isinstance(wallet, Wallet)
-    puzzle_hash = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzzle_hash = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     for i in range(num_blocks):
         if i == num_blocks - 1:
@@ -223,7 +224,8 @@ async def test_subscribe_for_coin_id(simulator_and_wallet: OldSimulatorsAndWalle
     fn_server = full_node_api.full_node.server
     standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
     assert isinstance(standard_wallet, Wallet)
-    puzzle_hash = await standard_wallet.get_new_puzzlehash()
+    async with standard_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzzle_hash = await action_scope.get_puzzle_hash(standard_wallet.wallet_state_manager)
 
     await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
     incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
@@ -325,7 +327,8 @@ async def test_subscribe_for_ph_reorg(simulator_and_wallet: OldSimulatorsAndWall
     fn_server = full_node_api.full_node.server
     standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
     assert isinstance(standard_wallet, Wallet)
-    puzzle_hash = await standard_wallet.get_new_puzzlehash()
+    async with standard_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzzle_hash = await action_scope.get_puzzle_hash(standard_wallet.wallet_state_manager)
 
     await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
     incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)
@@ -400,7 +403,8 @@ async def test_subscribe_for_coin_id_reorg(simulator_and_wallet: OldSimulatorsAn
     fn_server = full_node_api.full_node.server
     standard_wallet = wallet_node.wallet_state_manager.wallets[uint32(1)]
     assert isinstance(standard_wallet, Wallet)
-    puzzle_hash = await standard_wallet.get_new_puzzlehash()
+    async with standard_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        puzzle_hash = await action_scope.get_puzzle_hash(standard_wallet.wallet_state_manager)
 
     await server_2.start_client(PeerInfo(self_hostname, fn_server.get_port()), None)
     incoming_queue, peer_id = await add_dummy_connection(fn_server, self_hostname, 12312, NodeType.WALLET)

chia/_tests/wallet/sync/test_wallet_sync.py

@@ -11,7 +11,15 @@ from unittest.mock import MagicMock
 
 import pytest
 from aiosqlite import Error as AIOSqliteError
-from chia_rs import ConsensusConstants, G2Element, confirm_not_included_already_hashed
+from chia_rs import (
+    BlockRecord,
+    CoinState,
+    ConsensusConstants,
+    FullBlock,
+    G2Element,
+    SpendBundle,
+    confirm_not_included_already_hashed,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 from chiabip158 import PyBIP158
@@ -23,24 +31,23 @@ from chia._tests.util.misc import patch_request_handler, wallet_height_at_least
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
 from chia._tests.weight_proof.test_weight_proof import load_blocks_dont_validate
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_body_validation import ForkInfo
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.full_node.weight_proof import WeightProofHandler
 from chia.protocols import full_node_protocol, wallet_protocol
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
 from chia.protocols.wallet_protocol import (
-    CoinState,
     RequestAdditions,
     RespondAdditions,
     RespondBlockHeader,
     RespondBlockHeaders,
     SendTransaction,
 )
-from chia.server.outbound_message import Message, make_msg
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
@@ -51,11 +58,8 @@ 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.condition_opcodes import ConditionOpcode
-from chia.types.full_block import FullBlock
 from chia.types.peer_info import PeerInfo
-from chia.types.spend_bundle import SpendBundle
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.hash import std_hash
 from chia.wallet.conditions import CreateCoin
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
@@ -91,7 +95,8 @@ async def test_request_block_headers(
     [full_node_api], [(wallet_node, _)], bt = simulator_and_wallet
 
     wallet = wallet_node.wallet_state_manager.main_wallet
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await add_blocks_in_batches(default_400_blocks[:100], full_node_api.full_node)
 
     msg = await full_node_api.request_block_headers(wallet_protocol.RequestBlockHeaders(uint32(10), uint32(15), False))
@@ -320,7 +325,9 @@ async def test_almost_recent(
     both_phs = []
     for wallet_node, wallet_server in wallets:
         wallet = wallet_node.wallet_state_manager.main_wallet
-        both_phs.append(await wallet.get_new_puzzlehash())
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+        both_phs.append(ph)
 
     for i in range(20):
         # Tests a reorg with the wallet
@@ -484,7 +491,9 @@ async def test_wallet_reorg_sync(
     phs = []
     for wallet_node, wallet_server in wallets:
         wallet = wallet_node.wallet_state_manager.main_wallet
-        phs.append(await wallet.get_new_puzzlehash())
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+        phs.append(ph)
         await wallet_server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
 
     # Insert 400 blocks
@@ -565,7 +574,8 @@ async def test_wallet_reorg_get_coinbase(
     all_blocks_reorg_2 = blocks_reorg[:-30]
     for wallet_node, wallet_server in wallets:
         wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
         all_blocks_reorg_2 = bt.get_consecutive_blocks(
             1, pool_reward_puzzle_hash=ph, farmer_reward_puzzle_hash=ph, block_list_input=all_blocks_reorg_2
         )
@@ -604,7 +614,8 @@ async def test_request_additions_errors(simulator_and_wallet: OldSimulatorsAndWa
     full_nodes, wallets, _ = simulator_and_wallet
     wallet_node, wallet_server = wallets[0]
     wallet = wallet_node.wallet_state_manager.main_wallet
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     full_node_api = full_nodes[0]
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.full_node.server.get_port()), None)
@@ -659,7 +670,8 @@ async def test_request_additions_success(simulator_and_wallet: OldSimulatorsAndW
     full_nodes, wallets, _ = simulator_and_wallet
     wallet_node, wallet_server = wallets[0]
     wallet = wallet_node.wallet_state_manager.main_wallet
-    ph = await wallet.get_new_puzzlehash()
+    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     full_node_api = full_nodes[0]
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.full_node.server.get_port()), None)
@@ -669,13 +681,14 @@ async def test_request_additions_success(simulator_and_wallet: OldSimulatorsAndW
 
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-    payees: list[CreateCoin] = []
-    for i in range(10):
-        payee_ph = await wallet.get_new_puzzlehash()
-        payees.append(CreateCoin(payee_ph, uint64(i + 100)))
-        payees.append(CreateCoin(payee_ph, uint64(i + 200)))
-
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        payees: list[CreateCoin] = []
+        for i in range(10):
+            payee_ph = await action_scope.get_puzzle_hash(
+                wallet.wallet_state_manager, override_reuse_puzhash_with=False
+            )
+            payees.append(CreateCoin(payee_ph, uint64(i + 100)))
+            payees.append(CreateCoin(payee_ph, uint64(i + 200)))
         await wallet.generate_signed_transaction(
             [uint64(0), *(payee.amount for payee in payees)],
             [ph, *(payee.puzzle_hash for payee in payees)],
@@ -855,7 +868,8 @@ async def test_dusted_wallet(
     # Create two wallets, one for farming (not used for testing), and one for testing dust.
     farm_wallet = farm_wallet_node.wallet_state_manager.main_wallet
     dust_wallet = dust_wallet_node.wallet_state_manager.main_wallet
-    ph = await farm_wallet.get_new_puzzlehash()
+    async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(farm_wallet.wallet_state_manager)
 
     full_node_api = full_nodes[0]
 
@@ -888,9 +902,10 @@ async def test_dusted_wallet(
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[farm_wallet_node, dust_wallet_node], timeout=20)
 
     # Part 1: create a single dust coin
-    payees: list[CreateCoin] = []
-    payee_ph = await dust_wallet.get_new_puzzlehash()
-    payees.append(CreateCoin(payee_ph, uint64(dust_value)))
+    async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        payees: list[CreateCoin] = []
+        payee_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
+        payees.append(CreateCoin(payee_ph, uint64(dust_value)))
 
     # construct and send tx
     async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -950,8 +965,11 @@ async def test_dusted_wallet(
     dust_remaining = new_dust
 
     while dust_remaining > 0:
-        payee_ph = await dust_wallet.get_new_puzzlehash()
-        payees.append(CreateCoin(payee_ph, uint64(dust_value)))
+        async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            payee_ph = await action_scope.get_puzzle_hash(
+                dust_wallet.wallet_state_manager, override_reuse_puzhash_with=False
+            )
+            payees.append(CreateCoin(payee_ph, uint64(dust_value)))
 
         # After every 100 (at most) coins added, push the tx and advance the chain
         # This greatly speeds up the overall process
@@ -1025,9 +1043,12 @@ async def test_dusted_wallet(
 
     payees = []
 
-    for _ in range(large_coins):
-        payee_ph = await dust_wallet.get_new_puzzlehash()
-        payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount)))
+    async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        for _ in range(large_coins):
+            payee_ph = await action_scope.get_puzzle_hash(
+                dust_wallet.wallet_state_manager, override_reuse_puzhash_with=False
+            )
+            payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount)))
 
     # construct and send tx
     async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1069,8 +1090,9 @@ async def test_dusted_wallet(
     # Part 4: Create one more dust coin to test the threshold
     payees = []
 
-    payee_ph = await dust_wallet.get_new_puzzlehash()
-    payees.append(CreateCoin(payee_ph, uint64(dust_value)))
+    async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        payee_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
+        payees.append(CreateCoin(payee_ph, uint64(dust_value)))
 
     # construct and send tx
     async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1114,26 +1136,27 @@ async def test_dusted_wallet(
     # Those below the threshold should get filtered, and those above should not.
     payees = []
 
-    for i in range(5):
-        payee_ph = await dust_wallet.get_new_puzzlehash()
+    async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        for i in range(5):
+            payee_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
 
-        # Create a large coin and add on the appropriate balance.
-        payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount + i)))
-        large_coins += 1
-        large_coin_balance += xch_spam_amount + i
+            # Create a large coin and add on the appropriate balance.
+            payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount + i)))
+            large_coins += 1
+            large_coin_balance += xch_spam_amount + i
 
-        payee_ph = await dust_wallet.get_new_puzzlehash()
+            payee_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
 
-        # Make sure we are always creating coins with a positive value.
-        if xch_spam_amount - dust_value - i > 0:
-            payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount - dust_value - i)))
-        else:
-            payees.append(CreateCoin(payee_ph, uint64(dust_value)))
-        # In cases where xch_spam_amount is sufficiently low,
-        # the new dust should be considered a large coina and not be filtered.
-        if xch_spam_amount <= dust_value:
-            large_dust_coins += 1
-            large_dust_balance += dust_value
+            # Make sure we are always creating coins with a positive value.
+            if xch_spam_amount - dust_value - i > 0:
+                payees.append(CreateCoin(payee_ph, uint64(xch_spam_amount - dust_value - i)))
+            else:
+                payees.append(CreateCoin(payee_ph, uint64(dust_value)))
+            # In cases where xch_spam_amount is sufficiently low,
+            # the new dust should be considered a large coina and not be filtered.
+            if xch_spam_amount <= dust_value:
+                large_dust_coins += 1
+                large_dust_balance += dust_value
 
     # construct and send tx
     async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1172,8 +1195,9 @@ async def test_dusted_wallet(
     # Send to the dust wallet "spam_filter_after_n_txs" coins that are equal in value to "xch_spam_amount".
     # Send 1 mojo from the dust wallet. The dust wallet should receive a change coin valued at "xch_spam_amount-1".
 
-    payee_ph = await farm_wallet.get_new_puzzlehash()
-    payees = [CreateCoin(payee_ph, uint64(balance))]
+    async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        payee_ph = await action_scope.get_puzzle_hash(farm_wallet.wallet_state_manager)
+        payees = [CreateCoin(payee_ph, uint64(balance))]
 
     # construct and send tx
     async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1217,8 +1241,9 @@ async def test_dusted_wallet(
         coin_value = 2
 
     while coins_remaining > 0:
-        payee_ph = await dust_wallet.get_new_puzzlehash()
-        payees.append(CreateCoin(payee_ph, uint64(coin_value)))
+        async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            payee_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
+            payees.append(CreateCoin(payee_ph, uint64(coin_value)))
 
         # After every 100 (at most) coins added, push the tx and advance the chain
         # This greatly speeds up the overall process
@@ -1273,8 +1298,9 @@ async def test_dusted_wallet(
     assert balance == unspent_count * coin_value
 
     # Send a 1 mojo coin from the dust wallet to the farm wallet
-    payee_ph = await farm_wallet.get_new_puzzlehash()
-    payees = [CreateCoin(payee_ph, uint64(1))]
+    async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        payee_ph = await action_scope.get_puzzle_hash(farm_wallet.wallet_state_manager)
+        payees = [CreateCoin(payee_ph, uint64(1))]
 
     # construct and send tx
     async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
@@ -1312,8 +1338,10 @@ async def test_dusted_wallet(
     #         The NFT should not be filtered.
 
     # Start with new puzzlehashes for each wallet
-    farm_ph = await farm_wallet.get_new_puzzlehash()
-    dust_ph = await dust_wallet.get_new_puzzlehash()
+    async with farm_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        farm_ph = await action_scope.get_puzzle_hash(farm_wallet.wallet_state_manager)
+    async with dust_wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        dust_ph = await action_scope.get_puzzle_hash(dust_wallet.wallet_state_manager)
 
     # Create an NFT wallet for the farmer and dust wallet
     farm_nft_wallet = await NFTWallet.create_new_nft_wallet(
@@ -1409,7 +1437,7 @@ async def test_retry_store(
         ) -> list[CoinState]:
             if flakiness_info.coin_state_flaky:
                 flakiness_info.coin_state_flaky = False
-                raise PeerRequestException()
+                raise PeerRequestException
             else:
                 return await func(coin_names, peer, fork_height)
 
@@ -1442,7 +1470,7 @@ async def test_retry_store(
         ) -> list[CoinState]:
             if flakiness_info.fetch_children_flaky:
                 flakiness_info.fetch_children_flaky = False
-                raise PeerRequestException()
+                raise PeerRequestException
             else:
                 return await func(coin_name, peer, fork_height)
 
@@ -1454,7 +1482,7 @@ async def test_retry_store(
         async def new_func(height: uint32) -> uint64:
             if flakiness_info.get_timestamp_flaky:
                 flakiness_info.get_timestamp_flaky = False
-                raise PeerRequestException()
+                raise PeerRequestException
             else:
                 return await func(height)
 
@@ -1466,7 +1494,7 @@ async def test_retry_store(
         async def new_func(puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
             if flakiness_info.db_flaky:
                 flakiness_info.db_flaky = False
-                raise AIOSqliteError()
+                raise AIOSqliteError
             else:
                 return await func(puzzle_hash)
 
@@ -1504,7 +1532,8 @@ async def test_retry_store(
             await wallet_server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
 
             wallet = wallet_node.wallet_state_manager.main_wallet
-            ph = await wallet.get_new_puzzlehash()
+            async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+                ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.zeros))
 

chia/_tests/wallet/test_clvm_casts.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import random
+
+import pytest
+
+from chia.types.blockchain_format.program import Program
+from chia.util.casts import int_from_bytes, int_to_bytes
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        0,
+        1,
+        -1,
+        127,
+        -127,
+        128,
+        -128,
+        255,
+        -255,
+        256,
+        -256,
+        2**8 - 1,
+        -(2**8) + 1,
+        2**15,
+        -(2**15),
+        2**31 - 1,
+        -(2**31),
+        2**63 - 1,
+        -(2**63),
+        2**127 - 1,
+        -(2**127),
+        10**100,
+        -(10**100),  # big ints
+    ],
+)
+def test_round_trip(value: int) -> None:
+    t1 = Program.to(value)
+    t2 = int_to_bytes(value)
+    assert t1 == Program.to(t2)
+    assert int_from_bytes(t2) == value
+    assert t1.as_int() == value
+
+
+def test_zero_serialization() -> None:
+    assert int_to_bytes(0) == b""
+    assert int_from_bytes(b"") == 0
+
+
+def test_minimal_encoding() -> None:
+    assert int_to_bytes(0x80) == b"\x00\x80"
+    assert int_to_bytes(-129) == b"\xff\x7f"  # no extra FF
+    assert int_to_bytes(-128) == b"\x80"
+    assert int_to_bytes(127) == b"\x7f"
+
+
+def test_randomized() -> None:
+    random.seed(97)
+    for _ in range(1000):
+        v = random.randint(-(2**256), 2**256)
+        assert int_from_bytes(int_to_bytes(v)) == v
+
+
+@pytest.mark.parametrize(
+    "blob, expected",
+    [
+        (b"", 0),
+        (b"\x00", 0),
+        (b"\x7f", 127),
+        (b"\x80", -128),
+        (b"\xff", -1),
+        (b"\x00\x80", 128),
+        (b"\xff\x7f", -129),
+    ],
+)
+def test_int_from_bytes_explicit(blob: bytes, expected: int) -> None:
+    assert int_from_bytes(blob) == expected
+
+
+def test_invertibility_on_large_values() -> None:
+    for e in range(1, 1025, 64):
+        v = 2**e
+        for sign in [1, -1]:
+            val = v * sign
+            b = int_to_bytes(val)
+            assert int_from_bytes(b) == val

chia/_tests/wallet/test_coin_management.py

@@ -16,8 +16,8 @@ from chia._tests.environments.wallet import STANDARD_TX_ENDPOINT_ARGS, WalletSta
 from chia.cmds.cmd_helpers import NeedsCoinSelectionConfig, NeedsWalletRPC, WalletClientInfo
 from chia.cmds.coins import CombineCMD, ListCMD, SplitCMD
 from chia.cmds.param_types import CliAmount, cli_amount_none
-from chia.rpc.wallet_request_types import GetSyncStatusResponse
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.wallet_request_types import GetSyncStatusResponse
 
 ONE_TRILLION = 1_000_000_000_000
 

chia/_tests/wallet/test_coin_selection.py

@@ -101,7 +101,7 @@ class TestCoinSelection:
     async def test_coin_selection_zero_coins(self, a_hash: bytes32) -> None:
         coin_list: list[WalletCoinRecord] = [
             WalletCoinRecord(Coin(a_hash, a_hash, uint64(0)), uint32(1), uint32(1), False, True, WalletType(0), 1)
-            for _ in range(0, 100)
+            for _ in range(100)
         ]
 
         result: set[Coin] = await select_coins(

chia/_tests/wallet/test_conditions.py

@@ -6,11 +6,11 @@ from typing import Any, Optional, Union
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_from_bytes
 from clvm.EvalError import EvalError
 
 from chia.types.blockchain_format.program import Program
 from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.casts import int_from_bytes
 from chia.wallet.conditions import (
     CONDITION_DRIVERS,
     CONDITION_DRIVERS_W_ABSTRACTIONS,

chia/_tests/wallet/test_new_wallet_protocol.py

@@ -8,27 +8,27 @@ from random import Random
 from typing import Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, Program
+from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, Program, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 
 from chia._tests.connection_utils import add_dummy_connection
+from chia._tests.util.coin_store import add_coin_records_to_db
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.full_node import FullNode
 from chia.full_node.mempool import MempoolRemoveReason
 from chia.protocols import wallet_protocol
+from chia.protocols.outbound_message import Message, NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
-from chia.server.outbound_message import Message, NodeType
+from chia.server.aliases import WalletService
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator import simulator_protocol
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.start_simulator import SimulatorFullNodeService
-from chia.types.aliases import WalletService
 from chia.types.coin_record import CoinRecord
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.types.spend_bundle import SpendBundle
 from chia.util.hash import std_hash
 
 IDENTITY_PUZZLE = Program.to(1)
@@ -278,7 +278,7 @@ async def test_request_coin_state(one_node: OneNode, self_hostname: str) -> None
         coinbase=False,
         timestamp=uint64(1),
     )
-    await simulator.full_node.coin_store._add_coin_records([*coin_records, ignored_coin])
+    await add_coin_records_to_db(simulator.full_node.coin_store, [*coin_records, ignored_coin])
 
     # Request no coin states
     resp = await simulator.request_coin_state(wallet_protocol.RequestCoinState([], None, genesis, False), peer)
@@ -378,7 +378,7 @@ async def test_request_coin_state_limit(one_node: OneNode, self_hostname: str) -
             )
             coin_records[coin_record.coin.name()] = coin_record
 
-    await simulator.full_node.coin_store._add_coin_records(list(coin_records.values()))
+    await add_coin_records_to_db(simulator.full_node.coin_store, list(coin_records.values()))
 
     # Fetch the coin records using the wallet protocol,
     # with more coin ids than the limit of 100,000, but only after height 10000.
@@ -441,7 +441,7 @@ async def test_request_puzzle_state(one_node: OneNode, self_hostname: str) -> No
         timestamp=uint64(1),
     )
 
-    await simulator.full_node.coin_store._add_coin_records([*coin_records, ignored_coin])
+    await add_coin_records_to_db(simulator.full_node.coin_store, [*coin_records, ignored_coin])
 
     # We already test permutations of CoinStateFilters in the CoinStore tests
     # So it's redundant to do so here
@@ -570,7 +570,7 @@ async def test_request_puzzle_state_limit(one_node: OneNode, self_hostname: str)
             )
             coin_records[coin_record.coin.name()] = coin_record
 
-    await simulator.full_node.coin_store._add_coin_records(list(coin_records.values()))
+    await add_coin_records_to_db(simulator.full_node.coin_store, list(coin_records.values()))
 
     # Fetch the coin records using the wallet protocol,
     # only after height 10000, so that the limit of 100000 isn't exceeded
@@ -724,7 +724,7 @@ async def test_sync_puzzle_state(
             if coin_ph != puzzle_hash:
                 hints.append((coin.name(), puzzle_hash))
 
-    await simulator.full_node.coin_store._add_coin_records(list(coin_records.values()))
+    await add_coin_records_to_db(simulator.full_node.coin_store, list(coin_records.values()))
     await simulator.full_node.hint_store.add_hints(hints)
 
     # Farm peak
@@ -828,7 +828,7 @@ async def raw_mpu_setup(one_node: OneNode, self_hostname: str, no_capability: bo
     reward_1 = Coin(std_hash(b"reward 1"), std_hash(b"reward puzzle hash"), uint64(1000))
     reward_2 = Coin(std_hash(b"reward 2"), std_hash(b"reward puzzle hash"), uint64(2000))
     await simulator.full_node.coin_store.new_block(
-        uint32(2), uint64(10000), [reward_1, reward_2], [coin for coin, _ in new_coins], []
+        uint32(2), uint64(10000), [reward_1, reward_2], [(coin.name(), coin, False) for coin, _ in new_coins], []
     )
     await simulator.full_node.hint_store.add_hints([(coin.name(), hint) for coin, hint in new_coins])
 
@@ -855,7 +855,9 @@ async def make_coin(full_node: FullNode) -> tuple[Coin, bytes32]:
 
     reward_1 = Coin(std_hash(b"reward 1"), std_hash(b"reward puzzle hash"), uint64(3000))
     reward_2 = Coin(std_hash(b"reward 2"), std_hash(b"reward puzzle hash"), uint64(4000))
-    await full_node.coin_store.new_block(uint32(height + 1), uint64(200000), [reward_1, reward_2], [coin], [])
+    await full_node.coin_store.new_block(
+        uint32(height + 1), uint64(200000), [reward_1, reward_2], [(coin.name(), coin, False)], []
+    )
     await full_node.hint_store.add_hints([(coin.name(), hint)])
 
     return coin, hint

chia/_tests/wallet/test_notifications.py

@@ -65,8 +65,10 @@ async def test_notifications(
     wallet_1 = wsm_1.main_wallet
     wallet_2 = wsm_2.main_wallet
 
-    ph_1 = await wallet_1.get_new_puzzlehash()
-    ph_2 = await wallet_2.get_new_puzzlehash()
+    async with wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph_1 = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
+    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph_2 = await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)
     ph_token = bytes32.random(seeded_random)
 
     if trusted:
@@ -83,7 +85,7 @@ async def test_notifications(
     await server_0.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
     await server_1.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
 
-    for i in range(0, 2):
+    for i in range(2):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_1))
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_1, wallet_node_2], timeout=30)