feat(multisig): public key registration

[cjcobb23]

Description

• Add a method to register public keys
• Add a query to fetch public keys
• Distinguish keys and signatures by type

Todos

• Unit tests
• Manual tests
• Documentation
• Connect epics/issues

Steps to Test

Expected Behaviour

Other Notes

AXE-1533

[cgorenflo]

are you sure about those locations? Why do two line inserts shift the lines by 3?

[cjcobb23]

I was wrong, it was supposed to be 2.

[cgorenflo]

looks like I didn't see this when it was added. Why does the signer struct have an optional signature?

[cgorenflo]

same goes for the operator

[cjcobb23]

this was from before, but it's due to the way Signer is used. It's returned by the GetMultisig query, which queries the status of a specific signing session. So it returns the signer, and the signature (if present).

I actually refactored this in a later PR to move the signature out of the Signer struct.

[cgorenflo]

is there a way to do this comparison cleaner?

[eguajardo]

was changed by CJ to .find(|&(addr, _)| addr == &info.sender.to_string()). Looks good to me

[cgorenflo]

should we throw away the key type here?

[cgorenflo]

why do KeyType and PublicKey need to be separate entities?

[cjcobb23]

We need KeyType on it's own at least for the query, and possibly for the execute msg

[cgorenflo]

why is the type information not part of the arguments of rotate_snapshot. I 100% guarantee you, this hardcoding is going to break the contract if we ever add another key type

[cjcobb23]

rotate snapshot is actually deleted in a later PR

[fish-sammy]

Just wanna confirm, later on the key type is gonna be passed in for rotate_snapshot? Is that the plan?

[cjcobb23]

We won't need rotate_snapshot later on, it's actually deleted in a later PR. We can just pass PublicKey in KeyGen execute message, if we want to keep KeyGen

[fish-sammy]

Discussed with Chris as well, here's what we came up with to make these nicer. Warning: pseudocode.

enum KeyType {
  ECDSA,
  ED25519,
}

enum Signature {
  ECDSA(HexBinary)
  ED25519(HexBinary)
}

enum PublicKey {
    ECDSA(HexBinary)
    ED25519(HexBinary)
}

trait KeyTyped {
  fn matches<T>(&self, other: T) -> bool where T: KeyTyped {
    self.key_type() == other.key_type()
  };

  fn key_type(&self) -> KeyType;
}

impl KeyTyped for PublicKey {
  fn key_type(&self) -> KeyType {
    match self {
      ECDSA(_) => KeyType::ECDSA,
      ED25519(_) => KeyType::ED25519,
    }
  }
}

impl KeyTyped for Signature {
  fn key_type(&self) -> KeyType {
    match self {
      ECDSA(_) => KeyType::ECDSA,
      ED25519(_) => KeyType::ED25519,
    }
  }
}

impl Signature {
  pub fn verify(&self, pub_key: PublicKey) -> Result<bool, Error> {
    if !self.matches(pub_key) {
      return Err(Error::new("Key type mismatch"));
    }

    match (self, pub_key) {
      (ECDSA(sig), ECDSA(pub_key)) => {
        todo!()
      },
      (ED25519(sig), ED25519(pub_key)) => {
        todo!()
      },
      _ => {
        panic!("Key type mismatch");
      }
    }
  }
}

[fish-sammy]

@cjcobb23 Also, you need to check out this https://serde.rs/enum-representations.html. I personally prefer it being internally tagged, i.e. #[serde(tag = "type")].

[cjcobb23]

I implemented this, take a look