feat(meroctl): support alias listing

crates/meroctl/src/cli/context/identity/alias.rs

@@ -1,7 +1,7 @@
 use calimero_primitives::alias::Alias;
 use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
-use calimero_server_primitives::admin::GetContextIdentitiesResponse;
+use calimero_server_primitives::admin::{GetContextIdentitiesResponse, ListAliasesResponse};
 use clap::Parser;
 use eyre::{OptionExt, Result as EyreResult, WrapErr};
 use libp2p::identity::Keypair;
@@ -10,8 +10,8 @@ use reqwest::Client;
 
 use crate::cli::Environment;
 use crate::common::{
-    create_alias, delete_alias, fetch_multiaddr, load_config, lookup_alias, multiaddr_to_url,
-    resolve_alias,
+    create_alias, delete_alias, do_request, fetch_multiaddr, load_config, lookup_alias,
+    make_request, multiaddr_to_url, resolve_alias, RequestType,
 };
 use crate::output::ErrorLine;
 
@@ -87,6 +87,13 @@ pub enum ContextIdentityAliasSubcommand {
         #[arg(long, short, default_value = "default")]
         context: Alias<ContextId>,
     },
+
+    #[command(about = "List all the aliases under the context", alias = "ls")]
+    List {
+        #[arg(help = "The context whose aliases need to be listed")]
+        #[arg(long, short, default_value = "default")]
+        context: Alias<ContextId>,
+    },
 }
 
 impl ContextIdentityAliasCommand {
@@ -185,6 +192,30 @@ impl ContextIdentityAliasCommand {
 
                 environment.output.write(&res);
             }
+
+            ContextIdentityAliasSubcommand::List { context } => {
+                let client = Client::new();
+
+                let resolve_response =
+                    resolve_alias(multiaddr, &config.identity, context, None).await?;
+                let context_id = resolve_response
+                    .value()
+                    .cloned()
+                    .ok_or_eyre("Failed to resolve context: no value found")?;
+
+                make_request::<(), ListAliasesResponse<PublicKey>>(
+                    &environment,
+                    &client,
+                    multiaddr_to_url(
+                        multiaddr,
+                        &format!("/admin-api/dev/aliases/identity/{context_id}"),
+                    )?,
+                    None::<()>,
+                    &config.identity,
+                    RequestType::Get,
+                )
+                .await?;
+            }
         }
 
         Ok(())

crates/meroctl/src/common.rs

@@ -8,7 +8,8 @@ use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
 use calimero_server_primitives::admin::{
     AliasKind, CreateAliasRequest, CreateAliasResponse, CreateApplicationIdAlias,
-    CreateContextIdAlias, CreateContextIdentityAlias, DeleteAliasResponse, LookupAliasResponse,
+    CreateContextIdAlias, CreateContextIdentityAlias, DeleteAliasResponse, ListAliasesResponse,
+    LookupAliasResponse,
 };
 use camino::Utf8Path;
 use chrono::Utc;
@@ -429,3 +430,22 @@ where
 
     Ok(ResolveResponse { alias, value })
 }
+
+impl<T: fmt::Display + ScopedAlias + Eq> Report for ListAliasesResponse<T> {
+    fn report(&self) -> () {
+        let mut table = Table::new();
+        let _ = table.set_header(vec![
+            Cell::new("Value").fg(Color::Blue),
+            Cell::new("Alias").fg(Color::Blue),
+        ]);
+
+        for (alias, value) in &self.data {
+            let _ = table.add_row(vec![
+                Cell::new(&value.to_string()),
+                Cell::new(alias.as_str()),
+            ]);
+        }
+
+        table.to_string();
+    }
+}

crates/node/src/interactive_cli/context/identity.rs

@@ -131,7 +131,8 @@ enum ContextIdentityAliasSubcommands {
     #[command(about = "List context identity aliases", alias = "ls")]
     List {
         /// The context whose aliases we're listing
-        context: Option<Alias<ContextId>>,
+        #[arg(long, short, default_value = "default")]
+        context: Alias<ContextId>,
     },
 }
 
@@ -415,17 +416,10 @@ fn handle_alias_command(
                 c2 = "Identity",
                 c3 = "Alias",
             );
