chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/_tests/wallet/sync/test_wallet_sync.py

@@ -25,6 +25,7 @@ from chia_rs.sized_ints import uint32, uint64, uint128
 from chiabip158 import PyBIP158
 from colorlog import getLogger
 
+from chia._tests.conftest import ConsensusMode
 from chia._tests.connection_utils import connect_and_get_peer, disconnect_all, disconnect_all_and_reconnect
 from chia._tests.util.blockchain_mock import BlockchainMock
 from chia._tests.util.misc import patch_request_handler, wallet_height_at_least
@@ -1702,6 +1703,11 @@ async def test_long_sync_untrusted_break(
 @pytest.mark.anyio
 @pytest.mark.parametrize("chain_length", [0, 100])
 @pytest.mark.parametrize("fork_point", [500, 1500])
+# TODO: todo_v2_plots once we have new test chains, we can probably re-enable this
+@pytest.mark.limit_consensus_modes(
+    allows=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0],
+    reason="after plot-v1 phase-out, the chains aren't valid anymore",
+)
 async def test_long_reorg_nodes_and_wallet(
     chain_length: int,
     fork_point: int,

chia/_tests/wallet/test_new_wallet_protocol.py

@@ -21,7 +21,6 @@ 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.aliases import WalletService
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator import simulator_protocol
 from chia.simulator.block_tools import BlockTools
@@ -30,6 +29,7 @@ from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.types.coin_record import CoinRecord
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.util.hash import std_hash
+from chia.wallet.wallet_service import WalletService
 
 IDENTITY_PUZZLE = Program.to(1)
 IDENTITY_PUZZLE_HASH = IDENTITY_PUZZLE.get_tree_hash()

chia/_tests/wallet/test_signer_protocol.py

@@ -848,8 +848,8 @@ def test_signer_protocol_in(monkeypatch: pytest.MonkeyPatch) -> None:
         with open("some file", "wb") as file:
             file.write(byte_serialize_clvm_streamable(coin, translation_layer=FOO_COIN_TRANSLATION))
 
-            with open("some file2", "wb") as file:
-                file.write(byte_serialize_clvm_streamable(coin, translation_layer=FOO_COIN_TRANSLATION))
+            with open("some file2", "wb") as file2:
+                file2.write(byte_serialize_clvm_streamable(coin, translation_layer=FOO_COIN_TRANSLATION))
 
         result = runner.invoke(
             cmd, ["temp_cmd", "--signer-protocol-input", "some file", "--signer-protocol-input", "some file2"]

chia/_tests/wallet/test_singleton_lifecycle_fast.py

@@ -65,10 +65,9 @@ def satisfies_hint(obj: T, type_hint: type[T]) -> bool:
                     object_hint_pairs.extend((v, args[1]) for v in obj.values())
                 else:
                     raise NotImplementedError(f"Type {origin} is not yet supported")
-        else:
-            # Handle concrete types
-            if type(obj) is not type_hint:
-                return False
+        # Handle concrete types
+        elif type(obj) is not type_hint:
+            return False
     return True
 
 

chia/_tests/wallet/test_transaction_store.py

@@ -11,6 +11,7 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chia._tests.util.db_connection import DBConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.bech32m import encode_puzzle_hash
 from chia.util.errors import Err
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord, TransactionRecordOld, minimum_send_attempts
@@ -32,7 +33,7 @@ coin_3 = Coin(bytes32.random(module_seeded_random), bytes32.random(module_seeded
 tr1 = TransactionRecord(
     uint32(0),  # confirmed height
     uint64(1000),  # created_at_time
-    bytes32(bytes32.random(module_seeded_random)),  # to_puzzle_hash
+    bytes32(bytes32.zeros),  # to_puzzle_hash
     uint64(1234),  # amount
     uint64(12),  # fee_amount
     False,  # confirmed
@@ -45,15 +46,21 @@ tr1 = TransactionRecord(
     bytes32(bytes32.random(module_seeded_random)),  # trade_id
     uint32(TransactionType.OUTGOING_TX),  # type
     bytes32(bytes32.random(module_seeded_random)),  # name
-    [],  # list[tuple[bytes32, list[bytes]]] memos
+    {},  # memos
     ConditionValidTimes(),
+    encode_puzzle_hash(bytes32(bytes32.zeros), "txch"),
 )
 
+MINIMUM_CONFIG = {
+    "network_overrides": {"config": {"testnet": {"address_prefix": "txch"}}},
+    "selected_network": "testnet",
+}
+
 
 @pytest.mark.anyio
 async def test_add() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         assert await store.get_transaction_record(tr1.name) is None
         await store.add_transaction_record(tr1)
@@ -63,7 +70,7 @@ async def test_add() -> None:
 @pytest.mark.anyio
 async def test_delete() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         await store.add_transaction_record(tr1)
         assert await store.get_transaction_record(tr1.name) == tr1
@@ -74,7 +81,7 @@ async def test_delete() -> None:
 @pytest.mark.anyio
 async def test_set_confirmed() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         await store.add_transaction_record(tr1)
         await store.set_confirmed(tr1.name, uint32(100))
@@ -87,7 +94,7 @@ async def test_set_confirmed() -> None:
 @pytest.mark.anyio
 async def test_increment_sent_noop(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         assert (
             await store.increment_sent(
@@ -100,7 +107,7 @@ async def test_increment_sent_noop(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_increment_sent() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         await store.add_transaction_record(tr1)
         tr = await store.get_transaction_record(tr1.name)
@@ -126,7 +133,7 @@ async def test_increment_sent() -> None:
 @pytest.mark.anyio
 async def test_increment_sent_error() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         await store.add_transaction_record(tr1)
         tr = await store.get_transaction_record(tr1.name)
@@ -156,7 +163,7 @@ def test_filter_ok_mempool_status() -> None:
 @pytest.mark.anyio
 async def test_tx_reorged_update() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr = dataclasses.replace(tr1, sent=uint32(2), sent_to=[("peer1", uint8(1), None), ("peer2", uint8(1), None)])
         await store.add_transaction_record(tr)
@@ -173,7 +180,7 @@ async def test_tx_reorged_update() -> None:
 @pytest.mark.anyio
 async def test_tx_reorged_add() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr = dataclasses.replace(tr1, sent=uint32(2), sent_to=[("peer1", uint8(1), None), ("peer2", uint8(1), None)])
 
@@ -187,7 +194,7 @@ async def test_tx_reorged_add() -> None:
 @pytest.mark.anyio
 async def test_get_tx_record(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(tr1, name=bytes32.random(seeded_random))
         tr3 = dataclasses.replace(tr1, name=bytes32.random(seeded_random))
@@ -212,7 +219,7 @@ async def test_get_tx_record(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_farming_rewards(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         test_trs: list[TransactionRecord] = []
         # tr1 is type OUTGOING_TX
@@ -249,7 +256,7 @@ async def test_get_farming_rewards(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_all_unconfirmed(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(
             tr1, name=bytes32.random(seeded_random), confirmed=True, confirmed_at_height=uint32(100)
@@ -263,7 +270,7 @@ async def test_get_all_unconfirmed(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_unconfirmed_for_wallet(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(
             tr1, name=bytes32.random(seeded_random), confirmed=True, confirmed_at_height=uint32(100)
@@ -282,7 +289,7 @@ async def test_get_unconfirmed_for_wallet(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_transaction_count_for_wallet(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(tr1, name=bytes32.random(seeded_random), wallet_id=uint32(2))
 
@@ -322,7 +329,7 @@ async def test_transaction_count_for_wallet(seeded_random: random.Random) -> Non
 @pytest.mark.anyio
 async def test_all_transactions_for_wallet(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         test_trs: list[TransactionRecord] = []
         for wallet_id in [1, 2]:
@@ -373,7 +380,7 @@ def cmp(lhs: list[Any], rhs: list[Any]) -> bool:
 @pytest.mark.anyio
 async def test_get_all_transactions(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         test_trs: list[TransactionRecord] = []
         assert await store.get_all_transactions() == []
@@ -390,7 +397,7 @@ async def test_get_all_transactions(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_transaction_above(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         test_trs: list[TransactionRecord] = []
         assert await store.get_transaction_above(uint32(0)) == []
@@ -410,7 +417,7 @@ async def test_get_transaction_above(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_tx_by_trade_id(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(tr1, name=bytes32.random(seeded_random), trade_id=bytes32.random(seeded_random))
         tr3 = dataclasses.replace(tr1, name=bytes32.random(seeded_random), trade_id=bytes32.random(seeded_random))
@@ -442,7 +449,7 @@ async def test_get_tx_by_trade_id(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_rollback_to_block(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         test_trs: list[TransactionRecord] = []
         for height in range(10):
@@ -465,7 +472,7 @@ async def test_rollback_to_block(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_delete_unconfirmed(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(tr1, name=bytes32.random(seeded_random), confirmed=True)
         tr3 = dataclasses.replace(tr1, name=bytes32.random(seeded_random), confirmed=True, wallet_id=uint32(2))
@@ -493,7 +500,7 @@ async def test_delete_unconfirmed(seeded_random: random.Random) -> None:
 @pytest.mark.anyio
 async def test_get_transactions_between_confirmed(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(
             tr1, name=bytes32.random(seeded_random), confirmed=True, confirmed_at_height=uint32(1)
@@ -585,7 +592,7 @@ async def test_get_transactions_between_confirmed(seeded_random: random.Random)
 @pytest.mark.anyio
 async def test_get_transactions_between_relevance(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         t1 = dataclasses.replace(
             tr1,
@@ -716,22 +723,24 @@ async def test_get_transactions_between_relevance(seeded_random: random.Random)
 @pytest.mark.anyio
 async def test_get_transactions_between_to_puzzle_hash(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         ph1 = bytes32.random(seeded_random)
+        ad1 = encode_puzzle_hash(ph1, "txch")
         ph2 = bytes32.random(seeded_random)
+        ad2 = encode_puzzle_hash(ph2, "txch")
 
         tr2 = dataclasses.replace(
-            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(1), to_puzzle_hash=ph1
+            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(1), to_puzzle_hash=ph1, to_address=ad1
         )
         tr3 = dataclasses.replace(
-            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(2), to_puzzle_hash=ph1
+            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(2), to_puzzle_hash=ph1, to_address=ad1
         )
         tr4 = dataclasses.replace(
-            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(3), to_puzzle_hash=ph2
+            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(3), to_puzzle_hash=ph2, to_address=ad2
         )
         tr5 = dataclasses.replace(
-            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(4), to_puzzle_hash=ph2
+            tr1, name=bytes32.random(seeded_random), confirmed_at_height=uint32(4), to_puzzle_hash=ph2, to_address=ad2
         )
 
         await store.add_transaction_record(tr1)
@@ -762,7 +771,7 @@ async def test_get_transactions_between_to_puzzle_hash(seeded_random: random.Ran
 @pytest.mark.anyio
 async def test_get_not_sent(seeded_random: random.Random) -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
 
         tr2 = dataclasses.replace(
             tr1, name=bytes32.random(seeded_random), confirmed=True, confirmed_at_height=uint32(1)
@@ -859,7 +868,7 @@ async def test_valid_times_migration() -> None:
             trade_id=None,
             type=uint32(TransactionType.INCOMING_TX.value),
             name=bytes32.zeros,
-            memos=[],
+            memos={},
         )
 
         async with db_wrapper.writer_maybe_transaction() as conn:
@@ -881,7 +890,7 @@ async def test_valid_times_migration() -> None:
                 ),
             )
 
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
         rec = await store.get_transaction_record(old_record.name)
         assert rec is not None
         assert rec.valid_times == ConditionValidTimes()
@@ -890,7 +899,7 @@ async def test_valid_times_migration() -> None:
 @pytest.mark.anyio
 async def test_large_tx_record_query() -> None:
     async with DBConnection(1) as db_wrapper:
-        store = await WalletTransactionStore.create(db_wrapper)
+        store = await WalletTransactionStore.create(db_wrapper, MINIMUM_CONFIG)
         tx_records_to_insert = []
         for _ in range(db_wrapper.host_parameter_limit + 1):
             name = bytes32.random()
@@ -910,7 +919,7 @@ async def test_large_tx_record_query() -> None:
                 trade_id=None,
                 type=uint32(TransactionType.INCOMING_TX.value),
                 name=name,
-                memos=[],
+                memos={},
             )
             tx_records_to_insert.append(
                 (

chia/_tests/wallet/test_wallet.py

@@ -19,6 +19,7 @@ from chia.types.blockchain_format.program import Program
 from chia.types.peer_info import PeerInfo
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX
 from chia.util.bech32m import encode_puzzle_hash
+from chia.util.byte_types import hexstr_to_bytes
 from chia.util.errors import Err
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.derive_keys import master_sk_to_wallet_sk
@@ -395,9 +396,7 @@ class TestWalletSimulator:
         assert len(txs["transactions"]) == 1
         assert not txs["transactions"][0]["confirmed"]
         assert txs["transactions"][0]["metadata"]["recipient_puzzle_hash"][2:] == normal_puzhash.hex()
-        assert txs["transactions"][0]["metadata"]["coin_id"] == merkle_coin.name().hex()
-        with pytest.raises(ValueError):
-            await api_0.spend_clawback_coins({})
+        assert txs["transactions"][0]["metadata"]["coin_id"] == "0x" + merkle_coin.name().hex()
 
         test_fee = 10
         resp = await api_0.spend_clawback_coins(
@@ -407,7 +406,6 @@ class TestWalletSimulator:
                 **wallet_environments.tx_config.to_json_dict(),
             }
         )
-        assert resp["success"]
         assert len(resp["transaction_ids"]) == 1
 
         await wallet_environments.process_pending_states(
@@ -540,7 +538,6 @@ class TestWalletSimulator:
                 **wallet_environments.tx_config.to_json_dict(),
             }
         )
-        assert resp["success"]
         assert len(resp["transaction_ids"]) == 1
         # Wait mempool update
         await wallet_environments.process_pending_states(
@@ -587,7 +584,7 @@ class TestWalletSimulator:
         assert txs["transactions"][0]["confirmed"]
         assert txs["transactions"][1]["confirmed"]
         assert txs["transactions"][0]["memos"] != txs["transactions"][1]["memos"]
-        assert next(iter(txs["transactions"][0]["memos"].values())) == b"Test".hex()
+        assert "0x" + b"Test".hex() in next(iter(txs["transactions"][0]["memos"].values()))
 
     @pytest.mark.parametrize(
         "wallet_environments",
@@ -677,7 +674,6 @@ class TestWalletSimulator:
                 **wallet_environments.tx_config.to_json_dict(),
             }
         )
-        assert resp["success"]
         assert len(resp["transaction_ids"]) == 1
 
         await wallet_environments.process_pending_states(
@@ -1093,10 +1089,8 @@ class TestWalletSimulator:
         await time_out_assert(20, wsm_2.coin_store.count_small_unspent, 1, 1000, CoinType.CLAWBACK)
         # clawback merkle coin
         resp = await api_1.spend_clawback_coins({"coin_ids": [clawback_coin_id_1.hex()], "fee": 0})
-        assert resp["success"]
         assert len(resp["transaction_ids"]) == 1
         resp = await api_1.spend_clawback_coins({"coin_ids": [clawback_coin_id_2.hex()], "fee": 0})
-        assert resp["success"]
         assert len(resp["transaction_ids"]) == 1
 
         await wallet_environments.process_pending_states(
@@ -1542,9 +1536,9 @@ class TestWalletSimulator:
         fees = estimate_fees(tx.spend_bundle)
         assert fees == tx_fee
 
-        memos = await env_0.rpc_client.get_transaction_memo(GetTransactionMemo(transaction_id=tx.name))
-        assert len(memos.coins_with_memos) == 1
-        assert memos.coins_with_memos[0].memos[0] == ph_2
+        memo_response = await env_0.rpc_client.get_transaction_memo(GetTransactionMemo(transaction_id=tx.name))
+        assert len(memo_response.memo_dict) == 1
+        assert next(iter(memo_response.memo_dict.values()))[0] == ph_2
 
         await wallet_environments.process_pending_states(
             [
@@ -1589,13 +1583,9 @@ class TestWalletSimulator:
             if coin.amount == tx_amount:
                 tx_id = coin.name()
         assert tx_id is not None
-        memos = await env_1.rpc_client.get_transaction_memo(GetTransactionMemo(transaction_id=tx_id))
-        assert len(memos.coins_with_memos) == 1
-        assert memos.coins_with_memos[0].memos[0] == ph_2
-        # test json serialization
-        assert memos.to_json_dict() == {
-            tx_id.hex(): {memos.coins_with_memos[0].coin_id.hex(): [memos.coins_with_memos[0].memos[0].hex()]}
-        }
+        memo_response = await env_1.rpc_client.get_transaction_memo(GetTransactionMemo(transaction_id=tx_id))
+        assert len(memo_response.memo_dict) == 1
+        assert next(iter(memo_response.memo_dict.values()))[0] == ph_2
 
     @pytest.mark.parametrize(
         "wallet_environments",
@@ -1721,6 +1711,7 @@ class TestWalletSimulator:
             confirmed_at_height=uint32(0),
             created_at_time=uint64(0),
             to_puzzle_hash=bytes32(32 * b"0"),
+            to_address=encode_puzzle_hash(bytes32(32 * b"0"), "txch"),
             amount=uint64(0),
             fee_amount=uint64(0),
             confirmed=False,
@@ -1733,7 +1724,7 @@ class TestWalletSimulator:
             trade_id=None,
             type=uint32(TransactionType.OUTGOING_TX.value),
             name=name,
-            memos=[],
+            memos={},
             valid_times=ConditionValidTimes(),
         )
         [stolen_tx] = await wallet.wallet_state_manager.add_pending_transactions([stolen_tx])
@@ -2011,9 +2002,9 @@ class TestWalletSimulator:
         puzzle: Program = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message))
 
         assert AugSchemeMPL.verify(
-            G1Element.from_bytes(bytes.fromhex(response["pubkey"])),
+            G1Element.from_bytes(hexstr_to_bytes(response["pubkey"])),
             puzzle.get_tree_hash(),
-            G2Element.from_bytes(bytes.fromhex(response["signature"])),
+            G2Element.from_bytes(hexstr_to_bytes(response["signature"])),
         )
         # Test hex string
         message = "0123456789ABCDEF"
@@ -2023,9 +2014,9 @@ class TestWalletSimulator:
         puzzle = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message)))
 
         assert AugSchemeMPL.verify(
-            G1Element.from_bytes(bytes.fromhex(response["pubkey"])),
+            G1Element.from_bytes(hexstr_to_bytes(response["pubkey"])),
             puzzle.get_tree_hash(),
-            G2Element.from_bytes(bytes.fromhex(response["signature"])),
+            G2Element.from_bytes(hexstr_to_bytes(response["signature"])),
         )
         # Test informal input
         message = "0123456789ABCDEF"
@@ -2035,9 +2026,9 @@ class TestWalletSimulator:
         puzzle = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message)))
 
         assert AugSchemeMPL.verify(
-            G1Element.from_bytes(bytes.fromhex(response["pubkey"])),
+            G1Element.from_bytes(hexstr_to_bytes(response["pubkey"])),
             puzzle.get_tree_hash(),
-            G2Element.from_bytes(bytes.fromhex(response["signature"])),
+            G2Element.from_bytes(hexstr_to_bytes(response["signature"])),
         )
         # Test BLS sign string
         message = "Hello World"
@@ -2046,9 +2037,9 @@ class TestWalletSimulator:
         )
 
         assert AugSchemeMPL.verify(
-            G1Element.from_bytes(bytes.fromhex(response["pubkey"])),
+            G1Element.from_bytes(hexstr_to_bytes(response["pubkey"])),
             bytes(message, "utf-8"),
-            G2Element.from_bytes(bytes.fromhex(response["signature"])),
+            G2Element.from_bytes(hexstr_to_bytes(response["signature"])),
         )
         # Test BLS sign hex
         message = "0123456789ABCDEF"
@@ -2057,9 +2048,9 @@ class TestWalletSimulator:
         )
 
         assert AugSchemeMPL.verify(
-            G1Element.from_bytes(bytes.fromhex(response["pubkey"])),
-            bytes.fromhex(message),
-            G2Element.from_bytes(bytes.fromhex(response["signature"])),
+            G1Element.from_bytes(hexstr_to_bytes(response["pubkey"])),
+            hexstr_to_bytes(message),
+            G2Element.from_bytes(hexstr_to_bytes(response["signature"])),
         )
 
     @pytest.mark.parametrize(

chia/_tests/wallet/test_wallet_state_manager.py

@@ -21,7 +21,7 @@ from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.wallet_types import WalletType
-from chia.wallet.wallet_request_types import PushTransactions
+from chia.wallet.wallet_request_types import ExtendDerivationIndex, PushTransactions
 from chia.wallet.wallet_rpc_api import MAX_DERIVATION_INDEX_DELTA
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 from chia.wallet.wallet_state_manager import WalletStateManager
@@ -286,6 +286,11 @@ async def test_puzzle_hash_requests(wallet_environments: WalletTestFramework) ->
 
     expected_state = await get_puzzle_hash_state()
 
+    # Quick test of this RPC
+    assert (
+        await wallet_environments.environments[0].rpc_client.get_current_derivation_index()
+    ).index == expected_state.highest_index
+
     # `create_more_puzzle_hashes`
     # No-op
     result = await wsm.create_more_puzzle_hashes()
@@ -420,7 +425,7 @@ async def test_puzzle_hash_requests(wallet_environments: WalletTestFramework) ->
             (0,),
         )
     with pytest.raises(ValueError):
-        await rpc_client.extend_derivation_index(0)
+        await rpc_client.extend_derivation_index(ExtendDerivationIndex(uint32(0)))
 
     # Reset to a normal state
     await wsm.puzzle_store.delete_wallet(wsm.main_wallet.id())
@@ -431,15 +436,17 @@ async def test_puzzle_hash_requests(wallet_environments: WalletTestFramework) ->
 
     # Test an index already created
     with pytest.raises(ValueError):
-        await rpc_client.extend_derivation_index(0)
+        await rpc_client.extend_derivation_index(ExtendDerivationIndex(uint32(0)))
 
     # Test an index too far in the future
     with pytest.raises(ValueError):
-        await rpc_client.extend_derivation_index(MAX_DERIVATION_INDEX_DELTA + expected_state.highest_index + 1)
+        await rpc_client.extend_derivation_index(
+            ExtendDerivationIndex(uint32(MAX_DERIVATION_INDEX_DELTA + expected_state.highest_index + 1))
+        )
 
     # Test the actual functionality
-    assert await rpc_client.extend_derivation_index(expected_state.highest_index + 5) == str(
-        expected_state.highest_index + 5
-    )
+    assert (
+        await rpc_client.extend_derivation_index(ExtendDerivationIndex(uint32(expected_state.highest_index + 5)))
+    ).index == expected_state.highest_index + 5
     expected_state = PuzzleHashState(expected_state.highest_index + 5, expected_state.used_up_to_index)
     assert await get_puzzle_hash_state() == expected_state