Drop versioning from LSPS1

... as the spec dropped versioning, we now make the corresponding
adjustments.

Author: tnull

src/lsps1/client.rs

@@ -1,4 +1,4 @@
-// This file is Copyright its original authors, visible in version contror
+// This file is Copyright its original authors, visible in version control
 // history.
 //
 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
@@ -35,8 +35,6 @@ use bitcoin::secp256k1::PublicKey;
 
 use core::ops::Deref;
 
-const SUPPORTED_SPEC_VERSIONS: [u16; 1] = [1];
-
 /// Client-side configuration options for LSPS1 channel requests.
 #[derive(Clone, Debug)]
 pub struct LSPS1ClientConfig {
@@ -55,43 +53,30 @@ impl From<ChannelStateError> for LightningError {
 #[derive(PartialEq, Debug)]
 enum InboundRequestState {
 	InfoRequested,
-	OptionsSupport { version: u16, options_supported: OptionsSupported },
-	OrderRequested { version: u16, order: OrderParams },
+	OptionsSupport { options_supported: OptionsSupported },
+	OrderRequested { order: OrderParams },
 	PendingPayment { order_id: OrderId },
 	AwaitingConfirmation { id: u128, order_id: OrderId },
 }
 
 impl InboundRequestState {
-	fn info_received(
-		&self, versions: Vec<u16>, options: OptionsSupported,
-	) -> Result<Self, ChannelStateError> {
-		let max_shared_version = versions
-			.iter()
-			.filter(|version| SUPPORTED_SPEC_VERSIONS.contains(version))
-			.max()
-			.cloned()
-			.ok_or(ChannelStateError(format!(
-			"LSP does not support any of our specification versions.  ours = {:?}. theirs = {:?}",
-			SUPPORTED_SPEC_VERSIONS, versions
-		)))?;
-
+	fn info_received(&self, options: OptionsSupported) -> Result<Self, ChannelStateError> {
 		match self {
-			InboundRequestState::InfoRequested => Ok(InboundRequestState::OptionsSupport {
-				version: max_shared_version,
-				options_supported: options,
-			}),
+			InboundRequestState::InfoRequested => {
+				Ok(InboundRequestState::OptionsSupport { options_supported: options })
+			}
 			state => Err(ChannelStateError(format!(
-				"Received unexpected get_versions response. Channel was in state: {:?}",
+				"Received unexpected get_info response. Channel was in state: {:?}",
 				state
 			))),
 		}
 	}
 
 	fn order_requested(&self, order: OrderParams) -> Result<Self, ChannelStateError> {
 		match self {
-			InboundRequestState::OptionsSupport { version, options_supported } => {
+			InboundRequestState::OptionsSupport { options_supported } => {
 				if is_valid(&order, options_supported) {
-					Ok(InboundRequestState::OrderRequested { version: *version, order })
+					Ok(InboundRequestState::OrderRequested { order })
 				} else {
 					return Err(ChannelStateError(format!(
 						"The order created does not match options supported by LSP. Options Supported by LSP are {:?}. The order created was {:?}",
@@ -110,7 +95,7 @@ impl InboundRequestState {
 		&self, response_order: &OrderParams, order_id: OrderId,
 	) -> Result<Self, ChannelStateError> {
 		match self {
-			InboundRequestState::OrderRequested { version, order } => {
+			InboundRequestState::OrderRequested { order } => {
 				if response_order == order {
 					Ok(InboundRequestState::PendingPayment { order_id })
 				} else {
@@ -153,25 +138,23 @@ impl InboundCRChannel {
 		Self { id, state: InboundRequestState::InfoRequested }
 	}
 
-	fn info_received(
-		&mut self, versions: Vec<u16>, options: OptionsSupported,
-	) -> Result<u16, LightningError> {
-		self.state = self.state.info_received(versions, options)?;
+	fn info_received(&mut self, options: OptionsSupported) -> Result<(), LightningError> {
+		self.state = self.state.info_received(options)?;
 
 		match self.state {
-			InboundRequestState::OptionsSupport { version, .. } => Ok(version),
+			InboundRequestState::OptionsSupport { .. } => Ok(()),
 			_ => Err(LightningError {
 				action: ErrorAction::IgnoreAndLog(Level::Error),
 				err: "impossible state transition".to_string(),
 			}),
 		}
 	}
 
-	fn order_requested(&mut self, order: OrderParams) -> Result<u16, LightningError> {
+	fn order_requested(&mut self, order: OrderParams) -> Result<(), LightningError> {
 		self.state = self.state.order_requested(order)?;
 
 		match self.state {
-			InboundRequestState::OrderRequested { version, .. } => Ok(version),
+			InboundRequestState::OrderRequested { .. } => Ok(()),
 			_ => {
 				return Err(LightningError {
 					action: ErrorAction::IgnoreAndLog(Level::Error),
@@ -301,10 +284,8 @@ where
 					action: ErrorAction::IgnoreAndLog(Level::Info),
 				})?;
 
-				let version = match inbound_channel
-					.info_received(result.supported_versions, result.options.clone())
-				{
-					Ok(version) => version,
+				match inbound_channel.info_received(result.options.clone()) {
+					Ok(()) => (),
 					Err(e) => {
 						peer_state_lock.remove_inbound_channel(channel_id);
 						return Err(e);
@@ -315,7 +296,6 @@ where
 					id: channel_id,
 					request_id,
 					counterparty_node_id: *counterparty_node_id,
-					version,
 					website: result.website,
 					options_supported: result.options,
 				}))
@@ -349,8 +329,8 @@ where
 					err: format!("Channel with id {} not found", channel_id),
 				})?;
 
-				let version = match inbound_channel.order_requested(order.clone()) {
-					Ok(version) => version,
+				match inbound_channel.order_requested(order.clone()) {
+					Ok(()) => (),
 					Err(e) => {
 						peer_state_lock.remove_inbound_channel(channel_id);
 						return Err(APIError::APIMisuseError { err: e.err });
@@ -364,7 +344,7 @@ where
 					counterparty_node_id,
 					LSPS1Message::Request(
 						request_id,
-						LSPS1Request::CreateOrder(CreateOrderRequest { order, version }),
+						LSPS1Request::CreateOrder(CreateOrderRequest { order }),
 					)
 					.into(),
 				);
@@ -540,7 +520,7 @@ where
 				let channel_id =
 					peer_state_lock.request_to_cid.remove(&request_id).ok_or(LightningError {
 						err: format!(
-							"Received get_versions response for an unknown request: {:?}",
+							"Received get_order response for an unknown request: {:?}",
 							request_id
 						),
 						action: ErrorAction::IgnoreAndLog(Level::Info),
@@ -551,7 +531,7 @@ where
 					.get_mut(&channel_id)
 					.ok_or(LightningError {
 					err: format!(
-						"Received get_versions response for an unknown channel: {:?}",
+						"Received get_order response for an unknown channel: {:?}",
 						channel_id
 					),
 					action: ErrorAction::IgnoreAndLog(Level::Info),

src/lsps1/event.rs

@@ -19,8 +19,6 @@ pub enum LSPS1ClientEvent {
 		/// TODO
 		counterparty_node_id: PublicKey,
 		/// TODO
-		version: u16,
-		/// TODO
 		website: String,
 		/// TODO
 		options_supported: OptionsSupported,

src/lsps1/msgs.rs

@@ -16,7 +16,6 @@ pub(crate) const LSPS1_GET_ORDER_METHOD_NAME: &str = "lsps1.get_order";
 pub(crate) const LSPS1_CREATE_ORDER_REQUEST_INVALID_PARAMS_ERROR_CODE: i32 = -32602;
 pub(crate) const LSPS1_CREATE_ORDER_REQUEST_ORDER_MISMATCH_ERROR_CODE: i32 = 1000;
 pub(crate) const LSPS1_CREATE_ORDER_REQUEST_CLIENT_REJECTED_ERROR_CODE: i32 = 1001;
-pub(crate) const LSPS1_CREATE_ORDER_REQUEST_INVALID_VERSION_ERROR_CODE: i32 = 1;
 pub(crate) const LSPS1_CREATE_ORDER_REQUEST_INVALID_TOKEN_ERROR_CODE: i32 = 2;
 
 /// The identifier of an order.
@@ -62,8 +61,6 @@ pub struct OptionsSupported {
 /// A response to an [`GetInfoRequest`].
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct GetInfoResponse {
-	/// A list of all supported API versions by the LSP.
-	pub supported_versions: Vec<u16>,
 	/// The website of the LSP.
 	pub website: String,
 	/// All options supported by the LSP.
@@ -76,17 +73,13 @@ pub struct GetInfoResponse {
 /// for more information.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct CreateOrderRequest {
-	/// TODO: this is superfluous and should likely be removed.
-	pub version: u16,
 	/// The order made.
 	pub order: OrderParams,
 }
 
 /// An object representing an LSPS1 channel order.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct OrderParams {
-	/// The API version that the client wants to work with.
-	pub api_version: u16,
 	/// Indicates how many satoshi the LSP will provide on their side.
 	pub lsp_balance_sat: u64,
 	/// Indicates how many satoshi the client will provide on their side.

src/lsps1/service.rs

@@ -1,4 +1,4 @@
-// This file is Copyright its original authors, visible in version contror
+// This file is Copyright its original authors, visible in version control
 // history.
 //
 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
@@ -13,8 +13,7 @@ use super::event::LSPS1ServiceEvent;
 use super::msgs::{
 	ChannelInfo, CreateOrderRequest, CreateOrderResponse, GetInfoResponse, GetOrderRequest,
 	GetOrderResponse, LSPS1Message, LSPS1Request, LSPS1Response, OptionsSupported, OrderId,
-	OrderParams, OrderPayment, OrderState, LSPS1_CREATE_ORDER_REQUEST_INVALID_VERSION_ERROR_CODE,
-	LSPS1_CREATE_ORDER_REQUEST_ORDER_MISMATCH_ERROR_CODE,
+	OrderParams, OrderPayment, OrderState, LSPS1_CREATE_ORDER_REQUEST_ORDER_MISMATCH_ERROR_CODE,
 };
 use super::utils::is_valid;
 use crate::message_queue::MessageQueue;
@@ -38,8 +37,6 @@ use bitcoin::secp256k1::PublicKey;
 use chrono::Utc;
 use core::ops::Deref;
 
-const SUPPORTED_SPEC_VERSIONS: [u16; 1] = [1];
-
 /// Server-side configuration options for LSPS1 channel requests.
 #[derive(Clone, Debug)]
 pub struct LSPS1ServiceConfig {
@@ -72,10 +69,7 @@ impl OutboundRequestState {
 			OutboundRequestState::OrderCreated { order_id } => {
 				Ok(OutboundRequestState::WaitingPayment { order_id: order_id.clone() })
 			}
-			state => Err(ChannelStateError(format!(
-				"Received unexpected get_versions response. JIT Channel was in state: {:?}",
-				state
-			))),
+			state => Err(ChannelStateError(format!("TODO. JIT Channel was in state: {:?}", state))),
 		}
 	}
 }
@@ -177,7 +171,6 @@ where
 		&self, request_id: RequestId, counterparty_node_id: &PublicKey,
 	) -> Result<(), LightningError> {
 		let response = GetInfoResponse {
-			supported_versions: SUPPORTED_SPEC_VERSIONS.to_vec(),
 			website: self.config.website.clone().unwrap().to_string(),
 			options: self
 				.config
@@ -197,22 +190,6 @@ where
 	fn handle_create_order_request(
 		&self, request_id: RequestId, counterparty_node_id: &PublicKey, params: CreateOrderRequest,
 	) -> Result<(), LightningError> {
-		if !SUPPORTED_SPEC_VERSIONS.contains(&params.version) {
-			self.enqueue_response(
-				counterparty_node_id,
-				request_id,
-				LSPS1Response::CreateOrderError(ResponseError {
-					code: LSPS1_CREATE_ORDER_REQUEST_INVALID_VERSION_ERROR_CODE,
-					message: format!("version {} is not supported", params.version),
-					data: Some(format!("Supported versions are {:?}", SUPPORTED_SPEC_VERSIONS)),
-				}),
-			);
-			return Err(LightningError {
-				err: format!("client requested unsupported version {}", params.version),
-				action: ErrorAction::IgnoreAndLog(Level::Info),
-			});
-		}
-
 		if !is_valid(&params.order, &self.config.options_supported.as_ref().unwrap()) {
 			self.enqueue_response(
 				counterparty_node_id,
@@ -227,7 +204,10 @@ where
 				}),
 			);
 			return Err(LightningError {
-				err: format!("client requested unsupported version {}", params.version),
+				err: format!(
+					"Client order does not match any supported options: {:?}",
+					params.order
+				),
 				action: ErrorAction::IgnoreAndLog(Level::Info),
 			});
 		}