Merge pull request talaia-labs#53 from talaia-labs/cln-plugin

Adds watchtower plugin for CoreLN

Author: sr-gi

.github/workflows/build.yaml

@@ -9,6 +9,9 @@ jobs:
       matrix:
         platform: [ ubuntu-latest, macos-latest, windows-latest ]
         toolchain: [ stable ]
+        include:
+           - platform: windows-latest
+             arguments: --workspace --exclude watchtower-plugin
 
     runs-on: ${{ matrix.platform }}
     steps:
@@ -22,10 +25,10 @@ jobs:
           profile: minimal
       - name: Build on Rust ${{ matrix.toolchain }}
         run: |
-          cargo build --verbose --color always
+          cargo build ${{ matrix.arguments }} --verbose --color always
       - name: Test on Rust ${{ matrix.toolchain }}
         run: |
-          cargo test --verbose --color always
+          cargo test ${{ matrix.arguments }} --verbose --color always
 
   lint:
     runs-on: ubuntu-latest
@@ -43,4 +46,4 @@ jobs:
           cargo fmt --verbose --check -- --color always
       - name: Run clippy
         run: |
-          cargo clippy --all-features --all-targets --color always -- --deny warnings
+          cargo clippy --all-features --all-targets --color always -- --deny warnings

.github/workflows/cln-plugin.yaml

@@ -0,0 +1,64 @@
+name: CI tests for CLN watchtower-plugin
+
+on: [push, pull_request]
+
+env:
+  bitcoind_version: 0.20.1
+  cln_version: 0.11.0.1
+
+jobs:
+  cache-cln:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+      - name: Create CLN cache
+        id: cache-cln
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-cln-dev
+        with:
+          path: lightning
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-v${{ env.cln_version }}
+      - name: Compile CLN
+        if: ${{ steps.cache-cln.outputs.cache-hit != 'true' }}
+        run: |
+          sudo apt-get update && sudo apt-get install gettext
+          git clone https://github.com/ElementsProject/lightning.git && cd lightning && git checkout v${{ env.cln_version }}
+          pip install --user poetry && poetry install
+          ./configure --enable-developer && poetry run make
+
+  cln-plugin:
+    needs: cache-cln
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+      - name: Install bitcoind
+        run: |
+          wget https://bitcoincore.org/bin/bitcoin-core-${{ env.bitcoind_version }}/bitcoin-${{ env.bitcoind_version }}-x86_64-linux-gnu.tar.gz
+          tar -xzf bitcoin-${{ env.bitcoind_version }}-x86_64-linux-gnu.tar.gz
+          ln -s $(pwd)/bitcoin-${{ env.bitcoind_version }}/bin/bitcoin* /usr/local/bin
+      - name: Load CLN cache
+        id: cache-cln
+        uses: actions/cache@v3
+        env:
+          cache-name: cache-cln-dev
+        with:
+          path: lightning
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-v${{ env.cln_version }}
+      - name: Link CLN
+        run: |
+          cd lightning && sudo make install
+      - name: Install teos and the plugin
+        run: |
+          cargo install --path teos 
+          cargo install --path watchtower-plugin
+      - name: Add test dependencies
+        run: |
+          cd watchtower-plugin/tests
+          pip install --user poetry && poetry install
+      - name: Run tests
+        run: |
+          cd watchtower-plugin/tests
+          DEVELOPER=1 poetry run pytest test.py -s

.gitignore

@@ -1,4 +1,5 @@
 target
-*/target
+__pycache__
 Cargo.lock
 .vscode
+.idea

Cargo.toml

@@ -3,4 +3,5 @@
 members = [
     "teos",
     "teos-common",
+    "watchtower-plugin"
 ]

README.md

@@ -114,8 +114,11 @@ To run `teos-cli` remotely, you'll need to take one extra step. When `teosd` is
 The files are generated to the data directory (by default stored at `~/.teos`). To run remotely, users need to copy the `client.pem`, `client-key.pem`, and `ca.pem` files to the corresponding watchtower data directory on the machine where the CLI is being run.
 
 ## Interacting with TEOS as a client
+## TEOS clients
 
-FIXME: Add client and docs
+Here is a list of the available clients for `teos`:
+
+- [watchtower-plugin for CLN](watchtower-plugin/)
 
 ## Contributing 
 Refer to [CONTRIBUTING.md](CONTRIBUTING.md)

teos-common/Cargo.toml

