Added CRchannelmanager

Author: Srg213

src/channel_request/channel_manager.rs

@@ -1,33 +1,59 @@
+use bitcoin::secp256k1::PublicKey;
 
+use crate::transport::msgs::RequestId;
+use super::msgs::{OptionsSupported, ChannelInfo, Order, Payment};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
-    // Request from the client for server info.
-    GetInfo {},
-
+    
     // Information from the LSP regarding fees and channel parameters.
-    GetInfoResponse {},
+    // The client should validate if the LSP's parameters supported match 
+    // requirements.
+    GetInfoResponse {
+        channel_id: u128,
+        
+        request_id: RequestId,
+    
+		/// The node id of the LSP that provided this response.
+		counterparty_node_id: PublicKey,
+
+        version: Vec<u16>,
+
+        website: String,
+
+        options_supported: OptionsSupported
+    },
 
     // Channel opening request from the client after selecting the LSP with desired parameters.
     // Client selects the fee and channel parameters and requests the LSP to create a channel.
-    CreateChannel {},
+    // LSP should check the validity of the create channel order.
+    CreateInvoice {
+        request_id: RequestId,
 
-    // LSP accepts the request parameters and sends an onchain address and invoice along with channel
-    // parameters to the client.
-    Order {},
+		counterparty_node_id: PublicKey,
+
+        order: Order,
+    },
 
-    // Client confirms the parameters and pays the LSP through onchain or lightning payment.
-    PaymentforChannel {},
+    // LSP accepts the request parameters and sends an onchain address and invoice along with channel
+    // parameters to the client. After payment by the client this event should be updated,
+    // to show the LSP to poll for the payment now.
+    PayforChannel {
+        request_id: RequestId,
+		counterparty_node_id: PublicKey,
+		order: Order,
+		payment: Payment,
+		channel: Option<ChannelInfo>,
+    },
 
-    // Waits for the payment to confirm and till then the order status can be retrived.
-    GetOrderStatus {},
 
-    // Checks whether the payment is confirmed and updates the order.
-    ConfirmPayment {},
+    UpdatePaymentStatus {},
 
-    // On payment confirmation, channel is opened.
+    // On payment confirmation, channel is opened. After payment confirms,
+    // LSP should open a channel and open to client.
     OpenChannel {},
 
     // If order fails, refund is initiated.
+    // 
     Refund {},
 }

src/channel_request/event.rs

@@ -10,4 +10,5 @@
 //! Types and primitives that implement the LSPS1: Channel Request specification.
 pub mod channel_manager;
 pub mod event;
-pub mod msgs;
+pub mod msgs;
+mod utils;

src/channel_request/mod.rs

@@ -1,16 +1,31 @@
 
+use std::convert::TryFrom;
+
 use serde::{Deserialize, Serialize};
 
 //use bitcoin::hashes::hmac::{Hmac, HmacEngine};
 //use bitcoin::hashes::sha256::Hash as Sha256;
 //use bitcoin::hashes::{Hash, HashEngine};
-use crate::transport::msgs::{RequestId, ResponseError};
+use crate::transport::msgs::{RequestId, ResponseError, LSPSMessage};
 use crate::utils;
 
 pub(crate) const LSPS1_GETINFO_METHOD_NAME: &str = "lsps1.getinfo";
 pub(crate) const LSPS1_CREATE_ORDER_METHOD_NAME: &str = "lsps1.create_order";
 pub(crate) const LSPS1_GET_ORDER_METHOD_NAME: &str = "lsps1.get_order";
 
