feat: add agent and namespace commands

Author: devwckd

cli/src/cli/agent.rs

@@ -0,0 +1,152 @@
+use tabled::Table;
+use torus_client::client::TorusClient;
+
+use crate::{
+    cli::CliCtx,
+    store::{get_account, get_key},
+};
+
+#[derive(clap::Args)]
+#[command(arg_required_else_help = true)]
+pub struct AgentCliCommand {
+    pub account: Option<String>,
+
+    #[command(subcommand)]
+    pub sub_command: Option<AgentCliSubCommand>,
+}
+
+#[derive(clap::Subcommand, Clone)]
+pub enum AgentCliSubCommand {
+    Info {
+        account: String,
+    },
+    Register {
+        key: String,
+        name: String,
+        metadata: String,
+        url: String,
+    },
+}
+
+#[derive(tabled::Tabled)]
+struct AgentInfo {
+    name: String,
+    metadata: String,
+    url: String,
+    last_update_block: u64,
+    registration_block: u64,
+}
+
+impl AgentInfo {
+    fn new(
+        name: Vec<u8>,
+        metadata: Vec<u8>,
+        url: Vec<u8>,
+        last_update_block: u64,
+        registration_block: u64,
+    ) -> Self {
+        Self {
+            name: String::from_utf8_lossy(&name[..]).to_string(),
+            metadata: String::from_utf8_lossy(&metadata[..]).to_string(),
+            url: String::from_utf8_lossy(&url[..]).to_string(),
+            last_update_block,
+            registration_block,
+        }
+    }
+}
+
+pub async fn info(ctx: &CliCtx, account: String) -> anyhow::Result<()> {
+    let account = get_account(&account)?;
+
+    println!("Fetching agent data...");
+
+    let agent_info = if ctx.is_testnet() {
+        let client = TorusClient::for_testnet().await?;
+        client
+            .torus0()
+            .storage()
+            .agents_get(&account)
+            .await?
+            .map(|agent| {
+                AgentInfo::new(
+                    agent.name.0,
+                    agent.metadata.0,
+                    agent.url.0,
+                    agent.last_update_block,
+                    agent.registration_block,
+                )
+            })
+    } else {
+        let client = TorusClient::for_mainnet().await?;
+        client
+            .torus0()
+            .storage()
+            .agents_get(&account)
+            .await?
+            .map(|agent| {
+                AgentInfo::new(
+                    agent.name.0,
+                    agent.metadata.0,
+                    agent.url.0,
+                    agent.last_update_block,
+                    agent.registration_block,
+                )
+            })
+    };
+
+    if let Some(agent_info) = agent_info {
+        let table = Table::kv(std::iter::once(agent_info));
+        println!("{table}");
+    } else {
+        println!("{account} is not an agent.");
+    }
+
+    Ok(())
+}
+
+pub async fn register(
+    ctx: &CliCtx,
+    key: String,
+    name: String,
+    metadata: String,
+    url: String,
+) -> anyhow::Result<()> {
+    let key = get_key(&key)?;
+    let (_key, keypair) = ctx.decrypt(&key)?;
+
+    ctx.confirm(&format!(
+        "register an agent with the IMMUTABLE name of {name}"
+    ))?;
+
+    println!("Registering agent...");
+
+    if ctx.is_testnet() {
+        let client = TorusClient::for_testnet().await?;
+        client
+            .torus0()
+            .calls()
+            .register_agent_wait(
+                name.as_bytes().to_vec(),
+                url.as_bytes().to_vec(),
+                metadata.as_bytes().to_vec(),
+                keypair,
+            )
+            .await?;
+    } else {
+        let client = TorusClient::for_mainnet().await?;
+        client
+            .torus0()
+            .calls()
+            .register_agent_wait(
+                name.as_bytes().to_vec(),
+                url.as_bytes().to_vec(),
+                metadata.as_bytes().to_vec(),
+                keypair,
+            )
+            .await?;
+    };
+
+    println!("Agent registered successfully!");
+
+    Ok(())
+}

cli/src/cli/balance.rs

