add on_commitment_revocation

Signed-off-by: dzdidi <[email protected]>

Author: dzdidi

teos-ldk-client/README.md

@@ -16,7 +16,9 @@ The client instance has the following methods:
 - `get_subscription_info <tower_id>`: gets the subscription information by querying the tower.
 - `get_appointment_receipt <tower_id> <locator>`: pulls a given appointment receipt from the local database.
 - `get_registration_receipt <tower_id>`: pulls the latest registration receipt from the local database.
-- `on_commitment_revocation <tx>`: sends appointments to the registered towers for every new commitment transaction.
+
+The general usage idea
+- `on_commitment_revocation <wt_client, tx>`: sends appointments to the registered towers for every new commitment transaction.
 
 # Configuration
 

teos-ldk-client/src/lib.rs

@@ -1,12 +1,20 @@
 use std::collections::{HashMap, HashSet};
 use std::fmt;
+use std::sync::MutexGuard;
+use std::sync::{Arc, Mutex};
 
 use serde::{Deserialize, Serialize};
 
 use teos_common::appointment::{Appointment, Locator};
 use teos_common::net::NetAddr;
 use teos_common::receipts::AppointmentReceipt;
 use teos_common::TowerId;
+use teos_common::{cryptography, errors};
+
+use crate::convert::CommitmentRevocation;
+use crate::http::AddAppointmentError;
+use crate::net::http;
+use crate::wt_client::{RevocationData, WTClient};
 
 pub mod convert;
 pub mod net;
@@ -280,6 +288,143 @@ impl MisbehaviorProof {
     }
 }
 
