rebase on v0.0.125 + update rgb-lib

Author: zoedberg

Cargo.toml

@@ -41,25 +41,5 @@ opt-level = 3
 lto = true
 panic = "abort"
 
-[workspace.lints.rust.unexpected_cfgs]
-level = "forbid"
-# When adding a new cfg attribute, ensure that it is added to this list.
-#
-# Note that Cargo automatically declares corresponding cfgs for every feature
-# defined in the member-level [features] tables as "expected".
-check-cfg = [
-    "cfg(fuzzing)",
-    "cfg(secp256k1_fuzz)",
-    "cfg(hashes_fuzz)",
-    "cfg(test)",
-    "cfg(debug_assertions)",
-    "cfg(c_bindings)",
-    "cfg(ldk_bench)",
-    "cfg(ldk_test_vectors)",
-    "cfg(taproot)",
-    "cfg(async_signing)",
-    "cfg(require_route_graph_test)",
-    "cfg(dual_funding)",
-    "cfg(splicing)",
-    "cfg(async_payments)",
-]
+[workspace.lints.rust]
+warnings = "allow"

lightning-invoice/Cargo.toml

@@ -23,6 +23,12 @@ lightning-types = { version = "0.1.0", path = "../lightning-types", default-feat
 serde = { version = "1.0.118", optional = true }
 bitcoin = { version = "0.32.2", default-features = false, features = ["secp-recovery"] }
 
+# RGB and related
+rgb-lib = { version = "0.3.0-alpha.11", features = [
+    "electrum",
+    "esplora",
+], git = "https://github.com/RGB-Tools/rgb-lib.git", rev = "952cd185" }
+
 [dev-dependencies]
 serde_json = { version = "1"}
 hashbrown = { version = "0.13", default-features = false }

lightning-invoice/src/de.rs

@@ -13,6 +13,7 @@ use bech32::{u5, FromBase32};
 use bitcoin::{PubkeyHash, ScriptHash, WitnessVersion};
 use bitcoin::hashes::Hash;
 use bitcoin::hashes::sha256;
+use rgb_lib::ContractId;
 use crate::prelude::*;
 use lightning_types::payment::PaymentSecret;
 use lightning_types::routing::{RoutingFees, RouteHint, RouteHintHop};
@@ -22,7 +23,7 @@ use bitcoin::secp256k1::PublicKey;
 
 use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, Bolt11InvoiceSignature, PositiveTimestamp,
 	Bolt11SemanticError, PrivateRoute, Bolt11ParseError, ParseOrSemanticError, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawBolt11Invoice,
-	constants, SignedRawBolt11Invoice, RawDataPart, Bolt11InvoiceFeatures};
+	constants, SignedRawBolt11Invoice, RawDataPart, Bolt11InvoiceFeatures, RgbAmount, RgbContractId};
 
 use self::hrp_sm::parse_hrp;
 
