Merge #119

119: feat: scope nilauth requests by blind module in `nillion` cli r=mfontanini a=mfontanini

This changes the `nillion` cli to use the new blind module parameter when talking to nilauth.

Co-authored-by: Matias Fontanini <[email protected]>

Author: nilogy-bors[bot]

Cargo.lock

@@ -13,7 +13,7 @@ hex = { version = "0.4", features = ["serde"] }
 humantime = "2.2"
 futures = "0.3.30"
 log = "0.4"
-nilauth-client = { git = "https://github.com/NillionNetwork/nilauth-client-rs", rev = "7c5105d250e46d87dd4e3cdbdd0519a949f5186c" }
+nilauth-client = { git = "https://github.com/NillionNetwork/nilauth-client-rs", rev = "03e2b38609f6c48332fbfc38960ce57d27121f44" }
 nillion-nucs = { git = "https://github.com/NillionNetwork/nuc-rs", rev = "687657acd08f2543e5c0d75e910eb9f1b1152d00" }
 serde = "1.0.214"
 serde_yaml = "0.9"

tools/nillion/Cargo.toml

@@ -3,6 +3,7 @@ use clap::{error::ErrorKind, Args, CommandFactory, Parser, Subcommand, ValueEnum
 use clap_utils::shell_completions::ShellCompletionsArgs;
 use hex::FromHexError;
 use nada_values_args::NadaValueArgs;
+use nilauth_client::client::BlindModule;
 use nillion_client::{grpc::membership::NodeId, Clear, NadaValue, UserId, Uuid};
 use nillion_nucs::token::Did;
 use serde::Deserialize;
@@ -651,7 +652,7 @@ pub enum NilauthCommand {
     Subscription(NilauthSubscriptionCommand),
 
     /// Request a token.
-    Token,
+    Token { module: BlindModuleArg },
 
     /// Revoke a token.
     Revoke(RevokeTokenArgs),
@@ -667,10 +668,32 @@ pub enum NilauthCommand {
 #[derive(Subcommand)]
 pub enum NilauthSubscriptionCommand {
     /// Pay for a subscription.
-    Pay,
+    Pay { module: BlindModuleArg },
 
     /// Get the subscription status.
-    Status,
+    Status { module: BlindModuleArg },
+
+    /// Get the cost of a subscription.
+    Cost { module: BlindModuleArg },
+}
+
+/// A nilauth blind module.
+#[derive(Clone, ValueEnum)]
+pub enum BlindModuleArg {
+    /// nildb
+    Nildb,
+
+    /// nilai
+    Nilai,
+}
+
+impl From<BlindModuleArg> for BlindModule {
+    fn from(arg: BlindModuleArg) -> Self {
+        match arg {
+            BlindModuleArg::Nildb => BlindModule::NilDb,
+            BlindModuleArg::Nilai => BlindModule::NilAi,
+        }
+    }
 }
 
 /// The arguments to a revoke token command.

tools/nillion/src/args.rs

@@ -45,7 +45,7 @@ impl NetworksHandler {
         });
         let nilauth = nilauth_endpoint.map(|endpoint| NilauthConfig { endpoint });
         NetworkConfig { bootnode, payments, nilauth }.write_to_file(&name)?;
-        Ok(Box::new(format!("Network {} added", name)))
+        Ok(Box::new(format!("Network {name} added")))
     }
 
     fn edit(args: EditNetworkArgs) -> HandlerResult {

tools/nillion/src/handlers/networks.rs

@@ -2,7 +2,7 @@ use super::HandlerResult;
 use crate::args::{CheckRevokedArgs, NilauthCommand, NilauthSubscriptionCommand, RevokeTokenArgs};
 use anyhow::{anyhow, bail, Context, Result};
 use chrono::{DateTime, Utc};
-use nilauth_client::client::{About, DefaultNilauthClient, NilauthClient};
+use nilauth_client::client::{About, BlindModule, DefaultNilauthClient, NilauthClient};
 use nillion_client::payments::{NillionChainClient, NillionChainPrivateKey};
 use nillion_nucs::{
     envelope::NucTokenEnvelope,
@@ -40,16 +40,19 @@ impl NilauthHandler {
     pub async fn handle(self, command: NilauthCommand) -> HandlerResult {
         use NilauthCommand::*;
         match command {
-            Subscription(NilauthSubscriptionCommand::Pay) => self.pay_subscription().await,
-            Subscription(NilauthSubscriptionCommand::Status) => self.subscription_status().await,
-            Token => self.request_token().await,
+            Subscription(NilauthSubscriptionCommand::Pay { module }) => self.pay_subscription(module.into()).await,
+            Subscription(NilauthSubscriptionCommand::Status { module }) => {
+                self.subscription_status(module.into()).await
+            }
+            Subscription(NilauthSubscriptionCommand::Cost { module }) => self.subscription_cost(module.into()).await,
+            Token { module } => self.request_token(module.into()).await,
             Revoke(args) => self.revoke_token(args).await,
             CheckRevoked(args) => self.check_revoked(args).await,
             About => self.about().await,
         }
     }
 
-    async fn pay_subscription(self) -> HandlerResult {
+    async fn pay_subscription(self, module: BlindModule) -> HandlerResult {
         #[derive(Serialize)]
         struct Output {
             tx_hash: String,
@@ -65,11 +68,11 @@ impl NilauthHandler {
             nilchain_client.set_gas_price(gas_price);
         }
 
-        let tx_hash = self.client.pay_subscription(&mut nilchain_client, &self.key).await?;
+        let tx_hash = self.client.pay_subscription(&mut nilchain_client, &self.key, module).await?;
         Ok(Box::new(Output { tx_hash: tx_hash.to_string() }))
     }
 
-    async fn subscription_status(self) -> HandlerResult {
+    async fn subscription_status(self, module: BlindModule) -> HandlerResult {
         #[derive(Serialize)]
         struct Output {
             subscribed: bool,
@@ -78,25 +81,37 @@ impl NilauthHandler {
             expires_at: Option<DateTime<Utc>>,
         }
 
-        let subscription = self.client.subscription_status(&self.key).await?;
+        let subscription = self.client.subscription_status(&self.key.public_key(), module).await?;
         let output =
             Output { subscribed: subscription.subscribed, expires_at: subscription.details.map(|s| s.expires_at) };
         Ok(Box::new(output))
     }
 
-    async fn request_token(self) -> HandlerResult {
+    async fn subscription_cost(self, module: BlindModule) -> HandlerResult {
+        #[derive(Serialize)]
+        struct Output {
+            cost_unils: u64,
+        }
+
+        let cost = self.client.subscription_cost(module).await?;
+        let output = Output { cost_unils: cost.to_unil() };
+        Ok(Box::new(output))
+    }
+
+    async fn request_token(self, module: BlindModule) -> HandlerResult {
         #[derive(Serialize)]
         struct Output {
             token: String,
         }
 
-        let token = self.client.request_token(&self.key).await?;
+        let token = self.client.request_token(&self.key, module).await?;
         Ok(Box::new(Output { token }))
     }
 
     async fn revoke_token(self, args: RevokeTokenArgs) -> HandlerResult {
         let token = NucTokenEnvelope::decode(&args.token)?;
-        self.client.revoke_token(&token, &self.key).await?;
+        let args = nilauth_client::client::RevokeTokenArgs { auth_token: token.clone(), revocable_token: token };
+        self.client.revoke_token(args, &self.key).await?;
         Ok(Box::new("Token revoked".to_string()))
     }
 

tools/nillion/src/handlers/nilauth.rs

@@ -98,7 +98,7 @@ async fn main() {
     };
 
     match serialized_result {
-        Ok(Some(serialized)) => println!("{}", serialized),
+        Ok(Some(serialized)) => println!("{serialized}"),
         Ok(None) => {}
         Err(e) => {
             println!("{}", serialize_error(&output_format, &e));