+/// Sends an appointment to all registered towers for every new commitment transaction.
+///
+/// The appointment is built using the data provided by the backend (dispute txid and penalty transaction).
+pub async fn on_commitment_revocation(
+    wt_client: Arc<Mutex<WTClient>>,
+    commitment_revocation: CommitmentRevocation,
+) -> Result<(), Box<dyn std::error::Error>> {
+    log::debug!(
+        "New commitment revocation received for channel {}. Commit number {}",
+        commitment_revocation.channel_id,
+        commitment_revocation.commit_num
+    );
+
+    // TODO: For now, to_self_delay is hardcoded to 42. Revisit and define it better / remove it when / if needed
+    let locator = Locator::new(commitment_revocation.commitment_txid);
+    let appointment = Appointment::new(
+        locator,
+        cryptography::encrypt(
+            &commitment_revocation.penalty_tx,
+            &commitment_revocation.commitment_txid,
+        )
+        .unwrap(),
+        42,
+    );
+    let signature =
+        cryptography::sign(&appointment.to_vec(), &wt_client.lock().unwrap().user_sk).unwrap();
+
+    // Looks like we cannot iterate through towers given a locked state is not Send (due to the async call),
+    // so we need to clone the bare minimum.
+    let towers = wt_client
+        .lock()
+        .unwrap()
+        .towers
+        .iter()
+        .map(|(id, info)| (*id, info.net_addr.clone(), info.status))
+        .collect::<Vec<_>>();
+
+    for (tower_id, net_addr, status) in towers {
+        if status.is_reachable() {
+            match http::add_appointment(tower_id, &net_addr, &appointment, &signature).await {
+                Ok((slots, receipt)) => {
+                    wt_client
+                        .lock()
+                        .unwrap()
+                        .add_appointment_receipt(tower_id, locator, slots, &receipt);
+                    log::debug!("Response verified and data stored in the database");
+                }
+                Err(e) => match e {
+                    AddAppointmentError::RequestError(e) => {
+                        if e.is_connection() {
+                            log::warn!(
+                                "{tower_id} cannot be reached. Adding {} to pending appointments",
+                                appointment.locator
+                            );
+                            let mut state = wt_client.lock().unwrap();
+                            state.set_tower_status(tower_id, TowerStatus::TemporaryUnreachable);
+                            state.add_pending_appointment(tower_id, &appointment);
+                            send_to_retrier(&state, tower_id, appointment.locator);
+                        }
+                    }
+                    AddAppointmentError::ApiError(e) => match e.error_code {
+                        errors::INVALID_SIGNATURE_OR_SUBSCRIPTION_ERROR => {
+                            log::warn!(
+                                "There is a subscription issue with {tower_id}. Adding {} to pending",
+                                appointment.locator
+                            );
+                            let mut state = wt_client.lock().unwrap();
+                            state.set_tower_status(tower_id, TowerStatus::SubscriptionError);
+                            state.add_pending_appointment(tower_id, &appointment);
+                            send_to_retrier(&state, tower_id, appointment.locator);
+                        }
+
+                        _ => {
+                            log::warn!(
+                                "{tower_id} rejected the appointment. Error: {}, error_code: {}",
+                                e.error,
+                                e.error_code
+                            );
+                            wt_client
+                                .lock()
+                                .unwrap()
+                                .add_invalid_appointment(tower_id, &appointment);
+                        }
+                    },
+                    AddAppointmentError::SignatureError(proof) => {
+                        log::warn!("Cannot recover known tower_id from the appointment receipt. Flagging tower as misbehaving");
+                        wt_client
+                            .lock()
+                            .unwrap()
+                            .flag_misbehaving_tower(tower_id, proof)
+                    }
+                },
+            };
+        } else if status.is_misbehaving() {
+            log::warn!("{tower_id} is misbehaving. Not sending any further appointments",);
+        } else {
+            if status.is_subscription_error() {
+                log::warn!(
+                    "There is a subscription issue with {tower_id}. Adding {} to pending",
+                    appointment.locator
+                );
+            } else {
+                log::warn!(
+                    "{tower_id} is {status}. Adding {} to pending",
+                    appointment.locator,
+                );
+            }
+
+            let mut state = wt_client.lock().unwrap();
+            state.add_pending_appointment(tower_id, &appointment);
+
+            if !status.is_unreachable() {
+                send_to_retrier(&state, tower_id, appointment.locator);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Sends fresh data to a retrier as long as is does not exist, or it does and its running.
+fn send_to_retrier(state: &MutexGuard<WTClient>, tower_id: TowerId, locator: Locator) {
+    if if let Some(status) = state.get_retrier_status(&tower_id) {
+        // A retrier in the retriers map can only be running or idle
+        status.is_running()
+    } else {
+        true
+    } {
+        state
+            .unreachable_towers
+            .send((tower_id, RevocationData::Fresh(locator)))
+            .unwrap();
+    } else {
+        log::debug!("Not sending data to idle retrier ({tower_id}, {locator})")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

teos-ldk-client/src/storage/encryption.rs

@@ -16,16 +16,12 @@ pub(crate) fn encrypt(
     message: &[u8],
     secret: &[u8],
 ) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
-    // Create nonce [0; 12]
     let nonce = Nonce::default();
-
-    // Hash the secret to create the encryption key
     let key_hash = sha256::Hash::hash(secret);
     let key = Key::from_slice(key_hash.as_byte_array());
 
-    // Create cipher instance
     let cipher = ChaCha20Poly1305::new(key);
-    // Encrypt the message
+
     cipher.encrypt(&nonce, message)
 }
 
@@ -40,10 +36,9 @@ pub(crate) fn decrypt(
     encrypted_blob: &[u8],
     secret: &[u8],
 ) -> Result<Vec<u8>, chacha20poly1305::aead::Error> {
-    // Defaults is [0; 12]
     let nonce = Nonce::default();
-    let k = sha256::Hash::hash(secret);
-    let key = Key::from_slice(k.as_byte_array());
+    let key_hash = sha256::Hash::hash(secret);
+    let key = Key::from_slice(key_hash.as_byte_array());
 
     let cypher = ChaCha20Poly1305::new(key);