Keystore overhaul (final)

[davxy]

Closes #13556

polkadot companion: paritytech/polkadot#6944

cumulus companion: paritytech/cumulus#2371

---

Within this PR:

• Removal of CryptoTypePublicId type
• Introduce explicit signing methods to the Keystore trait
• Keystore::sign_with method has been retained. But a default implementation has been provided in the trait definition. In the end this is a convenience method that can be used in some specific use cases (to prevent code duplication in all the cases where the key is generic such as AURA).
  • nevertheless in all the places where we can use the explicit keystore methods we save the casts to and from raw byte vectors that by definition are fallible (but in our use cases were infallible)
• Trivial renaming of AppKey trait to AppCrypto. The trait is implemented by types (signatures included) from whom the whole set of application crypto associated types and consts can be retrieved. Thus this new name fits better
• CRYPTO_ID in AppCrypto has been retained because without it sign_with can't work
• Wherever is possible prefer infallible sign methods over fallible sign_with

[davxy]

bot merge

[bkchr]

I thought you wanted to remove CRYPTO_ID ?

[davxy]

@bkchr

Yes, that was indeed the awesome original idea.

Unfortunately, though, considering that AURA is generic over the crypto scheme, we need a way to select the correct scheme to use.

The ideal solution (IIRC something like what you suggested during our chat), is to have a sign-with method generic over an object implementing Pair.
That is, something like this

Thus a generic sign_with method would look like:

fn sign_with<P: Pair>(&self, id: AppCryptoId, public: &P::Public, msg: &[u8]) -> P::Signature;

Sadly a trait with a method like this can't be made into a trait-objejct (as it depends on a generic type) and we use the keystore as a Arc<dyn Keystore> all over the project.

[koute]

Sadly a trait with a method like this can't be made into a trait-objejct (as it depends on a generic type) and we use the keystore as a Arc<dyn Keystore> all over the project.

Well, if you'd go through &dyn then you could, e.g.:

use std::sync::Arc;

trait Public {}
trait Pair {
    type Public: Public;
    type Signature: 'static;
}

trait Keystore {
    fn yo_sign_this_plz_impl(&self, pair: &dyn Public) -> Box<dyn std::any::Any>;
}

impl dyn Keystore {
    fn yo_sign_this_plz<P: Pair>(&self, pair: &P::Public) -> P::Signature {
        match self.yo_sign_this_plz_impl(pair).downcast() {
            Ok(sig) => *sig,
            Err(_) => unreachable!()
        }
    }
}

fn it_works<P: Pair>(keystore: Arc<dyn Keystore>, pubkey: P::Public) -> P::Signature {
    keystore.yo_sign_this_plz::<P>(&pubkey)
}

But (in this example) this would require that Public is now object safe, so you'd have to use similar tricks for it, and so on until you make everything object safe all the way to the bottom. It's turtles all the way down. Probably not worth it though?