Feat/substrate #73
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -5,3 +5,4 @@ pub mod hash; | |
| pub mod keypair; | ||
| pub mod mnemonic; | ||
| pub mod secp256k1; | ||
| pub mod sr25519; | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,100 @@ | ||
| use coins_bip39::{English, Mnemonic}; | ||
| use kos_types::{error::Error, Bytes32}; | ||
| use serde::{Deserialize, Deserializer, Serialize, Serializer}; | ||
| use sp_core::{sr25519, Pair}; | ||
| use wasm_bindgen::prelude::wasm_bindgen; | ||
|
|
||
| #[wasm_bindgen] | ||
| pub struct Sr25519KeyPair { | ||
| keypair: sr25519::Pair, | ||
| } | ||
|
|
||
| impl Serialize for Sr25519KeyPair { | ||
| fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error> | ||
| where | ||
| S: Serializer, | ||
| { | ||
| todo!() | ||
| } | ||
| } | ||
|
|
||
| impl<'de> Deserialize<'de> for Sr25519KeyPair { | ||
| fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error> | ||
| where | ||
| D: Deserializer<'de>, | ||
| { | ||
| todo!() | ||
| } | ||
| } | ||
|
|
||
| impl Clone for Sr25519KeyPair { | ||
| fn clone(&self) -> Sr25519KeyPair { | ||
| Sr25519KeyPair { | ||
| keypair: self.keypair.clone(), | ||
| } | ||
| } | ||
| } | ||
|
|
||
| impl Sr25519KeyPair { | ||
| pub fn random<R>(rng: &mut R) -> Self | ||
| where | ||
| R: rand::Rng + ?Sized, | ||
| { | ||
| let mut secret = Bytes32::zeroed(); | ||
| rng.fill(secret.as_mut()); | ||
|
|
||
| Sr25519KeyPair::new(secret.into()) | ||
| } | ||
|
|
||
| pub fn new(secret: [u8; 32]) -> Self { | ||
| let keypair = sr25519::Pair::from_seed_slice(&secret).unwrap(); | ||
|
There was a problem hiding this comment. Handle potential errors instead of using Using Apply this diff to handle the potential error: - let keypair = sr25519::Pair::from_seed_slice(&secret).unwrap();
+ let keypair = sr25519::Pair::from_seed_slice(&secret)?;Also, update the function signature to return a - pub fn new(secret: [u8; 32]) -> Self {
+ pub fn new(secret: [u8; 32]) -> Result<Self, Error> {And adjust the return statement: - Self { keypair }
+ Ok(Self { keypair })
|
||
| Self { keypair } | ||
| } | ||
|
|
||
| pub fn new_from_mnemonic_phrase_with_path( | ||
| phrase: &str, | ||
| path: &str, | ||
| password: Option<&str>, | ||
| ) -> Result<Self, Error> { | ||
| let mnemonic = Mnemonic::<English>::new_from_phrase(phrase)?; | ||
| Self::new_from_mnemonic(path, mnemonic, password) | ||
| } | ||
|
|
||
| pub fn new_from_mnemonic( | ||
| path: &str, | ||
| m: Mnemonic<English>, | ||
| password: Option<&str>, | ||
| ) -> Result<Self, Error> { | ||
| // Convert mnemonic to seed | ||
| let seed = format!("{}{}", m.to_phrase(), path); | ||
|
|
||
| // Derive keypair based on the provided path and seed | ||
| let keypair = Pair::from_string(&seed, password).unwrap(); | ||
|
There was a problem hiding this comment. Handle potential errors instead of using Using Apply this diff to handle the potential error: - let keypair = Pair::from_string(&seed, password).unwrap();
+ let keypair = Pair::from_string(&seed, password)?;Also, ensure that the function handles the
|
||
|
|
||
| Ok(Self { keypair }) | ||
| } | ||
| } | ||
|
|
||
| impl Sr25519KeyPair { | ||
| pub fn public_key(&self) -> Vec<u8> { | ||
| self.keypair.public().0.to_vec() | ||
| } | ||
|
|
||
| pub fn secret_key(&self) -> Vec<u8> { | ||
| self.keypair.to_raw_vec() | ||
| } | ||
| } | ||
|
|
||
| impl Sr25519KeyPair { | ||
| pub fn sign_digest(&self, message: &[u8]) -> Vec<u8> { | ||
| self.keypair.sign(message).0.to_vec() | ||
| } | ||
|
|
||
| pub fn verify_digest(&self, message: &[u8], signature: &[u8], public_key: &[u8]) -> bool { | ||
| let public = sr25519::Public::from_raw(<[u8; 32]>::try_from(public_key).unwrap()); | ||
|
|
||
| let signature = sr25519::Signature::from_raw(<[u8; 64]>::try_from(signature).unwrap()); | ||
|
Comment on lines
+94
to
+96
There was a problem hiding this comment. Handle potential errors instead of using Using Apply this diff to handle the potential errors: - let public = sr25519::Public::from_raw(<[u8; 32]>::try_from(public_key).unwrap());
+ let public = sr25519::Public::from_raw(<[u8; 32]>::try_from(public_key)?);- let signature = sr25519::Signature::from_raw(<[u8; 64]>::try_from(signature).unwrap());
+ let signature = sr25519::Signature::from_raw(<[u8; 64]>::try_from(signature)?);Adjust the function signature to return a - pub fn verify_digest(&self, message: &[u8], signature: &[u8], public_key: &[u8]) -> bool {
+ pub fn verify_digest(&self, message: &[u8], signature: &[u8], public_key: &[u8]) -> Result<bool, Error> {Update the return statement accordingly: - sr25519::Pair::verify(&signature, message, &public)
+ Ok(sr25519::Pair::verify(&signature, message, &public))
|
||
|
|
||
| sr25519::Pair::verify(&signature, message, &public) | ||
| } | ||
| } | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Handle potential
Nonevalues to prevent panicsIn the methods
sign_digest,verify_digest,public_key, andsecret_key, using.as_ref().unwrap()on thesr25519field can lead to a panic if the field isNone. Even though the current design assumes that the field will beSomewhenkey_typeisSr25519, it's safer to handle theNonecase explicitly to prevent unexpected panics and improve code robustness.Apply this diff to handle potential
Nonevalues:Similarly, update the
verify_digest,public_key, andsecret_keymethods to handleNonevalues appropriately.Also applies to: 98-102, 127-127, 143-143
🛠️ Refactor suggestion
Consider refactoring to reduce code duplication
The
matchstatements in the methodssign_digest,verify_digest,public_key, andsecret_keyhave repetitive patterns across different key types. Consider refactoring these methods to eliminate duplication, which will enhance maintainability and readability.For example, you could introduce a trait that defines common behaviors for key pairs and implement it for each key type. Then, store the key pair in an enum or a trait object to simplify method implementations.
Also applies to: 98-102, 127-127, 143-143