feat: only renew if we hit the renewal date

Author: mfontanini

libs/nilauth-client/examples/mint.rs

@@ -10,7 +10,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut payer = NillionChainClient::new("http://localhost:26648".to_string(), payment_key).await?;
     let client = DefaultNilauthClient::new("http://127.0.0.1:30921")?;
     let key = SecretKey::random(&mut rand::thread_rng());
-    client.pay_subscription(&mut payer, &key.public_key()).await?;
+    client.pay_subscription(&mut payer, &key).await?;
     let token = client.request_token(&key).await?;
     println!("{token}");
     Ok(())

libs/nilauth-client/src/client.rs

@@ -7,7 +7,7 @@ use nillion_nucs::{
     k256::{
         ecdsa::{signature::Signer, Signature, SigningKey},
         sha2::{Digest, Sha256},
-        PublicKey, SecretKey,
+        SecretKey,
     },
     token::{Did, ProofHash, TokenBody},
 };
@@ -44,7 +44,7 @@ pub trait NilauthClient {
     async fn pay_subscription(
         &self,
         payments_client: &mut NillionChainClient,
-        key: &PublicKey,
+        key: &SecretKey,
     ) -> Result<TxHash, PaySubscriptionError>;
 
     /// Get our subscription status.
@@ -88,6 +88,9 @@ pub enum PaySubscriptionError {
     #[error("fetching subscription cost: {0}")]
     Cost(#[from] SubscriptionCostError),
 
+    #[error("fetching subscription status: {0}")]
+    Status(#[from] SubscriptionStatusError),
+
     #[error("serde: {0}")]
     Serde(#[from] serde_json::Error),
 
@@ -103,6 +106,9 @@ pub enum PaySubscriptionError {
     #[error("server could not validate payment: {tx_hash}")]
     PaymentValidation { tx_hash: TxHash, payload: String },
 
+    #[error("cannot renew subscription before {0}")]
+    CannotRenewYet(DateTime<Utc>),
+
     #[error("request: {0:?}")]
     Request(RequestError),
 }
@@ -279,8 +285,15 @@ impl NilauthClient for DefaultNilauthClient {
     async fn pay_subscription(
         &self,
         payments_client: &mut NillionChainClient,
-        key: &PublicKey,
+        key: &SecretKey,
     ) -> Result<TxHash, PaySubscriptionError> {
+        let subscription = self.subscription_status(key).await?;
+        match subscription.details {
+            Some(details) if details.renewable_at > Utc::now() => {
+                return Err(PaySubscriptionError::CannotRenewYet(details.renewable_at));
+            }
+            _ => (),
+        };
         let about = self.about().await?;
         let cost = self.subscription_cost().await?;
         let payload = ValidatePaymentRequestPayload { nonce: rand::random(), service_public_key: about.public_key };
@@ -291,7 +304,8 @@ impl NilauthClient for DefaultNilauthClient {
             .await
             .map_err(|e| PaySubscriptionError::Payment(e.to_string()))?;
 
-        let public_key = key.to_sec1_bytes().as_ref().try_into().map_err(|_| PaySubscriptionError::InvalidPublicKey)?;
+        let public_key =
+            key.public_key().to_sec1_bytes().as_ref().try_into().map_err(|_| PaySubscriptionError::InvalidPublicKey)?;
         let url = self.make_url("/api/v1/payments/validate");
         let request =
             ValidatePaymentRequest { tx_hash: tx_hash.clone(), payload: payload.as_bytes().to_vec(), public_key };
@@ -511,4 +525,8 @@ pub struct SubscriptionDetails {
     /// The timestamp at which the subscription expires.
     #[serde(with = "chrono::serde::ts_seconds")]
     pub expires_at: DateTime<Utc>,
+
+    /// The timestamp at which the subscription can be renewed.
+    #[serde(with = "chrono::serde::ts_seconds")]
+    pub renewable_at: DateTime<Utc>,
 }

tools/nillion/src/runner.rs

@@ -755,7 +755,7 @@ impl Runner {
             nilchain_client.set_gas_price(gas_price);
         }
 
-        let tx_hash = nilauth_client.pay_subscription(&mut nilchain_client, &key.public_key()).await?;
+        let tx_hash = nilauth_client.pay_subscription(&mut nilchain_client, &key).await?;
         Ok(Box::new(Output { tx_hash: tx_hash.to_string() }))
     }
 

tools/nillion/src/serialize.rs

@@ -15,8 +15,8 @@ pub struct NoOutput;
 #[derive(Serialize)]
 pub struct ErrorOutput {
     error: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    cause: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    causes: Vec<String>,
 }
 
 pub fn serialize_output(format: &CommandOutputFormat, data: &dyn SerializeAsAny) -> Result<String> {
@@ -37,22 +37,8 @@ pub fn serialize_output(format: &CommandOutputFormat, data: &dyn SerializeAsAny)
 }
 
 pub fn serialize_error(format: &CommandOutputFormat, e: &anyhow::Error) -> String {
-    let main_error = e.to_string();
-    let mut causes: Vec<String> = e.chain().skip(1).map(|cause| cause.to_string()).collect();
-
-    let error = if causes.is_empty() {
-        if let Some((first_part, second_part)) = main_error.split_once(':') {
-            causes.push(second_part.trim().to_string());
-            first_part.trim().to_string()
-        } else {
-            main_error
-        }
-    } else {
-        main_error
-    };
-
-    let cause = (!causes.is_empty()).then_some(causes);
-
-    let error_response = ErrorOutput { error, cause };
+    let error = e.to_string();
+    let causes: Vec<String> = e.chain().skip(1).map(|cause| cause.to_string()).collect();
+    let error_response = ErrorOutput { error, causes };
     serialize_output(format, &error_response).unwrap_or_else(|_| format!("{e:#}"))
 }