-            let context_id = if let Some(ctx) = context {
-                node_client
-                    .resolve_alias(ctx, None)?
-                    .ok_or_eyre("unable to resolve context alias")?
-            } else {
-                let default_alias: Alias<ContextId> =
-                    "default".parse().expect("'default' is a valid alias name");
-                node_client
-                    .lookup_alias(default_alias, None)?
-                    .ok_or_eyre("unable to resolve default context")?
-            };
+            let context_id = node_client
+                .resolve_alias(context, None)?
+                .ok_or_eyre("unable to resolve context alias")?;
+
             for (alias, identity, scope) in
                 node_client.list_aliases::<PublicKey>(Some(context_id))?
             {

crates/primitives/src/alias.rs

@@ -3,6 +3,7 @@
 mod tests;
 
 use std::fmt;
+use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::str::FromStr;
 
@@ -146,3 +147,9 @@ impl<'de, T> Deserialize<'de> for Alias<T> {
         deserializer.deserialize_str(AliasVisitor(PhantomData))
     }
 }
+
+impl<T> Hash for Alias<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state);
+    }
+}

crates/server/primitives/src/admin.rs

@@ -1,7 +1,9 @@
+use std::collections::HashMap;
+
 use calimero_context_config::repr::Repr;
 use calimero_context_config::types::{Capability, ContextIdentity, ContextStorageEntry};
 use calimero_context_config::{Proposal, ProposalWithApprovals};
-use calimero_primitives::alias::Alias;
+use calimero_primitives::alias::{Alias, ScopedAlias};
 use calimero_primitives::application::{Application, ApplicationId};
 use calimero_primitives::context::{Context, ContextId, ContextInvitationPayload};
 use calimero_primitives::hash::Hash;
@@ -253,6 +255,24 @@ impl GetContextIdentitiesResponse {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListAliasesResponse<T>
+where
+    T: ScopedAlias + Eq,
+{
+    pub data: HashMap<Alias<T>, T>,
+}
+
+impl<T> ListAliasesResponse<T>
+where
+    T: ScopedAlias + Eq,
+{
+    pub fn new(data: HashMap<Alias<T>, T>) -> Self {
+        Self { data }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetContextClientKeysResponseData {

crates/server/src/admin/handlers/alias.rs

@@ -1,10 +1,11 @@
-use axum::routing::{post, Router};
+use axum::routing::{get, post, Router};
 use calimero_primitives::application::ApplicationId;
 use calimero_primitives::context::ContextId;
 use calimero_primitives::identity::PublicKey;
 
 mod create_alias;
 mod delete_alias;
+mod list_aliases;
 mod lookup_alias;
 
 pub fn service() -> Router {
@@ -38,8 +39,17 @@ pub fn service() -> Router {
             post(delete_alias::handler::<PublicKey>),
         );
 
+    let list_routes = Router::new()
+        .route("/context", get(list_aliases::handler::<ContextId>))
+        .route("/application", get(list_aliases::handler::<ApplicationId>))
+        .route(
+            "/identity/:context",
+            get(list_aliases::handler::<PublicKey>),
+        );
+
     Router::new()
         .nest("/create", create_routes)
         .nest("/lookup", lookup_routes)
         .nest("/delete", delete_routes)
+        .nest("/list", list_routes)
 }

crates/server/src/admin/handlers/alias/list_aliases.rs

@@ -0,0 +1,39 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use axum::extract::Path;
+use axum::response::IntoResponse;
+use axum::Extension;
+use calimero_primitives::alias::Alias;
+use calimero_server_primitives::admin::ListAliasesResponse;
+use calimero_store::key::{Aliasable, StoreScopeCompat};
+use reqwest::StatusCode;
+use serde::Serialize;
+
+use crate::admin::service::ApiResponse;
+use crate::AdminState;
+
+pub async fn handler<T>(
+    Extension(state): Extension<Arc<AdminState>>,
+    maybe_scope: Option<Path<T::Scope>>,
+) -> impl IntoResponse
+where
+    T: Aliasable<Scope: StoreScopeCompat + Copy + PartialEq> + Serialize + From<[u8; 32]> + Eq,
+{
+    let scope = maybe_scope.map(|Path(s)| s);
+
+    let aliases_raw = match state.node_client.list_aliases::<T>(scope) {
+        Ok(a) => a,
+        Err(err) => return (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()).into_response(),
+    };
+
+    let data: HashMap<Alias<T>, T> = aliases_raw
+        .into_iter()
+        .map(|(alias, value, _scope)| (alias, value))
+        .collect();
+
+    ApiResponse {
+        payload: ListAliasesResponse::new(data),
+    }
+    .into_response()
+}