@@ -82,6 +82,8 @@ pub async fn transfer(
 
     let target = AccountId32::from_str(&target)?;
 
+    ctx.confirm(&format!("transfer {amount} to {target}"))?;
+
     println!("Transfering...");
 
     if ctx.is_testnet() {

cli/src/cli/key.rs

@@ -24,6 +24,9 @@ pub enum KeyCliSubCommand {
 
         #[arg(long)]
         password: bool,
+
+        #[arg(long)]
+        mnemonic: Option<String>,
     },
     Delete {
         name: String,
@@ -65,7 +68,12 @@ pub(super) fn list(_ctx: &CliCtx) -> anyhow::Result<()> {
     Ok(())
 }
 
-pub(super) fn create(_ctx: &CliCtx, name: String, password: bool) -> anyhow::Result<()> {
+pub(super) fn create(
+    _ctx: &CliCtx,
+    name: String,
+    password: bool,
+    mnemonic: Option<String>,
+) -> anyhow::Result<()> {
     if key_exists(&name) {
         println!("A key with this name already exists.");
         return Ok(());
@@ -81,12 +89,17 @@ pub(super) fn create(_ctx: &CliCtx, name: String, password: bool) -> anyhow::Res
         None
     };
 
-    let mnemonic = Mnemonic::generate(12)?;
+    let mnemonic = if let Some(mnemonic) = mnemonic {
+        Mnemonic::parse(mnemonic)?
+    } else {
+        Mnemonic::generate(12)?
+    };
+
     let (keypair, seed) = generate_sr25519_keypair(&mnemonic, password.as_deref())?;
 
     store_new_key(&name, &mnemonic, &seed, &keypair, password.as_deref())?;
 
-    print!(
+    println!(
         "Created key `{}` with public key `{}`.",
         keypair.ss58_address(),
         keypair.hex_public_key()

cli/src/cli/mod.rs

@@ -1,27 +1,44 @@
 use clap::Parser;
 
 use balance::BalanceCliCommand;
-use inquire::Password;
+use inquire::{Password, PasswordDisplayMode};
 use key::KeyCliCommand;
 
 use crate::{
     cli::{
+        agent::{AgentCliCommand, AgentCliSubCommand},
         key::KeyCliSubCommand,
+        namespace::{NamespaceCliCommand, NamespaceCliSubCommand},
         stake::{StakeCliCommand, StakeCliSubCommand},
     },
     keypair::Keypair,
     store::{decrypt_key, Key},
 };
 
+mod agent;
 mod balance;
 mod key;
+mod namespace;
 mod stake;
 
 pub(super) async fn execute() -> anyhow::Result<()> {
     let cli = Cli::parse();
     let (ctx, command) = cli.extract_context();
 
     match command {
+        CliSubCommand::Agent(command) => match command.sub_command {
+            Some(AgentCliSubCommand::Info { account }) => agent::info(&ctx, account).await?,
+            Some(AgentCliSubCommand::Register {
+                key,
+                name,
+                metadata,
+                url,
+            }) => agent::register(&ctx, key, name, metadata, url).await?,
+            None if command.account.is_some() => {
+                agent::info(&ctx, command.account.unwrap()).await?
+            }
+            _ => {}
+        },
         CliSubCommand::Balance(command) => match command.sub_command {
             Some(balance::BalanceCliSubCommand::Check { key }) => balance::check(&ctx, key).await?,
             Some(balance::BalanceCliSubCommand::Transfer {
@@ -34,7 +51,11 @@ pub(super) async fn execute() -> anyhow::Result<()> {
         },
         CliSubCommand::Key(command) => match command.sub_command {
             KeyCliSubCommand::List => key::list(&ctx)?,
-            KeyCliSubCommand::Create { name, password } => key::create(&ctx, name, password)?,
+            KeyCliSubCommand::Create {
+                name,
+                password,
+                mnemonic,
+            } => key::create(&ctx, name, password, mnemonic)?,
             KeyCliSubCommand::Delete { name } => key::delete(&ctx, name)?,
             KeyCliSubCommand::Info { name } => key::info(&ctx, name)?,
         },
@@ -60,6 +81,18 @@ pub(super) async fn execute() -> anyhow::Result<()> {
             None if command.key.is_some() => stake::given(&ctx, command.key.unwrap()).await?,
             _ => {}
         },
+        CliSubCommand::Namespace(command) => match command.sub_command {
+            Some(NamespaceCliSubCommand::Info { account }) => {
+                namespace::info(&ctx, account).await?
+            }
+            Some(NamespaceCliSubCommand::Register { key, path }) => {
+                namespace::register(&ctx, key, path).await?
+            }
+            None if command.account.is_some() => {
+                namespace::info(&ctx, command.account.unwrap()).await?
+            }
+            _ => {}
+        },
     }
 
     Ok(())
@@ -81,26 +114,31 @@ pub struct Cli {
 impl Cli {
     pub fn extract_context(self) -> (CliCtx, CliSubCommand) {
         let is_testnet = self.testnet;
+        let yes = self.yes;
 
-        (CliCtx::new(is_testnet), self.command)
+        (CliCtx::new(is_testnet, yes), self.command)
     }
 }
 
 #[derive(clap::Subcommand)]
 pub enum CliSubCommand {
+    Agent(AgentCliCommand),
     Balance(BalanceCliCommand),
     Key(KeyCliCommand),
+    Namespace(NamespaceCliCommand),
     Stake(StakeCliCommand),
 }
 
 pub struct CliCtx {
     testnet: bool,
+    skip_confirmation: bool,
 }
 
 impl CliCtx {
-    pub fn new(is_testnet: bool) -> Self {
+    pub fn new(is_testnet: bool, skip_confirmation: bool) -> Self {
         Self {
             testnet: is_testnet,
+            skip_confirmation,
         }
     }
 
@@ -123,4 +161,21 @@ impl CliCtx {
 
         Ok((key.clone(), Keypair::from_key(key, Some(&password))?))
     }
+
+    pub fn confirm(&self, action: &str) -> anyhow::Result<()> {
+        if self.skip_confirmation {
+            return Ok(());
+        }
+
+        let res = Password::new(&format!("Are you sure you want to \"{action}\"? [y/N] "))
+            .without_confirmation()
+            .with_display_mode(PasswordDisplayMode::Full)
+            .prompt()?;
+
+        if !res.to_lowercase().starts_with("y") {
+            return Err(anyhow::anyhow!("not confirmed"));
+        }
+
+        Ok(())
+    }
 }