@@ -466,6 +467,10 @@ impl FromBase32 for TaggedField {
 				Ok(TaggedField::PaymentMetadata(Vec::<u8>::from_base32(field_data)?)),
 			constants::TAG_FEATURES =>
 				Ok(TaggedField::Features(Bolt11InvoiceFeatures::from_base32(field_data)?)),
+			constants::TAG_RGB_AMOUNT =>
+				Ok(TaggedField::RgbAmount(RgbAmount::from_base32(field_data)?)),
+			constants::TAG_RGB_CONTRACT_ID =>
+				Ok(TaggedField::RgbContractId(RgbContractId::from_base32(field_data)?)),
 			_ => {
 				// "A reader MUST skip over unknown fields"
 				Err(Bolt11ParseError::Skip)
@@ -612,6 +617,7 @@ impl FromBase32 for PrivateRoute {
 				cltv_expiry_delta: u16::from_be_bytes(hop_bytes[49..51].try_into().expect("slice too big?")),
 				htlc_minimum_msat: None,
 				htlc_maximum_msat: None,
+				htlc_maximum_rgb: None,
 			};
 
 			route_hops.push(hop);
@@ -621,6 +627,32 @@ impl FromBase32 for PrivateRoute {
 	}
 }
 
+impl FromBase32 for RgbAmount {
+	type Err = Bolt11ParseError;
+
+	fn from_base32(field_data: &[u5]) -> Result<RgbAmount, Bolt11ParseError> {
+		let rgb_amount = parse_u64_be(field_data);
+		if let Some(rgb_amount) = rgb_amount {
+			Ok(RgbAmount(rgb_amount))
+		} else {
+			Err(Bolt11ParseError::IntegerOverflowError)
+		}
+	}
+}
+
+impl FromBase32 for RgbContractId {
+	type Err = Bolt11ParseError;
+
+	fn from_base32(field_data: &[u5]) -> Result<RgbContractId, Bolt11ParseError> {
+		let bytes = Vec::<u8>::from_base32(field_data)?;
+		let rgb_contract_id_str = String::from(str::from_utf8(&bytes)?);
+		match ContractId::from_str(&rgb_contract_id_str) {
+			Ok(cid) => Ok(RgbContractId(cid)),
+			Err(_) => Err(Bolt11ParseError::InvalidContractId),
+		}
+	}
+}
+
 impl Display for Bolt11ParseError {
 	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
 		match *self {
@@ -669,6 +701,9 @@ impl Display for Bolt11ParseError {
 			Bolt11ParseError::Skip => {
 				f.write_str("the tagged field has to be skipped because of an unexpected, but allowed property")
 			},
+			Bolt11ParseError::InvalidContractId => {
+				f.write_str("invalid RGB contract ID")
+			},
 		}
 	}
 }

lightning-invoice/src/lib.rs

@@ -42,6 +42,8 @@ use bitcoin::secp256k1::PublicKey;
 use bitcoin::secp256k1::{Message, Secp256k1};
 use bitcoin::secp256k1::ecdsa::RecoverableSignature;
 
+use rgb_lib::ContractId;
+
 use core::cmp::Ordering;
 use core::fmt::{Display, Formatter, self};
 use core::iter::FilterMap;
@@ -98,6 +100,7 @@ pub enum Bolt11ParseError {
 	InvalidScriptHashLength,
 	InvalidRecoveryId,
 	InvalidSliceLength(String),
+	InvalidContractId,
 
 	/// Not an error, but used internally to signal that a part of the invoice should be ignored
 	/// according to BOLT11
@@ -432,6 +435,8 @@ pub enum TaggedField {
 	PaymentSecret(PaymentSecret),
 	PaymentMetadata(Vec<u8>),
 	Features(Bolt11InvoiceFeatures),
+	RgbAmount(RgbAmount),
+	RgbContractId(RgbContractId),
 }
 
 /// SHA-256 hash
@@ -468,6 +473,14 @@ pub struct ExpiryTime(Duration);
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub struct MinFinalCltvExpiryDelta(pub u64);
 
+/// Requested amount for the RGB asset
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub struct RgbAmount(pub u64);
+
+/// Requested RGB contract ID
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub struct RgbContractId(pub ContractId);
+
 /// Fallback address in case no LN payment is possible
 #[allow(missing_docs)]
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
@@ -518,6 +531,8 @@ pub mod constants {
 	pub const TAG_PAYMENT_SECRET: u8 = 16;
 	pub const TAG_PAYMENT_METADATA: u8 = 27;
 	pub const TAG_FEATURES: u8 = 5;
+	pub const TAG_RGB_AMOUNT: u8 = 30;
+	pub const TAG_RGB_CONTRACT_ID: u8 = 31;
 }
 
 impl InvoiceBuilder<tb::False, tb::False, tb::False, tb::False, tb::False, tb::False> {
@@ -607,6 +622,18 @@ impl<D: tb::Bool, H: tb::Bool, T: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Boo
 		}
 		self
 	}
+
+	/// Sets the RGB amount.
+	pub fn rgb_amount(mut self, rgb_amount: u64) -> Self {
+		self.tagged_fields.push(TaggedField::RgbAmount(RgbAmount(rgb_amount)));
+		self
+	}
+
+	/// Sets the RGB contract ID.
+	pub fn rgb_contract_id(mut self, rgb_contract_id: ContractId) -> Self {
+		self.tagged_fields.push(TaggedField::RgbContractId(RgbContractId(rgb_contract_id)));
+		self
+	}
 }
 
 impl<D: tb::Bool, H: tb::Bool, C: tb::Bool, S: tb::Bool, M: tb::Bool> InvoiceBuilder<D, H, tb::True, C, S, M> {
@@ -1065,6 +1092,14 @@ impl RawBolt11Invoice {
 		find_extract!(self.known_tagged_fields(), TaggedField::Features(ref x), x)
 	}
 
+	pub fn rgb_amount(&self) -> Option<&RgbAmount> {
+		find_extract!(self.known_tagged_fields(), TaggedField::RgbAmount(ref x), x)
+	}
+
+	pub fn rgb_contract_id(&self) -> Option<&RgbContractId> {
+		find_extract!(self.known_tagged_fields(), TaggedField::RgbContractId(ref x), x)
+	}
+
 	/// This is not exported to bindings users as we don't support Vec<&NonOpaqueType>
 	pub fn fallbacks(&self) -> Vec<&Fallback> {
 		find_all_extract!(self.known_tagged_fields(), TaggedField::Fallback(ref x), x).collect()
@@ -1483,6 +1518,18 @@ impl Bolt11Invoice {
 	fn amount_pico_btc(&self) -> Option<u64> {
 		self.signed_invoice.amount_pico_btc()
 	}
+
+	/// Returns the invoice's `rgb_amount` if present
+	pub fn rgb_amount(&self) -> Option<u64> {
+		self.signed_invoice.rgb_amount()
+			.map(|x| x.0)
+	}
+
+	/// Returns the invoice's `rgb_contract_id` if present
+	pub fn rgb_contract_id(&self) -> Option<ContractId> {
+		self.signed_invoice.rgb_contract_id()
+			.map(|x| x.0)
+	}
 }
 
 impl From<TaggedField> for RawTaggedField {
@@ -1506,6 +1553,8 @@ impl TaggedField {
 			TaggedField::PaymentSecret(_) => constants::TAG_PAYMENT_SECRET,
 			TaggedField::PaymentMetadata(_) => constants::TAG_PAYMENT_METADATA,
 			TaggedField::Features(_) => constants::TAG_FEATURES,
+			TaggedField::RgbAmount(_) => constants::TAG_RGB_AMOUNT,
+			TaggedField::RgbContractId(_) => constants::TAG_RGB_CONTRACT_ID,
 		};
 
 		u5::try_from_u8(tag).expect("all tags defined are <32")

lightning-invoice/src/ser.rs

@@ -4,7 +4,7 @@ use bech32::{ToBase32, u5, WriteBase32, Base32Len};
 use crate::prelude::*;
 
 use super::{Bolt11Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiryDelta, Fallback, PayeePubKey, Bolt11InvoiceSignature, PositiveTimestamp,
-	PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawBolt11Invoice, RawDataPart};
+	PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, constants, SignedRawBolt11Invoice, RawDataPart, RgbAmount, RgbContractId};
 
 /// Converts a stream of bytes written to it to base32. On finalization the according padding will
 /// be applied. That means the results of writing two data blocks with one or two `BytesToBase32`
@@ -399,6 +399,30 @@ impl Base32Len for PrivateRoute {
 	}
 }
 
+impl ToBase32 for RgbAmount {
+	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
+		writer.write(&encode_int_be_base32(self.0))
+	}
+}
+
+impl Base32Len for RgbAmount {
+	fn base32_len(&self) -> usize {
+		encoded_int_be_base32_size(self.0)
+	}
+}
+
+impl ToBase32 for RgbContractId {
+	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
+		self.0.to_string().as_bytes().write_base32(writer)
+	}
+}
+
+impl Base32Len for RgbContractId {
+	fn base32_len(&self) -> usize {
+		self.0.to_string().as_bytes().base32_len()
+	}
+}
+
 impl ToBase32 for TaggedField {
 	fn write_base32<W: WriteBase32>(&self, writer: &mut W) -> Result<(), <W as WriteBase32>::Err> {
 		/// Writes a tagged field: tag, length and data. `tag` should be in `0..32` otherwise the
@@ -452,6 +476,12 @@ impl ToBase32 for TaggedField {
 			TaggedField::Features(ref features) => {
 				write_tagged_field(writer, constants::TAG_FEATURES, features)
 			},
+			TaggedField::RgbAmount(ref rgb_amount) => {
+				write_tagged_field(writer, constants::TAG_RGB_AMOUNT, rgb_amount)
+			},
+			TaggedField::RgbContractId(ref rgb_contract_id) => {
+				write_tagged_field(writer, constants::TAG_RGB_CONTRACT_ID, rgb_contract_id)
+			},
 		}
 	}
 }

