identity: make Keypair and Publickey opaque

[thomaseizinger]

Description

As already announced in some deprecation warnings, we want to encapsulate the KeyPair and PublicKey types to not expose enums anymore but just structs. This allows us to contain the cfg statements in our code and not bother our users with it.

Are you planning to do it yourself in a pull request?

Maybe, unless someone beats me to it.

[folex]

Hi!

That breaks some of our code: it was converting from libp2p:_identity::Keypair to our own KeyPair structure that defines stricter and simpler serialization.

But now, we're not able to match on the key type. Instead, we have to use try_into 3 times, which internally uses match 3 times instead of a single time. And the code looks... harder to read.

Instead of

match keypair {
  Ed25519(kp) => KeyPair::Ed25519(decode(kp)),
  Rsa(kp) => KeyPair::RSA(transmute(kp)),
  Secp256k1(kp) => KeyPair::Secp256k1(kp.into()),
}

We now have to do

impl From<libp2p_identity::Keypair> for KeyPair {
    fn from(key: libp2p_identity::Keypair) -> Self {
        key.try_into_ed25519().map(|kp| {
            KeyPair::Ed25519(decode(kp))
        }).or_else(
            key.try_into_rsa().map(|kp| KeyPair::RSA(transmute))
        ).or_else(key.try_into_secp256k1().map(|kp| {
            KeyPair::Secp256k1(kp.into())
        })).unwrap()
    }
}

This is less effective, because of all the matching and error handling underneath, and readability is far far worse.

Is there any chance you could at least expose key_type so we can know the key type, and match on that?

P.S. same holds for PublicKey

[thomaseizinger]

See #3649.