Most of these hassles is because of the following requirement (and maybe also the asynchronous handling of setting a state):

If a new requested comes by, the previously sent request should be cancelled.

Now lets dive into the code: First of all std::shared_future is used instead of std::future intentionally so by calling the get method on the future object from any thread, the object still stays valid. If future object was a type of std::future, the first call of get method makes the object invalid. So, by that statement, checkFuture on SM cannot have any affect on the StateClient. Then, better to put SM outside of this equation to avoid any confusion for now.

Now lets get back to StateClient and take a look to the following code:

            if (mSetStateFuture.valid())
            {
                try
                {
                    const ExecErrc cExecErrc{ExecErrc::kCancelled};
                    setPromiseException(mSetStatePromise, cExecErrc);
                }
                catch (std::future_error)
                {
                    // Catch the exception if the promise is already set
                }

                mSetStatePromise = std::promise<void>();
            }

            std::vector<uint8_t> _rpcPayload;
            state.Serialize(_rpcPayload);
            mSetStateFuture =
                getFuture(mSetStatePromise, cSetStateId, _rpcPayload);

            return mSetStateFuture;

As you said, by calling the method for the first time, the if-statement will be skipped, and before return, mSetStateFuture becomes valid. However, (surprisingly) mSetStateFuture will be kept valid even if the state has been set already on EM and it has been notified back via setStateHandler. But why? Because when StateClient returns the future, it only has control of when to set the future value via the corresponding promise, but it does not have any clue when somebody may get that value.

So, if StateClient invalidates the future, it is actually breaking the promise without notifying the owners of the future-copy (those who have already called SetState). However, if somebody calls SetState again in this moment, StateClient is going to tell to the previous callers that:

if you guys get the value of the future (that you have already owned) from this moment, you will get the kCancelled exception (because you are too late now and I need to process a new request).

Then it renews the promise mSetStatePromise = std::promise<void>() and then it renews the future mSetStateFuture = getFuture(mSetStatePromise, cSetStateId, _rpcPayload); and it returns the future object to the current caller.