@@ -8,12 +8,20 @@ edition = "2018"
 
 [dependencies]
 # General
-hex = "0.4.3"
+hex = { version = "0.4.3", features = [ "serde" ] }
+prost = "0.9"
+rusqlite = { version = "0.26.0", features = [ "bundled", "limits" ] }
+serde = "1.0.130"
+serde_json = "1.0"
+tonic = "0.6"
 
 # Crypto
 rand = "0.8.4"
 chacha20poly1305 = "0.8.0"
 
 # Bitcoin and Lightning
-bitcoin = "0.27"
+bitcoin = { version = "0.27", features = [ "use-serde" ] }
 lightning = "0.0.105"
+
+[build-dependencies]
+tonic-build = "0.6"

teos-common/build.rs

@@ -0,0 +1,23 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tonic_build::configure()
+        .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]")
+        .type_attribute("AppointmentData.appointment_data", "#[serde(untagged)]")
+        .field_attribute("AppointmentData.appointment_data", "#[serde(flatten)]")
+        .field_attribute("appointment_data", "#[serde(rename = \"appointment\")]")
+        .field_attribute("user_id", "#[serde(with = \"hex::serde\")]")
+        .field_attribute("locator", "#[serde(with = \"hex::serde\")]")
+        .field_attribute("encrypted_blob", "#[serde(with = \"hex::serde\")]")
+        .field_attribute(
+            "GetAppointmentResponse.status",
+            "#[serde(with = \"crate::ser::serde_status\")]",
+        )
+        .compile(
+            &[
+                "proto/common/teos/v2/appointment.proto",
+                "proto/common/teos/v2/user.proto",
+            ],
+            &["proto/common/teos/v2"],
+        )?;
+
+    Ok(())
+}

teos-common/proto/common/teos/v2/appointment.proto

@@ -0,0 +1,75 @@
+syntax = "proto3";
+package common.teos.v2;
+
+message Appointment {
+    /*
+    Contains the basic information about an appointment (Watcher) and it's used for messages like
+    AddAppointmentRequest or encapsulated inside AppointmentData for GetAppointmentResponse
+    */
+  
+    bytes locator = 1;
+    bytes encrypted_blob = 2;
+    uint32 to_self_delay = 3;
+  
+  }
+  
+  message Tracker {
+    // It's the equivalent of an appointment message from data held by the Responder.
+  
+    bytes dispute_txid = 1;
+    bytes penalty_txid = 2;
+    bytes penalty_rawtx = 3;
+  }
+  
+  message AppointmentData {
+    /*
+    Encapsulates the data for a GetAppointmentResponse, given it can be an appointment (data is on the Watcher) or a
+    tracker (data is on the Responder).
+    */
+  
+    oneof appointment_data {
+      Appointment appointment = 1;
+      Tracker tracker = 2;
+    }
+  }
+  
+  message AddAppointmentRequest {
+    // Request to add an appointment to the backend, contains the appointment data and the user signature.
+  
+    Appointment appointment = 1;
+    string signature = 2;
+  }
+  
+  message AddAppointmentResponse {
+    /*
+    Response to an AddAppointmentRequest, contains the locator to identify the added appointment, the tower signature,
+    the block at which the tower has started (or will start) watching for the appointment, and the updated subscription
+    information.
+     */
+  
+    bytes locator = 1;
+    uint32 start_block = 2;
+    string signature = 3;
+    uint32 available_slots = 4;
+    uint32 subscription_expiry = 5;
+  }
+  
+  message GetAppointmentRequest {
+    // Request to get information about an appointment. Contains the appointment locator and a signature by the user.
+  
+    bytes locator = 1;
+    string signature = 2;
+  }
+  
+  message GetAppointmentResponse {
+    // Response to a GetAppointmentRequest. Contains the appointment data encapsulated in an AppointmentData message.
+  
+    AppointmentData appointment_data = 1;
+    enum AppointmentStatus {
+      NOT_FOUND = 0;
+      BEING_WATCHED = 1;
+      DISPUTE_RESPONDED = 2;
+  
+    }
+    AppointmentStatus status = 2;
+  }

