Bls Keystore and Mnemonic (#72)

This PR integrates https://github.com/Layr-Labs/rust-bls-bn254 

- [x] [Keystore]

- [x] [Mnemonic]

---------

Co-authored-by: ricomateo <mrico@fi.uba.ar>
Co-authored-by: tomasarrachea <tomas.arrachea@lambdaclass.com>
Co-authored-by: Pablo Deymonnaz <deymonnaz@gmail.com>
Co-authored-by: Mateo Rico <ricomateo@users.noreply.github.com>
Co-authored-by: Pablo Deymonnaz <pdeymon@fi.uba.ar>
Co-authored-by: supernovahs <supernovahs@proton.me>

crates/eigen-cli/Cargo.toml

@@ -15,6 +15,7 @@ ark-ec.workspace = true
 ark-ff.workspace = true
 ark-serialize.workspace = true
 clap.workspace = true
+colored = "2.1.0"
 eigen-crypto-bls.workspace = true
 eigen-testing-utils.workspace = true
 eigen-types.workspace = true
@@ -25,6 +26,7 @@ k256.workspace = true
 num-bigint.workspace = true
 rand.workspace = true
 rand_core.workspace = true
+rust-bls-bn254.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true

crates/eigen-cli/src/args.rs

@@ -1,7 +1,11 @@
 use crate::ANVIL_RPC_URL;
 use alloy_primitives::Address;
 use clap::{ArgGroup, Parser, Subcommand};
-
+use rust_bls_bn254::{
+    CHINESE_SIMPLIFIED_WORD_LIST, CHINESE_TRADITIONAL_WORD_LIST, CZECH_WORD_LIST,
+    ENGLISH_WORD_LIST, ITALIAN_WORD_LIST, KOREAN_WORD_LIST, PORTUGUESE_WORD_LIST,
+    SPANISH_WORD_LIST,
+};
 #[derive(Parser, Debug)]
 #[command(
     about = "Eigenlayer CLI tools",
@@ -102,10 +106,83 @@ It creates the following artifacts based on arguments
         #[arg(long, help = "password to encrypt key")]
         password: Option<String>,
     },
+
+    #[command(
+        about = "Using Pbkfd2 / scrypt encryption to secure the bls key.",
+        alias = "b"
+    )]
+    BlsConvert {
+        #[arg(long, help = "Bls keystore type (pbkdf2 or scrypt)")]
+        #[clap(value_enum)]
+        key_type: BlsKeystoreType,
+
+        #[arg(long, help = "bls key to encrypt in hex")]
+        secret_key: String,
+
+        #[arg(long, help = "file path to store key")]
+        output_path: String,
+
+        #[arg(long, help = "password to encrypt key(default is empty string)")]
+        password: Option<String>,
+    },
+    #[command(about = "Create a new mnemonic from default word lists", alias = "md")]
+    CreateNewMnemonicFromDefaultWordList {
+        #[arg(long, help = "Mnemonic language select")]
+        #[clap(value_enum)]
+        language: MnemonicLanguage,
+    },
+    #[command(
+        about = "Create a new mnemonic from given word list at path",
+        alias = "mp"
+    )]
+    CreateNewMnemonicFromPath {
+        #[arg(long, help = "Mnemonic language select")]
+        #[clap(value_enum)]
+        language: MnemonicLanguage,
+        #[arg(long, help = "Path to a the directory where lists are stored)")]
+        path: String,
+    },
 }
 
 #[derive(clap::ValueEnum, Debug, Clone)]
 pub enum KeyType {
     Ecdsa,
     Bls,
 }
+
+#[derive(clap::ValueEnum, Debug, Clone)]
+pub enum BlsKeystoreType {
+    Pbkdf2,
+    Scrypt,
+}
+
+#[derive(clap::ValueEnum, Debug, Clone)]
+pub enum MnemonicLanguage {
+    English,
+    ChineseSimplified,
+    ChineseTraditional,
+    Italian,
+    Czech,
+    Korean,
+    Portuguese,
+    Spanish,
+}
+
+impl MnemonicLanguage {
+    pub fn try_from(&self) -> (&str, &str) {
+        match self {
+            MnemonicLanguage::English => ("english", ENGLISH_WORD_LIST),
+            MnemonicLanguage::ChineseSimplified => {
+                ("chinese_simplified", CHINESE_SIMPLIFIED_WORD_LIST)
+            }
+            MnemonicLanguage::ChineseTraditional => {
+                ("chinese_traditional", CHINESE_TRADITIONAL_WORD_LIST)
+            }
+            MnemonicLanguage::Italian => ("italian", ITALIAN_WORD_LIST),
+            MnemonicLanguage::Czech => ("czech", CZECH_WORD_LIST),
+            MnemonicLanguage::Korean => ("korean", KOREAN_WORD_LIST),
+            MnemonicLanguage::Portuguese => ("portuguese", PORTUGUESE_WORD_LIST),
+            MnemonicLanguage::Spanish => ("spanish", SPANISH_WORD_LIST),
+        }
+    }
+}

crates/eigen-cli/src/bls.rs

@@ -0,0 +1,60 @@
+use crate::args::BlsKeystoreType;
+use crate::EigenBlsKeyStoreError;
+use rust_bls_bn254::keystores::{pbkdf2_keystore::Pbkdf2Keystore, scrypt_keystore::ScryptKeystore};
+
+/// BlsKeystore   
+pub enum BlsKeystore {
+    Pbkdf2,
+    Scrypt,
+}
+
+impl BlsKeystore {
+    /// Create a new [`BlsKeystore`] instance.
+    /// [`BlsKeystore::Pbkdft`] or [`BlsKeystore::Scrypt`]
+    pub fn new_keystore(
+        self,
+        secret_key: String,
+        output_path: String,
+        password: Option<&str>,
+    ) -> Result<(), EigenBlsKeyStoreError> {
+        match self {
+            BlsKeystore::Pbkdf2 => {
+                let key_hex = hex::decode(secret_key)?;
+                let bls_key = key_hex.as_slice();
+                let mut keystore = Pbkdf2Keystore::new();
+                keystore.encrypt(
+                    bls_key,
+                    password.unwrap_or_default(),
+                    &output_path.to_string(),
+                    None,
+                    None,
+                )?;
+                keystore.to_keystore().save(&output_path.to_string())?;
+                Ok(())
+            }
+            BlsKeystore::Scrypt => {
+                let key_hex = hex::decode(secret_key)?;
+                let bls_key = key_hex.as_slice();
+                let mut keystore = ScryptKeystore::new();
+                keystore.encrypt(
+                    bls_key,
+                    password.unwrap_or_default(),
+                    &output_path.to_string(),
+                    None,
+                    None,
+                )?;
+                keystore.to_keystore().save(&output_path.to_string())?;
+                Ok(())
+            }
+        }
+    }
+}
+
+impl From<BlsKeystoreType> for BlsKeystore {
+    fn from(value: BlsKeystoreType) -> Self {
+        match value {
+            BlsKeystoreType::Pbkdf2 => BlsKeystore::Pbkdf2,
+            BlsKeystoreType::Scrypt => BlsKeystore::Scrypt,
+        }
+    }
+}