[LABS-312] Miscellaneous wallet RPC cleanups

chia/wallet/wallet_rpc_api.py

@@ -998,12 +998,8 @@ async def set_wallet_resync_on_startup(self, request: SetWalletResyncOnStartup)
         :param request: optionally pass in `enable` as bool to enable/disable resync
         :return:
         """
-        assert self.service.wallet_state_manager is not None
-        fingerprint = self.service.logged_in_fingerprint
-        if fingerprint is not None:
-            self.service.set_resync_on_startup(fingerprint, request.enable)
-        else:
-            raise ValueError("You need to login into wallet to use this RPC call")
+        assert self.service.logged_in_fingerprint is not None
+        self.service.set_resync_on_startup(self.service.logged_in_fingerprint, request.enable)
         return Empty()
 
     @marshal
@@ -1016,8 +1012,9 @@ async def get_sync_status(self, request: Empty) -> GetSyncStatusResponse:
 
     @marshal
     async def get_height_info(self, request: Empty) -> GetHeightInfoResponse:
-        height = await self.service.wallet_state_manager.blockchain.get_finished_sync_up_to()
-        return GetHeightInfoResponse(height=height)
+        return GetHeightInfoResponse(
+            height=await self.service.wallet_state_manager.blockchain.get_finished_sync_up_to()
+        )
 
     @marshal
     async def push_tx(self, request: PushTX) -> Empty:
@@ -1075,10 +1072,7 @@ async def get_auto_claim(self, request: Empty) -> AutoClaimSettings:
         :param request: None
         :return:
         """
-        auto_claim_settings = AutoClaimSettings.from_json_dict(
-            self.service.wallet_state_manager.config.get("auto_claim", {})
-        )
-        return auto_claim_settings
+        return AutoClaimSettings.from_json_dict(self.service.wallet_state_manager.config.get("auto_claim", {}))
 
     ##########################################################################################
     # Wallet Management
@@ -1150,7 +1144,6 @@ async def create_new_wallet(  # type: ignore[return]
                         request.name,
                     )
                     asset_id = cat_wallet.get_asset_id()
-                self.service.wallet_state_manager.state_changed("wallet_created")
                 return CreateNewWalletResponse(
                     unsigned_transactions=[],
                     transactions=[],
@@ -1358,11 +1351,12 @@ async def get_transaction_memo(self, request: GetTransactionMemo) -> GetTransact
                 )
                 assert len(coin_state_list) == 1
                 coin_spend = await fetch_coin_spend_for_coin_state(coin_state_list[0], peer)
-                tr = dataclasses.replace(tr, spend_bundle=WalletSpendBundle([coin_spend], G2Element()))
+                spend_bundle = WalletSpendBundle([coin_spend], G2Element())
             else:
                 raise ValueError(f"Transaction 0x{transaction_id.hex()} doesn't have any coin spend.")
-        assert tr.spend_bundle is not None
-        return GetTransactionMemoResponse(transaction_memos={transaction_id: compute_memos(tr.spend_bundle)})
+        else:
+            spend_bundle = tr.spend_bundle
+        return GetTransactionMemoResponse(transaction_memos={transaction_id: compute_memos(spend_bundle)})
 
     @tx_endpoint(push=False)
     @marshal
@@ -1445,12 +1439,13 @@ async def get_transactions(self, request: GetTransactions) -> GetTransactionsRes
 
     @marshal
     async def get_transaction_count(self, request: GetTransactionCount) -> GetTransactionCountResponse:
-        count = await self.service.wallet_state_manager.tx_store.get_transaction_count_for_wallet(
-            request.wallet_id, confirmed=request.confirmed, type_filter=request.type_filter
-        )
         return GetTransactionCountResponse(
             wallet_id=request.wallet_id,
-            count=uint16(count),
+            count=uint16(
+                await self.service.wallet_state_manager.tx_store.get_transaction_count_for_wallet(
+                    request.wallet_id, confirmed=request.confirmed, type_filter=request.type_filter
+                )
+            ),
         )
 
     @marshal
