While working on this PR https://github.com/bitcoin/bitcoin/pull/18570 I ran into a bit confusing situation where in one function a **CWallet reference** was expected while two others dealt with **CWallet pointers**. My initial reaction was: `let's harmonize them by making them references`. However, not being part of the PR itself I did't change anything and completed the PR first.

Now, after having analyzed the `rpcwallet.cpp` code I came to the conclusion that:

* converting them all into references is not the solution as they're originally **shared_ptr**s
* but also: there is no (visible) reason why every RPC function should begin like this:

```cpp
std::shared_ptr<CWallet> const pwallet = GetWalletForJSONRPCRequest(request);
const CWallet* const pwallet = wallet.get();
```

This clearly defeats the purpose of shared pointers for no obvious reason. *Maybe I am missing something?*

In my (unpublished) [code changes](https://github.com/brakmic/bitcoin/commit/0b3ee615491edf6f542631bf6ae6f72eac406550) all raw pointers got replaced with **shared_ptr**s but kept their original names (that is, *pwallet*). In the end, they're pointers too, so the most of the original code remained untouched.

However, some of the helper functions couldn't be changed because external code is accessing them and I didn't want to make this task "virulent". So I introduced new ("Ref") variants that expect **shared_ptr** parameters, namely: 

```cpp
void EnsureWalletRefIsUnlocked(const std::shared_ptr<CWallet>);
bool EnsureWalletRefIsAvailable(const std::shared_ptr<CWallet>, bool avoidException);
```

I have tested the code, with python and boost-tests, and could not find any errors. 
But before opening a PR I would like to open a discussion about this. 

Is there any reason to keep on working with raw pointers when every function call actually begins with *shared_ptr*s?

Regards,
}
        UniValue spk(UniValue::VOBJ);
        LOCK(desc_spk_man->cs_desc_man);
        const auto& wallet_descriptor = desc_spk_man->GetWalletDescriptor();
        std::string descriptor;
        if (!desc_spk_man->GetDescriptorString(descriptor, false)) {
            throw JSONRPCError(RPC_WALLET_ERROR, "Can't get normalized descriptor string.");
        }
        spk.pushKV("desc", descriptor);
        spk.pushKV("timestamp", wallet_descriptor.creation_time);
        const bool active = active_spk_mans.count(desc_spk_man) != 0;
        spk.pushKV("active", active);
        const auto& type = wallet_descriptor.descriptor->GetOutputType();
        if (active && type != nullopt) {
            spk.pushKV("internal", wallet->GetScriptPubKeyMan(*type, true) == desc_spk_man);
        }
        if (wallet_descriptor.descriptor->IsRange()) {
            UniValue range(UniValue::VARR);
            range.push_back(wallet_descriptor.range_start);
            range.push_back(wallet_descriptor.range_end - 1);
            spk.pushKV("range", range);
            spk.pushKV("next", wallet_descriptor.next_index);
        }
        response.push_back(spk);
    }
    return response;
},
    };
}