feat: test all available curves

Cargo.toml

@@ -108,6 +108,7 @@ jmt = { git = "https://github.com/deltadevsde/jmt", branch = "rehashing-circuit"
 sha2 = "0.10.8"
 tempfile = "3.14.0"
 auto_impl = "1.2.0"
+paste = "1.0.15"
 
 # prism
 prism-common = { path = "crates/common" }

ci/run-validator.sh

@@ -99,7 +99,8 @@ provision_light_nodes() {
         "$NODE_NAME" \
         "$light_address" \
         "$BRIDGE_COINS" \
-        --fees 21000utia
+        --fees 21000utia \
+        --broadcast-mode block
     done
 
     echo "Provisioning finished."
@@ -160,12 +161,18 @@ provision_bridge_nodes() {
       "$NODE_NAME" \
       "$bridge_address" \
       "$BRIDGE_COINS" \
-      --fees 21000utia
+      --fees 21000utia \
+      --broadcast-mode block
   done
 
   echo "Provisioning finished."
 }
 
+provision() {
+  provision_bridge_nodes
+  provision_light_nodes
+}
+
 # Set up the validator for a private alone network.
 # Based on
 # https://github.com/celestiaorg/celestia-app/blob/main/scripts/single-node.sh
@@ -202,8 +209,7 @@ setup_private_validator() {
 main() {
   # Configure stuff
   setup_private_validator
-  provision_bridge_nodes &
-  provision_light_nodes &
+  provision &
   # Start the celestia-app
   echo "Configuration finished. Running a validator node..."
   celestia-appd start --api.enable --grpc.enable --force-no-bbr

crates/cli/src/cfg.rs

@@ -36,6 +36,12 @@ pub struct CommandArgs {
     #[arg(long)]
     verifying_key: Option<String>,
 
+    /// The algorithm used for the verifying key.
+    ///
+    /// Can be one of: `ed25519`, `secp256k1`, `secp256r1`.
+    #[arg(long, default_value = "ed25519")]
+    verifying_key_algorithm: Option<String>,
+
     #[arg(long)]
     config_path: Option<String>,
 
@@ -97,6 +103,7 @@ pub struct Config {
     pub da_layer: DALayerOption,
     pub redis_config: Option<RedisConfig>,
     pub verifying_key: Option<String>,
+    pub verifying_key_algorithm: String,
 }
 
 impl Default for Config {
@@ -107,6 +114,7 @@ impl Default for Config {
             da_layer: DALayerOption::default(),
             redis_config: Some(RedisConfig::default()),
             verifying_key: None,
+            verifying_key_algorithm: "ed25519".to_string(),
         }
     }
 }
@@ -201,6 +209,9 @@ fn apply_command_line_args(config: Config, args: CommandArgs) -> Config {
         }),
         da_layer: config.da_layer,
         verifying_key: args.verifying_key.or(config.verifying_key),
+        verifying_key_algorithm: args
+            .verifying_key_algorithm
+            .unwrap_or(config.verifying_key_algorithm),
     }
 }
 

crates/cli/src/main.rs

@@ -4,14 +4,14 @@ mod node_types;
 use cfg::{initialize_da_layer, load_config, Cli, Commands};
 use clap::Parser;
 use keystore_rs::{KeyChain, KeyStore, KeyStoreType};
-use prism_keys::VerifyingKey;
+use prism_keys::{CryptoAlgorithm, SigningKey, VerifyingKey};
+use std::io::{Error, ErrorKind};
 
 use node_types::NodeType;
 use prism_lightclient::LightClient;
 use prism_prover::Prover;
 use prism_storage::RedisConnection;
-use std::sync::Arc;
-
+use std::{str::FromStr, sync::Arc};
 #[macro_use]
 extern crate log;
 
@@ -24,105 +24,120 @@ async fn main() -> std::io::Result<()> {
     let node: Arc<dyn NodeType> = match cli.command {
         Commands::LightClient(args) => {
             let config = load_config(args.clone())
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
             let da = initialize_da_layer(&config)
                 .await
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
             let celestia_config = config.celestia_config.ok_or_else(|| {
-                std::io::Error::new(
-                    std::io::ErrorKind::NotFound,
-                    "celestia configuration not found",
-                )
+                Error::new(ErrorKind::NotFound, "celestia configuration not found")
             })?;
 
-            let prover_vk = config.verifying_key.and_then(|s| s.try_into().ok()).and_then(
-                |vk: VerifyingKey| match vk {
-                    VerifyingKey::Ed25519(key) => Some(key),
-                    _ => None,
-                },
-            );
+            let verifying_key_algorithm =
+                CryptoAlgorithm::from_str(&config.verifying_key_algorithm).map_err(|_| {
+                    Error::new(
+                        ErrorKind::InvalidInput,
+                        "invalid verifying key algorithm format",
+                    )
+                })?;
+            let prover_vk = VerifyingKey::from_algorithm_and_bytes(
+                verifying_key_algorithm,
+                config.verifying_key.unwrap().as_bytes(),
+            )
+            .map_err(|e| Error::new(ErrorKind::InvalidInput, e.to_string()))?;
 
-            Arc::new(LightClient::new(da, celestia_config, prover_vk))
+            Arc::new(LightClient::new(da, celestia_config, Some(prover_vk)))
         }
         Commands::Prover(args) => {
             let config = load_config(args.clone())
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
             let da = initialize_da_layer(&config)
                 .await
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
-            let redis_config = config.clone().redis_config.ok_or_else(|| {
-                std::io::Error::new(
-                    std::io::ErrorKind::NotFound,
-                    "redis configuration not found",
-                )
-            })?;
+            let redis_config = config
+                .clone()
+                .redis_config
+                .ok_or_else(|| Error::new(ErrorKind::NotFound, "redis configuration not found"))?;
             let redis_connections = RedisConnection::new(&redis_config)
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
-            let signing_key = KeyStoreType::KeyChain(KeyChain)
+            let signing_key_chain = KeyStoreType::KeyChain(KeyChain)
                 .get_signing_key()
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
+
+            let verifying_key_algorithm =
+                CryptoAlgorithm::from_str(&config.verifying_key_algorithm).map_err(|_| {
+                    Error::new(
+                        ErrorKind::InvalidInput,
+                        "invalid verifying key algorithm format",
+                    )
+                })?;
+            let signing_key = SigningKey::from_algorithm_and_bytes(
+                verifying_key_algorithm,
+                signing_key_chain.as_bytes(),
+            )
+            .map_err(|e| Error::new(ErrorKind::InvalidInput, format!("Invalid signing key: {}", e)))?;
+            let verifying_key = signing_key.verifying_key();
 
             let prover_cfg = prism_prover::Config {
                 prover: true,
                 batcher: true,
                 webserver: config.webserver.unwrap_or_default(),
                 signing_key: signing_key.clone(),
-                verifying_key: signing_key.verification_key(),
+                verifying_key: verifying_key.clone(),
                 start_height: config.celestia_config.unwrap_or_default().start_height,
             };
 
-            info!(
-                "prover verifying key: {}",
-                VerifyingKey::from(prover_cfg.verifying_key)
-            );
-
             Arc::new(
                 Prover::new(Arc::new(Box::new(redis_connections)), da, &prover_cfg).map_err(
                     |e| {
                         error!("error initializing prover: {}", e);
-                        std::io::Error::new(std::io::ErrorKind::Other, e.to_string())
+                        Error::new(ErrorKind::Other, e.to_string())
                     },
                 )?,
             )
         }
         Commands::FullNode(args) => {
             let config = load_config(args.clone())
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
             let da = initialize_da_layer(&config)
                 .await
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
-            let redis_config = config.clone().redis_config.ok_or_else(|| {
-                std::io::Error::new(
-                    std::io::ErrorKind::NotFound,
-                    "redis configuration not found",
-                )
-            })?;
+            let redis_config = config
+                .clone()
+                .redis_config
+                .ok_or_else(|| Error::new(ErrorKind::NotFound, "redis configuration not found"))?;
             let redis_connections = RedisConnection::new(&redis_config)
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
 
-            let signing_key = KeyStoreType::KeyChain(KeyChain)
+            let signing_key_chain = KeyStoreType::KeyChain(KeyChain)
                 .get_signing_key()
-                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+                .map_err(|e| Error::new(ErrorKind::Other, e.to_string()))?;
+
+            let verifying_key_algorithm =
+                CryptoAlgorithm::from_str(&config.verifying_key_algorithm).map_err(|_| {
+                    Error::new(
+                        ErrorKind::InvalidInput,
+                        "invalid verifying key algorithm format",
+                    )
+                })?;
+            let signing_key = SigningKey::from_algorithm_and_bytes(
+                verifying_key_algorithm,
+                signing_key_chain.as_bytes(),
+            )
+            .map_err(|e| Error::new(ErrorKind::InvalidInput, format!("Invalid signing key: {}", e)))?;
 
             let prover_vk = config
                 .verifying_key
-                .and_then(|s| s.try_into().ok())
-                .and_then(|vk: VerifyingKey| match vk {
-                    VerifyingKey::Ed25519(key) => Some(key),
-                    _ => None,
-                })
-                .ok_or_else(|| {
-                    std::io::Error::new(
-                        std::io::ErrorKind::NotFound,
-                        "prover verifying key not found",
-                    )
+                .ok_or_else(|| Error::new(ErrorKind::NotFound, "prover verifying key not found"))
+                .and_then(|vk| {
+                    VerifyingKey::from_algorithm_and_bytes(verifying_key_algorithm, vk.as_bytes())
+                        .map_err(|e| Error::new(ErrorKind::InvalidInput, e.to_string()))
                 })?;
 
             let prover_cfg = prism_prover::Config {
@@ -138,12 +153,12 @@ async fn main() -> std::io::Result<()> {
                 Prover::new(Arc::new(Box::new(redis_connections)), da, &prover_cfg).map_err(
                     |e| {
                         error!("error initializing prover: {}", e);
-                        std::io::Error::new(std::io::ErrorKind::Other, e.to_string())
+                        Error::new(ErrorKind::Other, e.to_string())
                     },
                 )?,
             )
         }
     };
 
-    node.start().await.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))
+    node.start().await.map_err(|e| Error::new(ErrorKind::Other, e.to_string()))
 }