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

chia/_tests/wallet/did_wallet/test_did.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import json
-from typing import Any, Optional, Union
+from typing import Any
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element
@@ -23,13 +23,9 @@ from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.peer_info import PeerInfo
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
+from chia.util.byte_types import hexstr_to_bytes
 from chia.wallet.did_wallet.did_wallet import DIDWallet
-from chia.wallet.did_wallet.did_wallet_puzzles import (
-    DID_INNERPUZ_MOD,
-)
 from chia.wallet.singleton import (
-    SINGLETON_LAUNCHER_PUZZLE_HASH,
-    SINGLETON_TOP_LAYER_MOD_HASH,
     create_singleton_puzzle,
 )
 from chia.wallet.util.address_type import AddressType
@@ -38,9 +34,8 @@ 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, DIDGetRecoveryInfo
+from chia.wallet.wallet_request_types import DIDFindLostDID, DIDGetCurrentCoinInfo, DIDGetInfo
 from chia.wallet.wallet_rpc_api import WalletRpcApi
-from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
 async def get_wallet_num(wallet_manager):
@@ -56,34 +51,12 @@ async def make_did_wallet(
     wallet: Wallet,
     amount: uint64,
     action_scope: WalletActionScope,
-    recovery_list: list[bytes32] = [],
     metadata: dict[str, str] = {},
     fee: uint64 = uint64(0),
-    use_alternate_recovery: bool = False,
 ) -> DIDWallet:
-    def alt_create_innerpuz(
-        p2_puzzle_or_hash: Union[Program, bytes32],
-        recovery_list: list[bytes32],
-        num_of_backup_ids_needed: uint64,
-        launcher_id: bytes32,
-        metadata: Program = Program.to([]),
-        recovery_list_hash: Optional[Program] = None,
-    ) -> Program:
-        # override the default of NIL_TREEHASH with NIL to match other wallet implementations
-        nil_recovery = Program.to(None)
-        singleton_struct = Program.to((SINGLETON_TOP_LAYER_MOD_HASH, (launcher_id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
-        return DID_INNERPUZ_MOD.curry(p2_puzzle_or_hash, nil_recovery, 0, singleton_struct, metadata)
-
-    if use_alternate_recovery:
-        with pytest.MonkeyPatch.context() as m:
-            m.setattr("chia.wallet.did_wallet.did_wallet_puzzles.create_innerpuz", alt_create_innerpuz)
-            did_wallet = await DIDWallet.create_new_did_wallet(
-                wallet_state_manager, wallet, uint64(101), action_scope, metadata=metadata, fee=fee
-            )
-    else:
-        did_wallet = await DIDWallet.create_new_did_wallet(
-            wallet_state_manager, wallet, amount, action_scope, backups_ids=recovery_list, metadata=metadata, fee=fee
-        )
+    did_wallet = await DIDWallet.create_new_did_wallet(
+        wallet_state_manager, wallet, amount, action_scope, metadata=metadata, fee=fee
+    )
 
     return did_wallet
 
@@ -94,16 +67,11 @@ async def make_did_wallet(
     "trusted",
     [True, False],
 )
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
 async def test_creation_from_coin_spend(
     self_hostname: str,
     two_nodes_two_wallets_with_same_keys: OldSimulatorsAndWallets,
     trusted: bool,
-    use_alternate_recovery: bool,
 ) -> None:
     """
     Verify that DIDWallet.create_new_did_wallet_from_coin_spend() is called after Singleton creation on
@@ -151,12 +119,10 @@ async def test_creation_from_coin_spend(
             wallet_0,
             uint64(101),
             action_scope,
-            use_alternate_recovery=use_alternate_recovery,
         )
 
     with pytest.raises(RuntimeError):
         assert await did_wallet_0.get_coin() == set()
-    assert await did_wallet_0.get_info_for_recovery() is None
 
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_0, wallet_node_1])
@@ -187,15 +153,9 @@ async def test_creation_from_coin_spend(
     ],
     indirect=True,
 )
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_creation_from_backup_file(
-    wallet_environments: WalletTestFramework, use_alternate_recovery: bool
-) -> None:
+async def test_creation_from_backup_file(wallet_environments: WalletTestFramework) -> None:
     env_0 = wallet_environments.environments[0]
     env_1 = wallet_environments.environments[1]
     env_2 = wallet_environments.environments[2]
@@ -220,7 +180,6 @@ async def test_creation_from_backup_file(
             env_0.xch_wallet,
             uint64(101),
             action_scope,
-            use_alternate_recovery=use_alternate_recovery,
         )
 
     await wallet_environments.process_pending_states(
@@ -270,12 +229,9 @@ async def test_creation_from_backup_file(
         ]
     )
 
-    # Wallet1 sets up DIDWallet_1 with DIDWallet_0 as backup
-    backup_ids = [bytes32.from_hexstr(did_wallet_0.get_my_DID())]
-
     async with env_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         did_wallet_1: DIDWallet = await DIDWallet.create_new_did_wallet(
-            env_1.wallet_state_manager, env_1.xch_wallet, uint64(201), action_scope, backup_ids
+            env_1.wallet_state_manager, env_1.xch_wallet, uint64(201), action_scope
         )
 
     await wallet_environments.process_pending_states(
@@ -335,999 +291,149 @@ async def test_creation_from_backup_file(
         backup_data=backup_data,
     )
     did_wallet_2 = env_2.wallet_state_manager.get_wallet(id=uint32(2), required_type=DIDWallet)
-    recovery_info = await env_2.rpc_client.did_get_recovery_info(
-        DIDGetRecoveryInfo(uint32(env_2.wallet_aliases["did"]))
-    )
-    assert recovery_info.wallet_id == env_2.wallet_aliases["did"]
-    assert recovery_info.backup_dids == backup_ids
     current_coin_info_response = await env_0.rpc_client.did_get_current_coin_info(
         DIDGetCurrentCoinInfo(uint32(env_0.wallet_aliases["did"]))
     )
-    # TODO: this check is kind of weak, we should research when this endpoint might actually be useful
     assert current_coin_info_response.wallet_id == env_0.wallet_aliases["did"]
-    async with env_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        assert recovery_info.pubkey is not None
-        assert recovery_info.newpuzhash is not None
-        message_spend_bundle, attest_data = await did_wallet_0.create_attestment(
-            recovery_info.coin_name, recovery_info.newpuzhash, recovery_info.pubkey, action_scope
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "spendable_balance": -101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                        "max_send_amount": -101,
-                    }
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "spendable_balance": 101,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                        "max_send_amount": 101,
-                    }
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={},
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "init": True,
-                    }
-                },
-                post_block_balance_updates={},
-            ),
-        ]
-    )
-
-    (
-        test_info_list,
-        test_message_spend_bundle,
-    ) = await did_wallet_2.load_attest_files_for_recovery_spend([attest_data])
-    assert message_spend_bundle == test_message_spend_bundle
-
-    async with env_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        assert did_wallet_2.did_info.temp_coin is not None
-        await did_wallet_2.recovery_spend(
-            did_wallet_2.did_info.temp_coin,
-            recovery_info.newpuzhash,
-            test_info_list,
-            recovery_info.pubkey,
-            test_message_spend_bundle,
-            action_scope,
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={},
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={
-                    "did": {
-                        "confirmed_wallet_balance": -201,
-                        "unconfirmed_wallet_balance": -201,
-                        "spendable_balance": -201,
-                        "max_send_amount": -201,
-                        "unspent_coin_count": -1,
-                    }
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "unconfirmed_wallet_balance": 201,
-                        "pending_coin_removal_count": 2,
-                    }
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "confirmed_wallet_balance": 201,
-                        "spendable_balance": 201,
-                        "max_send_amount": 201,
-                        "unspent_coin_count": 1,
-                        "pending_coin_removal_count": -2,
-                    }
-                },
-            ),
-        ]
-    )
 
     for wallet in [did_wallet_0, did_wallet_1, did_wallet_2]:
         assert wallet.wallet_state_manager.wallets[wallet.id()] == wallet
 
-    some_ph = bytes32(32 * b"\2")
-    async with env_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        await did_wallet_2.create_exit_spend(some_ph, action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={},
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={},
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "unconfirmed_wallet_balance": -201,
-                        "spendable_balance": -201,
-                        "max_send_amount": -201,
-                        "pending_coin_removal_count": 1,
-                    }
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "confirmed_wallet_balance": -201,
-                        "unspent_coin_count": -1,
-                        "pending_coin_removal_count": -1,
-                    }
-                },
-            ),
-        ]
-    )
-
-    async def get_coins_with_ph() -> bool:
-        coins = await wallet_environments.full_node.full_node.coin_store.get_coin_records_by_puzzle_hash(True, some_ph)
-        return len(coins) == 1
-
-    await time_out_assert(15, get_coins_with_ph, True)
-
-    for wallet in [did_wallet_0, did_wallet_1]:
-        assert wallet.wallet_state_manager.wallets[wallet.id()] == wallet
-
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
-@pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [1, 1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
+@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
 @pytest.mark.anyio
-async def test_did_recovery_with_multiple_backup_dids(
-    wallet_environments: WalletTestFramework, use_alternate_recovery: bool
-) -> None:
+async def test_did_find_lost_did(wallet_environments: WalletTestFramework):
     env_0 = wallet_environments.environments[0]
-    env_1 = wallet_environments.environments[1]
     wallet_node_0 = env_0.node
-    wallet_node_1 = env_1.node
     wallet_0 = env_0.xch_wallet
-    wallet_1 = env_1.xch_wallet
 
     env_0.wallet_aliases = {
         "xch": 1,
         "did": 2,
     }
-    env_1.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
 
     async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet: DIDWallet = await make_did_wallet(
+        did_wallet_0 = await make_did_wallet(
             wallet_node_0.wallet_state_manager,
             wallet_0,
             uint64(101),
             action_scope,
-            use_alternate_recovery=use_alternate_recovery,
-        )
-    assert did_wallet.get_name() == "Profile 1"
-    recovery_list = [bytes32.from_hexstr(did_wallet.get_my_DID())]
-
-    async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet_2: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_1.wallet_state_manager, wallet_1, uint64(101), action_scope, recovery_list
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-    assert did_wallet_2.did_info.backup_ids == recovery_list
-
-    recovery_list.append(bytes32.from_hexstr(did_wallet_2.get_my_DID()))
-
-    async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet_3: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_1.wallet_state_manager, wallet_1, uint64(201), action_scope, recovery_list
-        )
-
-    env_1.wallet_aliases["did_2"] = 3
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={},
-                post_block_balance_updates={},
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "set_remainder": True,
-                    },
-                    "did_2": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 201,
-                        "pending_change": 201,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "set_remainder": True,
-                    },
-                    "did_2": {
-                        "confirmed_wallet_balance": 201,
-                        "spendable_balance": 201,
-                        "max_send_amount": 201,
-                        "unspent_coin_count": 1,
-                        "pending_change": -201,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-    coin = await did_wallet_3.get_coin()
-
-    backup_data = did_wallet_3.create_backup()
-
-    async with wallet_node_0.wallet_state_manager.lock:
-        did_wallet_4 = await DIDWallet.create_new_did_wallet_from_recovery(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            backup_data,
-        )
-    assert did_wallet_4.get_name() == "Profile 2"
-    env_0.wallet_aliases["did_2"] = 3
-
-    pubkey = (await did_wallet_4.wallet_state_manager.get_unused_derivation_record(did_wallet_2.wallet_info.id)).pubkey
-    new_ph = did_wallet_4.did_info.temp_puzhash
-    async with did_wallet.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        message_spend_bundle, attest1 = await did_wallet.create_attestment(coin.name(), new_ph, pubkey, action_scope)
-
-    async with did_wallet_2.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope_2:
-        message_spend_bundle2, attest2 = await did_wallet_2.create_attestment(
-            coin.name(), new_ph, pubkey, action_scope_2
         )
 
-    message_spend_bundle = message_spend_bundle.aggregate([message_spend_bundle, message_spend_bundle2])
-
-    (
-        test_info_list,
-        test_message_spend_bundle,
-    ) = await did_wallet_4.load_attest_files_for_recovery_spend([attest1, attest2])
-    assert message_spend_bundle == test_message_spend_bundle
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "spendable_balance": -101,
-                        "pending_change": 101,
-                        "max_send_amount": -101,
-                        "pending_coin_removal_count": 1,
-                        "set_remainder": True,
-                    },
-                    "did_2": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 0,
-                        "pending_change": 0,
-                        "pending_coin_removal_count": 0,
-                    },
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "spendable_balance": 101,
-                        "pending_change": -101,
-                        "max_send_amount": 101,
-                        "pending_coin_removal_count": -1,
-                    },
-                    "did_2": {
-                        "confirmed_wallet_balance": 0,
-                        "spendable_balance": 0,
-                        "max_send_amount": 0,
-                        "unspent_coin_count": 0,
-                        "pending_change": 0,
-                        "pending_coin_removal_count": 0,
-                    },
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "spendable_balance": -101,
-                        "pending_change": 101,
-                        "max_send_amount": -101,
-                        "pending_coin_removal_count": 1,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "spendable_balance": 101,
-                        "pending_change": -101,
-                        "max_send_amount": 101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-
-    async with did_wallet_4.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        await did_wallet_4.recovery_spend(coin, new_ph, test_info_list, pubkey, message_spend_bundle, action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_2": {
-                        "unconfirmed_wallet_balance": 201,
-                        "pending_change": 0,
-                        "pending_coin_removal_count": 3,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": 201,
-                        "spendable_balance": 201,
-                        "max_send_amount": 201,
-                        "unspent_coin_count": 1,
-                        "pending_change": 0,
-                        "pending_coin_removal_count": -3,
-                    },
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_2": {
-                        "unconfirmed_wallet_balance": 0,  # TODO: fix pre-block balances for recovery
-                        "spendable_balance": 0,
-                        "pending_change": 0,
-                        "max_send_amount": 0,
-                        "pending_coin_removal_count": 0,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": -201,
-                        "spendable_balance": -201,
-                        "max_send_amount": -201,
-                        "unspent_coin_count": -1,
-                        "set_remainder": True,
-                    },
-                },
-            ),
-        ]
-    )
-
-    for wallet in [did_wallet, did_wallet_2, did_wallet_3, did_wallet_4]:
-        assert wallet.wallet_state_manager.wallets[wallet.id()] == wallet
-
-
-@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
-@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
-@pytest.mark.anyio
-async def test_did_recovery_with_empty_set(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
-    env_0 = wallet_environments.environments[0]
-    wallet_node_0 = env_0.node
-    wallet_0 = env_0.xch_wallet
-
-    env_0.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
-
-    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
-
-    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        did_wallet: DIDWallet = await make_did_wallet(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            uint64(101),
-            action_scope,
-            use_alternate_recovery=use_alternate_recovery,
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-    coin = await did_wallet.get_coin()
-    info: list[tuple[bytes, bytes, int]] = []
-    pubkey = (await did_wallet.wallet_state_manager.get_unused_derivation_record(did_wallet.wallet_info.id)).pubkey
-    with pytest.raises(Exception):  # We expect a CLVM 80 error for this test
-        async with did_wallet.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=False
-        ) as action_scope:
-            await did_wallet.recovery_spend(
-                coin,
-                ph,
-                info,
-                pubkey,
-                WalletSpendBundle([], AugSchemeMPL.aggregate([])),
-                action_scope,
-            )
-
-
-@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
-@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
-@pytest.mark.anyio
-async def test_did_find_lost_did(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
-    env_0 = wallet_environments.environments[0]
-    wallet_node_0 = env_0.node
-    wallet_0 = env_0.xch_wallet
-
-    env_0.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
-
-    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet_0 = await make_did_wallet(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            uint64(101),
-            action_scope,
-            use_alternate_recovery=use_alternate_recovery,
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-
-    # Delete the coin and wallet
-    coin = await did_wallet_0.get_coin()
-    await wallet_node_0.wallet_state_manager.coin_store.delete_coin_record(coin.name())
-    await wallet_node_0.wallet_state_manager.delete_wallet(did_wallet_0.wallet_info.id)
-    wallet_node_0.wallet_state_manager.wallets.pop(did_wallet_0.wallet_info.id)
-    assert len(wallet_node_0.wallet_state_manager.wallets) == 1
-    # Find lost DID
-    assert did_wallet_0.did_info.origin_coin is not None  # mypy
-    await env_0.rpc_client.find_lost_did(DIDFindLostDID(did_wallet_0.did_info.origin_coin.name().hex()))
-    did_wallets = list(
-        filter(
-            lambda w: (w.type == WalletType.DECENTRALIZED_ID),
-            await wallet_node_0.wallet_state_manager.get_all_wallet_info_entries(),
-        )
-    )
-    did_wallet = wallet_node_0.wallet_state_manager.wallets[did_wallets[0].id]
-    assert isinstance(did_wallet, DIDWallet)
-    env_0.wallet_aliases["did_found"] = did_wallets[0].id
-    await env_0.change_balances(
-        {
-            "did_found": {
-                "init": True,
-                "confirmed_wallet_balance": 101,
-                "unconfirmed_wallet_balance": 101,
-                "spendable_balance": 101,
-                "max_send_amount": 101,
-                "unspent_coin_count": 1,
-            }
-        }
-    )
-    await env_0.check_balances()
-
-    # Spend DID
-    recovery_list = [bytes32.fromhex(did_wallet.get_my_DID())]
-    await did_wallet.update_recovery_list(recovery_list, uint64(1))
-    assert did_wallet.did_info.backup_ids == recovery_list
-    async with did_wallet.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        await did_wallet.create_update_spend(action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_found": {
-                        "spendable_balance": -101,
-                        "max_send_amount": -101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_found": {
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-
-    # Delete the coin and change inner puzzle
-    coin = await did_wallet.get_coin()
-    await wallet_node_0.wallet_state_manager.coin_store.delete_coin_record(coin.name())
-    with wallet_environments.new_puzzle_hashes_allowed():
-        async with did_wallet.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            new_inner_puzzle = await did_wallet.get_did_innerpuz(action_scope, override_reuse_puzhash_with=False)
-    did_wallet.did_info = dataclasses.replace(did_wallet.did_info, current_inner=new_inner_puzzle)
-    # Recovery the coin
-    assert did_wallet.did_info.origin_coin is not None  # mypy
-    await env_0.rpc_client.find_lost_did(DIDFindLostDID(did_wallet.did_info.origin_coin.name().hex()))
-    found_coin = await did_wallet.get_coin()
-    assert found_coin == coin
-    assert did_wallet.did_info.current_inner != new_inner_puzzle
-
-
-@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
-@pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [1, 1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
-@pytest.mark.anyio
-async def test_did_attest_after_recovery(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
-    env_0 = wallet_environments.environments[0]
-    env_1 = wallet_environments.environments[1]
-    wallet_node_0 = env_0.node
-    wallet_node_1 = env_1.node
-    wallet_0 = env_0.xch_wallet
-    wallet_1 = env_1.xch_wallet
-
-    env_0.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
-    env_1.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
-
-    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet: DIDWallet = await make_did_wallet(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            uint64(101),
-            action_scope,
-            use_alternate_recovery=use_alternate_recovery,
-        )
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-            WalletStateTransition(),
-        ]
-    )
-
-    await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
-    await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
-    recovery_list = [bytes32.from_hexstr(did_wallet.get_my_DID())]
-
-    async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        did_wallet_2: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_1.wallet_state_manager, wallet_1, uint64(101), action_scope, recovery_list
-        )
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-
-    assert did_wallet_2.did_info.backup_ids == recovery_list
-
-    # Update coin with new ID info
-    recovery_list = [bytes32.from_hexstr(did_wallet_2.get_my_DID())]
-    await did_wallet.update_recovery_list(recovery_list, uint64(1))
-    assert did_wallet.did_info.backup_ids == recovery_list
-    async with did_wallet.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        await did_wallet.create_update_spend(action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    }
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    }
-                },
-            ),
-            WalletStateTransition(),
-        ]
-    )
-
-    # DID Wallet 2 recovers into DID Wallet 3 with new innerpuz
-    backup_data = did_wallet_2.create_backup()
-
-    async with wallet_node_0.wallet_state_manager.lock:
-        did_wallet_3 = await DIDWallet.create_new_did_wallet_from_recovery(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            backup_data,
-        )
-    env_0.wallet_aliases["did_2"] = 3
-    with wallet_environments.new_puzzle_hashes_allowed():
-        async with did_wallet_3.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            new_ph = (
-                await did_wallet_3.get_did_innerpuz(action_scope, override_reuse_puzhash_with=False)
-            ).get_tree_hash()
-    coin = await did_wallet_2.get_coin()
-    pubkey = (await did_wallet_3.wallet_state_manager.get_unused_derivation_record(did_wallet_3.wallet_info.id)).pubkey
-
-    async with did_wallet.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        message_spend_bundle, attest_data = await did_wallet.create_attestment(
-            coin.name(), new_ph, pubkey, action_scope
-        )
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    },
-                    "did_2": {
-                        "init": True,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    },
-                    "did_2": {
-                        "set_remainder": True,
-                    },
-                },
-            ),
-            WalletStateTransition(),
-        ]
-    )
-
-    (
-        info,
-        message_spend_bundle,
-    ) = await did_wallet_3.load_attest_files_for_recovery_spend([attest_data])
-    async with did_wallet_3.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await did_wallet_3.recovery_spend(coin, new_ph, info, pubkey, message_spend_bundle, action_scope)
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_2": {
-                        "unconfirmed_wallet_balance": 101,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": 101,
-                        "set_remainder": True,
-                    },
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "unconfirmed_wallet_balance": 0,  # TODO: fix pre-block balances for recovery
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "confirmed_wallet_balance": -101,
-                        "set_remainder": True,
-                    },
-                },
-            ),
-        ]
-    )
-
-    # DID Wallet 1 recovery spends into DID Wallet 4
-    backup_data = did_wallet.create_backup()
-
-    async with wallet_node_1.wallet_state_manager.lock:
-        did_wallet_4 = await DIDWallet.create_new_did_wallet_from_recovery(
-            wallet_node_1.wallet_state_manager,
-            wallet_1,
-            backup_data,
-        )
-    env_1.wallet_aliases["did_2"] = 3
-    coin = await did_wallet.get_coin()
-    with wallet_environments.new_puzzle_hashes_allowed():
-        async with did_wallet_4.wallet_state_manager.new_action_scope(
-            wallet_environments.tx_config, push=True
-        ) as action_scope:
-            new_ph = (
-                await did_wallet_4.get_did_innerpuz(action_scope, override_reuse_puzhash_with=False)
-            ).get_tree_hash()
-    pubkey = (await did_wallet_4.wallet_state_manager.get_unused_derivation_record(did_wallet_4.wallet_info.id)).pubkey
-    async with did_wallet_3.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        message_spend_bundle, attest1 = await did_wallet_3.create_attestment(coin.name(), new_ph, pubkey, action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_2": {
-                        "unconfirmed_wallet_balance": 0,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": 0,
-                        "set_remainder": True,
-                    },
-                },
-            ),
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did_2": {
-                        "init": True,
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": 0,
-                        "set_remainder": True,
-                    },
-                },
-            ),
-        ]
-    )
-
-    (
-        test_info_list,
-        test_message_spend_bundle,
-    ) = await did_wallet_4.load_attest_files_for_recovery_spend([attest1])
-    async with did_wallet_4.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await did_wallet_4.recovery_spend(coin, new_ph, test_info_list, pubkey, test_message_spend_bundle, action_scope)
-
     await wallet_environments.process_pending_states(
         [
             WalletStateTransition(
                 pre_block_balance_updates={
-                    "did": {
+                    "xch": {
                         "set_remainder": True,
                     },
+                    "did": {
+                        "init": True,
+                        "unconfirmed_wallet_balance": 101,
+                        "pending_change": 101,
+                        "pending_coin_removal_count": 1,
+                    },
                 },
                 post_block_balance_updates={
-                    "did": {
-                        "confirmed_wallet_balance": -101,
+                    "xch": {
                         "set_remainder": True,
                     },
+                    "did": {
+                        "confirmed_wallet_balance": 101,
+                        "spendable_balance": 101,
+                        "max_send_amount": 101,
+                        "unspent_coin_count": 1,
+                        "pending_change": -101,
+                        "pending_coin_removal_count": -1,
+                    },
                 },
             ),
+        ]
+    )
+
+    # Delete the coin and wallet
+    coin = await did_wallet_0.get_coin()
+    await wallet_node_0.wallet_state_manager.coin_store.delete_coin_record(coin.name())
+    await wallet_node_0.wallet_state_manager.delete_wallet(did_wallet_0.wallet_info.id)
+    wallet_node_0.wallet_state_manager.wallets.pop(did_wallet_0.wallet_info.id)
+    assert len(wallet_node_0.wallet_state_manager.wallets) == 1
+    # Find lost DID
+    assert did_wallet_0.did_info.origin_coin is not None  # mypy
+    await env_0.rpc_client.find_lost_did(DIDFindLostDID(did_wallet_0.did_info.origin_coin.name().hex()))
+    did_wallets = list(
+        filter(
+            lambda w: (w.type == WalletType.DECENTRALIZED_ID),
+            await wallet_node_0.wallet_state_manager.get_all_wallet_info_entries(),
+        )
+    )
+    did_wallet = wallet_node_0.wallet_state_manager.wallets[did_wallets[0].id]
+    assert isinstance(did_wallet, DIDWallet)
+    env_0.wallet_aliases["did_found"] = did_wallets[0].id
+    await env_0.change_balances(
+        {
+            "did_found": {
+                "init": True,
+                "confirmed_wallet_balance": 101,
+                "unconfirmed_wallet_balance": 101,
+                "spendable_balance": 101,
+                "max_send_amount": 101,
+                "unspent_coin_count": 1,
+            }
+        }
+    )
+    await env_0.check_balances()
+
+    # Spend DID
+    async with did_wallet.wallet_state_manager.new_action_scope(
+        wallet_environments.tx_config, push=True
+    ) as action_scope:
+        await did_wallet.create_update_spend(action_scope)
+
+    await wallet_environments.process_pending_states(
+        [
             WalletStateTransition(
                 pre_block_balance_updates={
-                    "did_2": {
-                        "set_remainder": True,
+                    "did_found": {
+                        "spendable_balance": -101,
+                        "max_send_amount": -101,
+                        "pending_change": 101,
+                        "pending_coin_removal_count": 1,
                     },
                 },
                 post_block_balance_updates={
-                    "did_2": {
-                        "confirmed_wallet_balance": 101,
-                        "set_remainder": True,
+                    "did_found": {
+                        "spendable_balance": 101,
+                        "max_send_amount": 101,
+                        "pending_change": -101,
+                        "pending_coin_removal_count": -1,
                     },
                 },
             ),
         ]
     )
 
-    for wallet in [did_wallet, did_wallet_3, did_wallet_4]:
-        assert wallet.wallet_state_manager.wallets[wallet.id()] == wallet
+    # Delete the coin and change inner puzzle
+    coin = await did_wallet.get_coin()
+    await wallet_node_0.wallet_state_manager.coin_store.delete_coin_record(coin.name())
+    with wallet_environments.new_puzzle_hashes_allowed():
+        async with did_wallet.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
+            new_inner_puzzle = await did_wallet.get_did_innerpuz(action_scope, override_reuse_puzhash_with=False)
+    did_wallet.did_info = dataclasses.replace(did_wallet.did_info, current_inner=new_inner_puzzle)
+    # Recovery the coin
+    assert did_wallet.did_info.origin_coin is not None  # mypy
+    await env_0.rpc_client.find_lost_did(DIDFindLostDID(did_wallet.did_info.origin_coin.name().hex()))
+    found_coin = await did_wallet.get_coin()
+    assert found_coin == coin
+    assert did_wallet.did_info.current_inner != new_inner_puzzle
 
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
 @pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [1, 1]}], indirect=True)
-@pytest.mark.parametrize(
-    "with_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
-async def test_did_transfer(wallet_environments: WalletTestFramework, with_recovery: bool):
+async def test_did_transfer(wallet_environments: WalletTestFramework):
     env_0 = wallet_environments.environments[0]
     env_1 = wallet_environments.environments[1]
     wallet_node_0 = env_0.node
@@ -1343,8 +449,6 @@ async def test_did_transfer(wallet_environments: WalletTestFramework, with_recov
         "xch": 1,
         "did": 2,
     }
-    async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
     fee = uint64(1000)
 
     async with wallet_0.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
@@ -1353,8 +457,6 @@ async def test_did_transfer(wallet_environments: WalletTestFramework, with_recov
             wallet_0,
             uint64(101),
             action_scope,
-            [ph],
-            uint64(1),
             {"Twitter": "Test", "GitHub": "测试"},
             fee=fee,
         )
@@ -1398,7 +500,7 @@ async def test_did_transfer(wallet_environments: WalletTestFramework, with_recov
     async with did_wallet_1.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=True
     ) as action_scope:
-        await did_wallet_1.transfer_did(new_puzhash, fee, with_recovery, action_scope)
+        await did_wallet_1.transfer_did(new_puzhash, fee, action_scope)
 
     await wallet_environments.process_pending_states(
         [
@@ -1442,9 +544,6 @@ async def test_did_transfer(wallet_environments: WalletTestFramework, with_recov
     assert isinstance(did_wallet_2, DIDWallet)  # mypy
     assert len(wallet_node_0.wallet_state_manager.wallets) == 1
     assert did_wallet_1.did_info.origin_coin == did_wallet_2.did_info.origin_coin
-    if with_recovery:
-        assert did_wallet_1.did_info.backup_ids[0] == did_wallet_2.did_info.backup_ids[0]
-        assert did_wallet_1.did_info.num_of_backup_ids_needed == did_wallet_2.did_info.num_of_backup_ids_needed
     metadata = json.loads(did_wallet_2.did_info.metadata)
     assert metadata["Twitter"] == "Test"
     assert metadata["GitHub"] == "测试"
@@ -1475,8 +574,6 @@ async def test_did_auto_transfer_limit(
     wallet = wallet_node.wallet_state_manager.main_wallet
     wallet2 = wallet_node_2.wallet_state_manager.main_wallet
     api_1 = WalletRpcApi(wallet_node_2)
-    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)
 
     if trusted:
         wallet_node.config["trusted_peers"] = {
@@ -1501,8 +598,6 @@ async def test_did_auto_transfer_limit(
                 wallet,
                 uint64(101),
                 action_scope,
-                [bytes32(bytes(ph))],
-                uint64(1),
                 {"Twitter": "Test", "GitHub": "测试"},
                 fee=fee,
             )
@@ -1517,7 +612,7 @@ async def test_did_auto_transfer_limit(
         async with wallet2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             new_puzhash = await action_scope.get_puzzle_hash(wallet2.wallet_state_manager)
         async with did_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-            await did_wallet_1.transfer_did(new_puzhash, fee, False, action_scope)
+            await did_wallet_1.transfer_did(new_puzhash, fee, action_scope)
         await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
         await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node, wallet_node_2])
         # Check if the DID wallet is created in the wallet2
@@ -1587,14 +682,11 @@ async def test_did_auto_transfer_limit(
     # Check we can still manually add new DIDs while at cap
     await full_node_api.farm_blocks_to_wallet(1, wallet2)
     async with wallet2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet2.wallet_state_manager)
         did_wallet_11: DIDWallet = await DIDWallet.create_new_did_wallet(
             wallet_node_2.wallet_state_manager,
             wallet2,
             uint64(101),
             action_scope,
-            [bytes32(bytes(ph))],
-            uint64(1),
             {"Twitter": "Test", "GitHub": "测试"},
             fee=fee,
         )
@@ -1612,97 +704,10 @@ async def test_did_auto_transfer_limit(
     assert len(did_wallets) == 11
 
 
-@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
-@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
-@pytest.mark.anyio
-async def test_update_recovery_list(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
-    env = wallet_environments.environments[0]
-    wallet_node = env.node
-    wallet = env.xch_wallet
-
-    env.wallet_aliases = {
-        "xch": 1,
-        "did": 2,
-    }
-
-    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
-        did_wallet_1: DIDWallet = await make_did_wallet(
-            wallet_node.wallet_state_manager,
-            wallet,
-            uint64(101),
-            action_scope,
-            use_alternate_recovery=use_alternate_recovery,
-        )
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "init": True,
-                        "unconfirmed_wallet_balance": 101,
-                        "pending_change": 101,
-                        "pending_coin_removal_count": 1,
-                    },
-                },
-                post_block_balance_updates={
-                    "xch": {
-                        "set_remainder": True,
-                    },
-                    "did": {
-                        "confirmed_wallet_balance": 101,
-                        "spendable_balance": 101,
-                        "max_send_amount": 101,
-                        "unspent_coin_count": 1,
-                        "pending_change": -101,
-                        "pending_coin_removal_count": -1,
-                    },
-                },
-            ),
-        ]
-    )
-    await did_wallet_1.update_recovery_list([ph], uint64(1))
-    async with did_wallet_1.wallet_state_manager.new_action_scope(
-        wallet_environments.tx_config, push=True
-    ) as action_scope:
-        await did_wallet_1.create_update_spend(action_scope)
-
-    await wallet_environments.process_pending_states(
-        [
-            WalletStateTransition(
-                pre_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    },
-                },
-                post_block_balance_updates={
-                    "did": {
-                        "set_remainder": True,
-                    },
-                },
-            ),
-        ]
-    )
-    assert did_wallet_1.did_info.backup_ids[0] == bytes(ph)
-    assert did_wallet_1.did_info.num_of_backup_ids_needed == 1
-
-
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
 @pytest.mark.parametrize("wallet_environments", [{"num_environments": 2, "blocks_needed": [1, 1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
-async def test_get_info(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
+async def test_get_info(wallet_environments: WalletTestFramework):
     env_0 = wallet_environments.environments[0]
     env_1 = wallet_environments.environments[1]
     wallet_node_0 = env_0.node
@@ -1730,10 +735,8 @@ async def test_get_info(wallet_environments: WalletTestFramework, use_alternate_
             wallet_0,
             did_amount,
             action_scope,
-            [],
             metadata={"twitter": "twitter"},
             fee=fee,
-            use_alternate_recovery=use_alternate_recovery,
         )
 
     await wallet_environments.process_pending_states(
@@ -1781,10 +784,7 @@ async def test_get_info(wallet_environments: WalletTestFramework, use_alternate_
     assert response.metadata["twitter"] == "twitter"
     assert response.latest_coin == (await did_wallet_1.get_coin()).name()
     assert response.num_verification == 0
-    if use_alternate_recovery:
-        assert response.recovery_list_hash is None
-    else:
-        assert response.recovery_list_hash == Program(Program.to([])).get_tree_hash()
+    assert response.recovery_list_hash == Program(Program.to([])).get_tree_hash()
     assert decode_puzzle_hash(response.p2_address) == response.hints[0]
 
     # Test non-singleton coin
@@ -1792,7 +792,7 @@ async def test_get_info(wallet_environments: WalletTestFramework, use_alternate_
         coin = (await wallet_0.select_coins(uint64(1), action_scope)).pop()
     assert coin.amount % 2 == 1
     coin_id = coin.name()
-    with pytest.raises(ValueError, match="The coin is not a DID."):
+    with pytest.raises(ValueError, match="The coin is not a DID"):
         await api_0.get_did_info(DIDGetInfo(coin_id.hex()))
 
     # Test multiple odd coins
@@ -1846,18 +846,14 @@ async def test_get_info(wallet_environments: WalletTestFramework, use_alternate_
         ]
     )
 
-    with pytest.raises(ValueError, match="This is not a singleton, multiple children coins found."):
+    with pytest.raises(ValueError, match=r"This is not a singleton, multiple children coins found."):
         await api_0.get_did_info(DIDGetInfo(coin_1.name().hex()))
 
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
 @pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
-async def test_message_spend(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
+async def test_message_spend(wallet_environments: WalletTestFramework):
     env = wallet_environments.environments[0]
     wallet_node = env.node
     wallet = env.xch_wallet
@@ -1876,9 +872,7 @@ async def test_message_spend(wallet_environments: WalletTestFramework, use_alter
             wallet,
             uint64(101),
             action_scope,
-            [],
             fee=fee,
-            use_alternate_recovery=use_alternate_recovery,
         )
     await wallet_environments.process_pending_states(
         [
@@ -1926,12 +920,8 @@ async def test_message_spend(wallet_environments: WalletTestFramework, use_alter
 
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
 @pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
-async def test_update_metadata(wallet_environments: WalletTestFramework, use_alternate_recovery: bool):
+async def test_update_metadata(wallet_environments: WalletTestFramework):
     env = wallet_environments.environments[0]
     wallet_node = env.node
     wallet = env.xch_wallet
@@ -1950,9 +940,7 @@ async def test_update_metadata(wallet_environments: WalletTestFramework, use_alt
             wallet,
             did_amount,
             action_scope,
-            [],
             fee=fee,
-            use_alternate_recovery=use_alternate_recovery,
         )
 
     await wallet_environments.process_pending_states(
@@ -2052,14 +1040,11 @@ async def test_did_sign_message(wallet_environments: WalletTestFramework):
     fee = uint64(1000)
 
     async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
         did_wallet_1: DIDWallet = await DIDWallet.create_new_did_wallet(
             wallet_node.wallet_state_manager,
             wallet,
             uint64(101),
             action_scope,
-            [ph],
-            uint64(1),
             {"Twitter": "Test", "GitHub": "测试"},
             fee=fee,
         )
@@ -2107,9 +1092,9 @@ async def test_did_sign_message(wallet_environments: WalletTestFramework):
     )
     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"
@@ -2123,9 +1108,9 @@ async def test_did_sign_message(wallet_environments: WalletTestFramework):
     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
@@ -2135,15 +1120,15 @@ async def test_did_sign_message(wallet_environments: WalletTestFramework):
         {
             "id": encode_puzzle_hash(did_wallet_1.did_info.origin_coin.name(), AddressType.DID.value),
             "message": message,
-            "is_hex": "False",
-            "safe_mode": "False",
+            "is_hex": False,
+            "safe_mode": False,
         }
     )
 
     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"
@@ -2158,99 +1143,12 @@ async def test_did_sign_message(wallet_environments: WalletTestFramework):
     )
 
     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(
-    "trusted",
-    [True, False],
-)
-@pytest.mark.anyio
-async def test_create_did_with_recovery_list(
-    self_hostname: str, two_nodes_two_wallets_with_same_keys: OldSimulatorsAndWallets, trusted: bool
-) -> None:
-    """
-    A DID is created on-chain in client0, causing a DID Wallet to be created in client1, which shares the same key.
-    This can happen if someone uses the same key on multiple computers, or is syncing a wallet from scratch.
-
-    For this test, we assign a recovery list hash at DID creation time, but the recovery list is not yet available
-    to the wallet_node that the DID Wallet is being created in (client1).
-
-    """
-    full_nodes, wallets, _ = two_nodes_two_wallets_with_same_keys
-    full_node_api = full_nodes[0]
-    full_node_server = full_node_api.server
-    wallet_node_0, server_0 = wallets[0]
-    wallet_node_1, server_1 = wallets[1]
-
-    wallet_0 = wallet_node_0.wallet_state_manager.main_wallet
-    wallet_1 = wallet_node_1.wallet_state_manager.main_wallet
-
-    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        ph0 = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
-    async with wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        ph1 = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
-
-    sk0 = await wallet_node_0.wallet_state_manager.get_private_key(ph0)
-    sk1 = await wallet_node_1.wallet_state_manager.get_private_key(ph1)
-    assert sk0 == sk1
-
-    if trusted:
-        wallet_node_0.config["trusted_peers"] = {
-            full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()
-        }
-        wallet_node_1.config["trusted_peers"] = {
-            full_node_api.full_node.server.node_id.hex(): full_node_api.full_node.server.node_id.hex()
-        }
-
-    else:
-        wallet_node_0.config["trusted_peers"] = {}
-        wallet_node_1.config["trusted_peers"] = {}
-    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)
-
-    await full_node_api.farm_blocks_to_wallet(1, wallet_0)
-    await full_node_api.farm_blocks_to_wallet(1, wallet_1)
-
-    # Node 0 sets up a DID Wallet with a backup set, but num_of_backup_ids_needed=0
-    # (a malformed solution, but legal for the clvm puzzle)
-    recovery_list = [bytes32(bytes.fromhex("00" * 32))]
-    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        did_wallet_0: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_0.wallet_state_manager,
-            wallet_0,
-            uint64(101),
-            action_scope,
-            backups_ids=recovery_list,
-            num_of_backup_ids_needed=uint64(0),
-        )
-
-    await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
-    await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_0])
-
-    await time_out_assert(15, did_wallet_0.get_confirmed_balance, 101)
-    await time_out_assert(15, did_wallet_0.get_unconfirmed_balance, 101)
-    await time_out_assert(15, did_wallet_0.get_pending_change_balance, 0)
-
-    await full_node_api.farm_blocks_to_wallet(1, wallet_0)
-
-    #######################
-    all_node_0_wallets = await wallet_node_0.wallet_state_manager.user_store.get_all_wallet_info_entries()
-    all_node_1_wallets = await wallet_node_1.wallet_state_manager.user_store.get_all_wallet_info_entries()
-    assert len(all_node_0_wallets) == len(all_node_1_wallets)
-
-    # Note that the inner program we expect is different than the on-chain inner.
-    # This means that we have more work to do in the checks for the two different spend cases of
-    # the DID wallet Singleton
-    # assert (
-    #    json.loads(all_node_0_wallets[1].data)["current_inner"]
-    #    == json.loads(all_node_1_wallets[1].data)["current_inner"]
-    # )
-
-
 #  TODO: See Issue CHIA-1544
 #  This test should be ported to WalletTestFramework once we can replace keys in the wallet node
 @pytest.mark.parametrize(
@@ -2273,8 +1171,6 @@ async def test_did_resync(
     fee = uint64(0)
     wallet_api_1 = WalletRpcApi(wallet_node_1)
     wallet_api_2 = WalletRpcApi(wallet_node_2)
-    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)
     if trusted:
         wallet_node_1.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
         wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
@@ -2292,8 +1188,6 @@ async def test_did_resync(
             wallet,
             uint64(101),
             action_scope,
-            [bytes32(ph)],
-            uint64(1),
             {"Twitter": "Test", "GitHub": "测试"},
             fee=fee,
         )
@@ -2306,7 +1200,7 @@ async def test_did_resync(
     async with wallet2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         new_puzhash = await action_scope.get_puzzle_hash(wallet2.wallet_state_manager)
     async with did_wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        await did_wallet_1.transfer_did(new_puzhash, fee, True, action_scope=action_scope)
+        await did_wallet_1.transfer_did(new_puzhash, fee, action_scope=action_scope)
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_1, wallet_node_2])
     # Check if the DID wallet is created in the wallet2
@@ -2354,12 +1248,8 @@ async def test_did_resync(
     ],
     indirect=True,
 )
-@pytest.mark.parametrize(
-    "use_alternate_recovery",
-    [True, False],
-)
 @pytest.mark.anyio
-async def test_did_coin_records(wallet_environments: WalletTestFramework, use_alternate_recovery: bool) -> None:
+async def test_did_coin_records(wallet_environments: WalletTestFramework) -> None:
     # Setup
     wallet_node = wallet_environments.environments[0].node
     wallet = wallet_environments.environments[0].xch_wallet
@@ -2371,7 +1261,6 @@ async def test_did_coin_records(wallet_environments: WalletTestFramework, use_al
             wallet,
             uint64(1),
             action_scope,
-            use_alternate_recovery=use_alternate_recovery,
         )
 
     await wallet_environments.process_pending_states(
@@ -2395,7 +1284,7 @@ async def test_did_coin_records(wallet_environments: WalletTestFramework, use_al
             wallet_environments.tx_config, push=True
         ) as action_scope:
             await did_wallet.transfer_did(
-                await action_scope.get_puzzle_hash(did_wallet.wallet_state_manager), uint64(0), True, action_scope
+                await action_scope.get_puzzle_hash(did_wallet.wallet_state_manager), uint64(0), action_scope
             )
         await wallet_environments.process_pending_states(
             [