@@ -1459,16 +1454,14 @@ async def get_next_address(self, request: GetNextAddress) -> GetNextAddressRespo
         Returns a new address
         """
         wallet = self.service.wallet_state_manager.wallets[request.wallet_id]
-        selected = self.service.config["selected_network"]
-        prefix = self.service.config["network_overrides"]["config"][selected]["address_prefix"]
         if wallet.type() in {WalletType.STANDARD_WALLET, WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
             async with self.service.wallet_state_manager.new_action_scope(
                 DEFAULT_TX_CONFIG, push=request.save_derivations
             ) as action_scope:
                 raw_puzzle_hash = await action_scope.get_puzzle_hash(
                     self.service.wallet_state_manager, override_reuse_puzhash_with=not request.new_address
                 )
-            address = encode_puzzle_hash(raw_puzzle_hash, prefix)
+            address = self.service.wallet_state_manager.encode_puzzle_hash(raw_puzzle_hash)
         else:
             raise ValueError(f"Wallet type {wallet.type()} cannot create puzzle hashes")
 
@@ -1966,15 +1959,17 @@ async def get_cat_list(self, request: Empty) -> GetCATListResponse:
 
     @marshal
     async def cat_set_name(self, request: CATSetName) -> CATSetNameResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
-        await wallet.set_name(request.name)
+        await self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet).set_name(
+            request.name
+        )
         return CATSetNameResponse(wallet_id=request.wallet_id)
 
     @marshal
     async def cat_get_name(self, request: CATGetName) -> CATGetNameResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
-        name: str = wallet.get_name()
-        return CATGetNameResponse(wallet_id=request.wallet_id, name=name)
+        return CATGetNameResponse(
+            wallet_id=request.wallet_id,
+            name=self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet).get_name(),
+        )
 
     @marshal
     async def get_stray_cats(self, request: Empty) -> GetStrayCATsResponse:
@@ -1983,8 +1978,12 @@ async def get_stray_cats(self, request: Empty) -> GetStrayCATsResponse:
         :param request: RPC request
         :return: A list of unacknowledged CATs
         """
-        cats = await self.service.wallet_state_manager.interested_store.get_unacknowledged_tokens()
-        return GetStrayCATsResponse(stray_cats=[StrayCAT.from_json_dict(cat) for cat in cats])
+        return GetStrayCATsResponse(
+            stray_cats=[
+                StrayCAT.from_json_dict(cat)
+                for cat in await self.service.wallet_state_manager.interested_store.get_unacknowledged_tokens()
+            ]
+        )
 
     @tx_endpoint(push=True)
     @marshal
@@ -2052,9 +2051,12 @@ async def cat_spend(
 
     @marshal
     async def cat_get_asset_id(self, request: CATGetAssetID) -> CATGetAssetIDResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=CATWallet)
-        asset_id = wallet.get_asset_id()
-        return CATGetAssetIDResponse(asset_id=asset_id, wallet_id=request.wallet_id)
+        return CATGetAssetIDResponse(
+            asset_id=self.service.wallet_state_manager.get_wallet(
+                id=request.wallet_id, required_type=CATWallet
+            ).get_asset_id(),
+            wallet_id=request.wallet_id,
+        )
 
     @marshal
     async def cat_asset_id_to_name(self, request: CATAssetIDToName) -> CATAssetIDToNameResponse:
@@ -2203,9 +2205,9 @@ async def take_offer(
 
     @marshal
     async def get_offer(self, request: GetOffer) -> GetOfferResponse:
-        trade_mgr = self.service.wallet_state_manager.trade_manager
-
-        trade_record: TradeRecord | None = await trade_mgr.get_trade_by_id(request.trade_id)
+        trade_record: TradeRecord | None = await self.service.wallet_state_manager.trade_manager.get_trade_by_id(
+            request.trade_id
+        )
         if trade_record is None:
             raise ValueError(f"No trade with trade id: {request.trade_id.hex()}")
 
@@ -2218,9 +2220,7 @@ async def get_offer(self, request: GetOffer) -> GetOfferResponse:
 
     @marshal
     async def get_all_offers(self, request: GetAllOffers) -> GetAllOffersResponse:
-        trade_mgr = self.service.wallet_state_manager.trade_manager
-
-        all_trades = await trade_mgr.trade_store.get_trades_between(
+        all_trades = await self.service.wallet_state_manager.trade_manager.trade_store.get_trades_between(
             request.start,
             request.end,
             sort_key=request.sort_key,
@@ -2245,9 +2245,11 @@ async def get_all_offers(self, request: GetAllOffers) -> GetAllOffersResponse:
 
     @marshal
     async def get_offers_count(self, request: Empty) -> GetOffersCountResponse:
-        trade_mgr = self.service.wallet_state_manager.trade_manager
-
-        (total, my_offers_count, taken_offers_count) = await trade_mgr.trade_store.get_trades_count()
+        (
+            total,
+            my_offers_count,
+            taken_offers_count,
+        ) = await self.service.wallet_state_manager.trade_manager.trade_store.get_trades_count()
 
         return GetOffersCountResponse(
             total=uint16(total), my_offers_count=uint16(my_offers_count), taken_offers_count=uint16(taken_offers_count)
@@ -2261,9 +2263,8 @@ async def cancel_offer(
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> CancelOfferResponse:
-        wsm = self.service.wallet_state_manager
         async with self.service.wallet_state_manager.lock:
-            await wsm.trade_manager.cancel_pending_offers(
+            await self.service.wallet_state_manager.trade_manager.cancel_pending_offers(
                 [request.trade_id],
                 action_scope,
                 fee=request.fee,
@@ -2324,14 +2325,17 @@ async def cancel_offers(
 
     @marshal
     async def did_set_wallet_name(self, request: DIDSetWalletName) -> DIDSetWalletNameResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
-        await wallet.set_name(request.name)
+        await self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet).set_name(
+            request.name
+        )
         return DIDSetWalletNameResponse(wallet_id=request.wallet_id)
 
     @marshal
     async def did_get_wallet_name(self, request: DIDGetWalletName) -> DIDGetWalletNameResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
-        return DIDGetWalletNameResponse(wallet_id=request.wallet_id, name=wallet.get_name())
+        return DIDGetWalletNameResponse(
+            wallet_id=request.wallet_id,
+            name=self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet).get_name(),
+        )
 
     @tx_endpoint(push=False)
     @marshal
@@ -2341,9 +2345,9 @@ async def did_message_spend(
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> DIDMessageSpendResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
-
-        await wallet.create_message_spend(
+        await self.service.wallet_state_manager.get_wallet(
+            id=request.wallet_id, required_type=DIDWallet
+        ).create_message_spend(
             action_scope,
             extra_conditions=(
                 *extra_conditions,
@@ -2604,19 +2608,16 @@ async def did_update_metadata(
     ) -> DIDUpdateMetadataResponse:
         wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         async with self.service.wallet_state_manager.lock:
-            update_success = await wallet.update_metadata(request.metadata)
             # Update coin with new ID info
-            if update_success:
-                await wallet.create_update_spend(action_scope, request.fee, extra_conditions=extra_conditions)
-                # tx_endpoint wrapper will take care of these default values
-                return DIDUpdateMetadataResponse(
-                    unsigned_transactions=[],
-                    transactions=[],
-                    wallet_id=request.wallet_id,
-                    spend_bundle=WalletSpendBundle([], G2Element()),
-                )
-            else:
-                raise ValueError(f"Couldn't update metadata with input: {request.metadata}")
+            await wallet.update_metadata(request.metadata)
+            await wallet.create_update_spend(action_scope, request.fee, extra_conditions=extra_conditions)
+            # tx_endpoint wrapper will take care of these default values
+            return DIDUpdateMetadataResponse(
+                unsigned_transactions=[],
+                transactions=[],
+                wallet_id=request.wallet_id,
+                spend_bundle=WalletSpendBundle([], G2Element()),
+            )
 
     @marshal
     async def did_get_did(self, request: DIDGetDID) -> DIDGetDIDResponse:
@@ -2640,9 +2641,10 @@ async def did_get_metadata(self, request: DIDGetMetadata) -> DIDGetMetadataRespo
 
     @marshal
     async def did_get_pubkey(self, request: DIDGetPubkey) -> DIDGetPubkeyResponse:
-        wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
+        # opportunity to raise
+        self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         return DIDGetPubkeyResponse(
-            pubkey=(await wallet.wallet_state_manager.get_unused_derivation_record(request.wallet_id)).pubkey
+            pubkey=(await self.service.wallet_state_manager.get_unused_derivation_record(request.wallet_id)).pubkey
         )
 
     @marshal
@@ -2665,8 +2667,12 @@ async def did_get_current_coin_info(self, request: DIDGetCurrentCoinInfo) -> DID
 
     @marshal
     async def did_create_backup_file(self, request: DIDCreateBackupFile) -> DIDCreateBackupFileResponse:
-        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
-        return DIDCreateBackupFileResponse(wallet_id=request.wallet_id, backup_data=did_wallet.create_backup())
+        return DIDCreateBackupFileResponse(
+            wallet_id=request.wallet_id,
+            backup_data=self.service.wallet_state_manager.get_wallet(
+                id=request.wallet_id, required_type=DIDWallet
+            ).create_backup(),
+        )
 
     @tx_endpoint(push=True)
     @marshal
@@ -2676,10 +2682,11 @@ async def did_transfer_did(
         action_scope: WalletActionScope,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> DIDTransferDIDResponse:
-        did_wallet = self.service.wallet_state_manager.get_wallet(id=request.wallet_id, required_type=DIDWallet)
         puzzle_hash: bytes32 = decode_puzzle_hash(request.inner_address)
         async with self.service.wallet_state_manager.lock:
-            await did_wallet.transfer_did(
+            await self.service.wallet_state_manager.get_wallet(
+                id=request.wallet_id, required_type=DIDWallet
+            ).transfer_did(
                 puzzle_hash,
                 request.fee,
                 action_scope,
@@ -3418,11 +3425,10 @@ async def pw_join_pool(
         ):
             raise ValueError(f"Already farming to pool {pool_wallet_info.current.pool_url}")
 
-        owner_pubkey = pool_wallet_info.current.owner_pubkey
         new_target_state: PoolState = create_pool_state(
             FARMING_TO_POOL,
             request.target_puzzlehash,
-            owner_pubkey,
+            pool_wallet_info.current.owner_pubkey,
             request.pool_url,
             request.relative_lock_height,
         )