lightning-rapid-gossip-sync/src/processing.rs

@@ -375,6 +375,7 @@ where
 				cltv_expiry_delta: default_cltv_expiry_delta,
 				htlc_minimum_msat: default_htlc_minimum_msat,
 				htlc_maximum_msat: default_htlc_maximum_msat,
+				htlc_maximum_rgb: 0, // unused message in RLN, so this value is irrelevant
 				fee_base_msat: default_fee_base_msat,
 				fee_proportional_millionths: default_fee_proportional_millionths,
 				excess_data: Vec::new(),

lightning-types/src/payment.rs

@@ -37,6 +37,13 @@ impl_fmt_traits! {
 	}
 }
 
+impl PaymentHash {
+	/// Create a payment hash consisting of all-zeros data (e.g. when uninitialized or a placeholder).
+	pub fn new_zero() -> Self {
+		Self([0; 32])
+	}
+}
+
 /// The payment preimage is the "secret key" which is used to claim the funds of an HTLC on-chain
 /// or in a lightning channel.
 ///

lightning-types/src/routing.rs

@@ -47,4 +47,6 @@ pub struct RouteHintHop {
 	pub htlc_minimum_msat: Option<u64>,
 	/// The maximum value in msat available for routing with a single HTLC.
 	pub htlc_maximum_msat: Option<u64>,
+	/// The maximum RGB value available for routing with a single HTLC.
+	pub htlc_maximum_rgb: Option<u64>,
 }

lightning/Cargo.toml

@@ -51,6 +51,21 @@ backtrace = { version = "0.3", optional = true }
 
 libm = { version = "0.2", optional = true, default-features = false }
 
+# RGB and related
+futures = "0.3"
+rgb-lib = { version = "0.3.0-alpha.11", features = [
+    "electrum",
+    "esplora",
+], git = "https://github.com/RGB-Tools/rgb-lib.git", rev = "952cd185" }
+serde = { version = "^1.0", features = [
+    "derive",
+] }
+serde_json = "^1.0"
+tokio = { version = "1.14.1", features = [
+    "macros",
+    "rt-multi-thread",
+] }
+
 [dev-dependencies]
 regex = "1.5.6"
 lightning-types = { version = "0.1.0", path = "../lightning-types", features = ["_test_utils"] }