+
+pub(crate) const REFUND_ONCHAIN_ADDRESS: bool = false;
+
+// Create a const to show preferred way for user payment
+// Should this be set everytime before payment?
+// Ask user for lighting or onchain and then set the const to
+// lightning or onchain
+
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Hash)]
+pub struct OrderId(pub String);
+
+
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct GetInfoRequest {}
@@ -35,72 +50,56 @@ pub struct OptionsSupported {
 pub struct GetInfoResponse {
     pub supported_versions: Vec<u16>,
     pub website: String,
-	pub options: Vec<OptionsSupported>,
+	pub options: OptionsSupported,
 }
 
-impl GetInfoResponse {
-	fn is_valid(&self) -> bool {
-		// TODO check validity of min < max for every pair 
-		// Use of hmacengine/hash for checking
-		1
-	}
-}
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct CreateOrderRequest {
-	pub api_version: u8,
-	pub lsp_balance_sat: String,
-	pub client_balance_sat: String,
-	pub confirms_within_blocks: u8,
-	pub channel_expiry_blocks: u8,
-	pub token: String,
-	// String of Onchain address, maybe object- String/bech32,
-	pub refund_onchain_address: String,
-	pub announce_channel: bool,
-}
-
-impl CreateOrderRequest {
-	fn is_valid(&self, req: &GetInfoResponse) -> bool {
-		// implement the conditions
-	}
+	pub order: Order,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct Order {
-	pub order_id: String,
+	pub order_id: Option<OrderId>,
 	pub api_version: u16,
 	pub lsp_balance_sat: u64,
 	pub client_balance_sat: u64,
 	pub confirms_within_blocks: u32,
 	pub channel_expiry_blocks: u32,
 	pub token: String,
-	pub created_at: String,
-	pub expires_at: String,
 	pub announce_channel: bool,
+	pub refund_onchain_address: Option<String>,
 	pub order_state: OrderState,
-	pub payment: Payment,
-	pub channel: Option<Channel>,
 }
 
-
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-pub struct CreateOrderResponse{
-	pub response: Order,
+pub struct CreateOrderResponse {
+	pub order: Order,
+	pub created_at: String,
+	pub expires_at: String,
+	pub payment: Payment,
+	pub channel: Option<ChannelInfo>,
 }
 
 impl CreateOrderResponse {
-	fn new(request: &CreateOrderRequest) -> () {
+	// import datetime and set to time to creaetd_at.
+	pub fn new(order: &mut Order, fee: u64, bolt11_invoice: String,
+	onchain_address: String, options: OptionsSupported) -> Self {
 		// Few of the parameters are mirrored from the orderrequest.
-	}
-
-	fn is_valid(&self) -> () {
-		// Check the following conditions
-
+	
+		let response = CreateOrderResponse {
+			order: request.order,
+			payment,
+			channel: None,
+		};
+		response
 	}
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub enum OrderState {
+	Requested,
 	Created,
 	Completed,
 	Failed,
@@ -134,8 +133,8 @@ pub struct OnchainPayment{
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-pub struct Channel {
-	pub state: ChannelState,
+pub struct ChannelInfo {
+	pub state: ChannelStatus,
 	pub funded_at: String,
 	pub funding_outpoint: String,
 	pub scid: Option<String>,
@@ -145,15 +144,15 @@ pub struct Channel {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-pub enum ChannelState {
+pub enum ChannelStatus {
 	Opening,
 	Opened,
 	Closed,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct GetOrderRequest {
-	pub order_id: String,
+	pub order_id: OrderId,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
@@ -193,3 +192,21 @@ pub enum Message {
 	Request(RequestId, Request),
 	Response(RequestId, Response),
 }
+
+impl TryFrom<LSPSMessage> for Message {
+	type Error = ();
+
+	fn try_from(message: LSPSMessage) -> Result<Self, Self::Error> {
+		if let LSPSMessage::LSPS1(message) = message {
+			return Ok(message);
+		}
+
+		Err(())
+	}
+}
+
+impl From<Message> for LSPSMessage {
+	fn from(message: Message) -> Self {
+		LSPSMessage::LSPS1(message)
+	}
+}

src/channel_request/msgs.rs

@@ -0,0 +1,8 @@
+
+// Need to add more conditions
+
+pub fn check_if_valid(value: u128, upper: u128, lower: u128) -> () {
+    let range = lower..upper;
+    assert!(range.contains(&value));
+}
+

src/channel_request/utils.rs

@@ -0,0 +1,8 @@
+use crate::channel_request;
+
+/// An Event which you should probably take some action in response to.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Event {
+	/// A LSPS1 (JIT Channel) protocol event
+	LSPS1(channel_request::event::Event),
+}

src/events.rs

@@ -22,5 +22,6 @@ mod channel_request;
 mod jit_channel;
 mod transport;
 mod utils;
+pub mod events;
 
 pub use transport::message_handler::{LiquidityManager, LiquidityProviderConfig};

src/lib.rs

@@ -37,7 +37,7 @@ impl wire::Type for RawLSPSMessage {
 	}
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct RequestId(pub String);
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
@@ -88,6 +88,7 @@ impl TryFrom<LSPSMessage> for LSPS0Message {
 		match message {
 			LSPSMessage::Invalid => Err(()),
 			LSPSMessage::LSPS0(message) => Ok(message),
+			LSPSMessage::LSPS1(_) => Err(()),
 		}
 	}
 }
@@ -160,6 +161,47 @@ impl Serialize for LSPSMessage {
 					}
 				}
 			}
+
+			LSPSMessage::LSPS1(channel_request::msgs::Message::Request(request_id, request)) => {
+				jsonrpc_object.serialize_field(JSONRPC_ID_FIELD_KEY, &request_id.0)?;
+				jsonrpc_object.serialize_field(JSONRPC_METHOD_FIELD_KEY, request.method())?;
+
+				match request {
+					channel_request::msgs::Request::GetInfo(params) => {
+						jsonrpc_object.serialize_field(JSONRPC_PARAMS_FIELD_KEY, params)?
+					}
+					channel_request::msgs::Request::CreateOrder(params) => {
+						jsonrpc_object.serialize_field(JSONRPC_PARAMS_FIELD_KEY, params)?
+					}
+					channel_request::msgs::Request::GetOrder(params) => {
+						jsonrpc_object.serialize_field(JSONRPC_PARAMS_FIELD_KEY, params)?
+					}
+				}
+			}
+			LSPSMessage::LSPS1(channel_request::msgs::Message::Response(request_id, response)) => {
+				jsonrpc_object.serialize_field(JSONRPC_ID_FIELD_KEY, &request_id.0)?;
+
+				match response {
+					channel_request::msgs::Response::GetInfo(result) => {
+						jsonrpc_object.serialize_field(JSONRPC_RESULT_FIELD_KEY, result)?
+					}
+					channel_request::msgs::Response::GetInfoError(error) => {
+						jsonrpc_object.serialize_field(JSONRPC_RESULT_FIELD_KEY, error)?
+					}
+					channel_request::msgs::Response::CreateOrder(result) => {
+						jsonrpc_object.serialize_field(JSONRPC_ERROR_FIELD_KEY, result)?
+					}
+					channel_request::msgs::Response::OrderError(error) => {
+						jsonrpc_object.serialize_field(JSONRPC_RESULT_FIELD_KEY, error)?
+					}
+					channel_request::msgs::Response::GetOrder(result) => {
+						jsonrpc_object.serialize_field(JSONRPC_ERROR_FIELD_KEY, result)?
+					}
+					&channel_request::msgs::Response::GetOrderError(error) => {
+						jsonrpc_object.serialize_field(JSONRPC_ERROR_FIELD_KEY, error)?	
+					}
+				}
+			}
 			LSPSMessage::Invalid => {
 				let error = ResponseError {
 					code: JSONRPC_INVALID_MESSAGE_ERROR_CODE,