teos-common/proto/common/teos/v2/user.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+package common.teos.v2;
+
+message RegisterRequest {
+    // Requests a user registration with the tower. Contains the user id in the form of a compressed ECDSA public key.
+  
+    bytes user_id = 1;
+  }
+  
+  message RegisterResponse {
+    // Response to a RegisterRequest, contains the registration information alongside the tower signature of the agreement.
+  
+    bytes user_id = 1;
+    uint32 available_slots = 2;
+    uint32 subscription_expiry = 3;
+    string subscription_signature = 4;
+  }
+
+  message GetSubscriptionInfoRequest {
+    // Request to get a specific user's subscription info.
+
+    string signature = 1;
+}
+
+message GetSubscriptionInfoResponse {
+  // Response with the information the tower has about a specific user
+
+  uint32 available_slots = 1;
+  uint32 subscription_expiry = 2;
+  repeated bytes locators = 3;
+}

teos-common/src/appointment.rs

@@ -1,15 +1,19 @@
 //! Logic related to appointments shared between users and the towers.
 
 use hex;
+use serde::{Deserialize, Serialize};
+
 use std::array::TryFromSliceError;
 use std::{convert::TryInto, fmt};
 
 use bitcoin::Txid;
 
+use crate::protos as msgs;
+
 pub const LOCATOR_LEN: usize = 16;
 
 /// User identifier for appointments.
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash, Serialize, Deserialize)]
 pub struct Locator([u8; LOCATOR_LEN]);
 
 impl Locator {
@@ -19,36 +23,42 @@ impl Locator {
     }
 
     /// Encodes a locator into its byte representation.
-    pub fn serialize(&self) -> Vec<u8> {
+    pub fn to_vec(&self) -> Vec<u8> {
         self.0.to_vec()
     }
 
     /// Builds a locator from its byte representation.
-    pub fn deserialize(data: &[u8]) -> Result<Self, TryFromSliceError> {
+    pub fn from_slice(data: &[u8]) -> Result<Self, TryFromSliceError> {
         data.try_into().map(Self)
     }
 }
 
-impl std::str::FromStr for Locator {
-    type Err = String;
+impl fmt::Display for Locator {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", hex::encode(self.to_vec()))
+    }
+}
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let raw_locator = hex::decode(s).map_err(|_| "Locator is not hex encoded")?;
-        Locator::deserialize(&raw_locator)
-            .map_err(|_| "Locator cannot be built from the given data".into())
+impl AsRef<[u8]> for Locator {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
     }
 }
 
-impl fmt::Display for Locator {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", hex::encode(self.serialize()))
+impl hex::FromHex for Locator {
+    type Error = String;
+
+    fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
+        let raw_locator = hex::decode(hex).map_err(|_| "Locator is not hex encoded")?;
+        Locator::from_slice(&raw_locator)
+            .map_err(|_| "Locator cannot be built from the given data".into())
     }
 }
 
 /// Contains data regarding an appointment between a client and the tower.
 ///
 /// An appointment is requested for every new channel update.
-#[derive(Debug, Eq, PartialEq, Clone)]
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub struct Appointment {
     /// The user identifier for the appointment.
     pub locator: Locator,
@@ -62,6 +72,7 @@ pub struct Appointment {
 }
 
 /// Represents all the possible states of an appointment in the tower, or in a response to a client request.
+#[derive(Serialize, Deserialize, Debug)]
 pub enum AppointmentStatus {
     NotFound = 0,
     BeingWatched = 1,
@@ -118,10 +129,27 @@ impl Appointment {
     /// `locator || encrypted_blob || to_self_delay`
     ///
     /// All values are big endian.
-    pub fn serialize(&self) -> Vec<u8> {
-        let mut result = self.locator.serialize();
+    pub fn to_vec(&self) -> Vec<u8> {
+        let mut result = self.locator.to_vec();
         result.extend(&self.encrypted_blob);
         result.extend(self.to_self_delay.to_be_bytes().to_vec());
         result
     }
 }
+
+impl From<Appointment> for msgs::Appointment {
+    fn from(a: Appointment) -> Self {
+        Self {
+            locator: a.locator.to_vec(),
+            encrypted_blob: a.encrypted_blob.clone(),
+            to_self_delay: a.to_self_delay,
+        }
+    }
+}
+
+/// Computes the number of slots an appointment takes from a user subscription.
+///
+/// This is based on the [encrypted_blob](Appointment::encrypted_blob) size and the slot size that was defined by the [Gatekeeper](crate::gatekeeper::Gatekeeper).
+pub fn compute_appointment_slots(blob_size: usize, blob_max_size: usize) -> u32 {
+    (blob_size as f32 / blob_max_size as f32).ceil() as u32
+}