implement RGB channels

Author: zoedberg

lightning-invoice/Cargo.toml

@@ -26,7 +26,12 @@ secp256k1 = { version = "0.24.0", default-features = false, features = ["recover
 num-traits = { version = "0.2.8", default-features = false }
 bitcoin_hashes = { version = "0.11", default-features = false }
 hashbrown = { version = "0.8", optional = true }
-serde = { version = "1.0.118", optional = true }
+
+# RGB and related
+hex = "0.4"
+rgb-std = "0.9.0"
+serde = { version = "1.0.118" }
+serde_json = { version = "1"}
 
 [dev-dependencies]
 lightning = { version = "0.0.113", path = "../lightning", default-features = false, features = ["_test_utils"] }

lightning-invoice/src/lib.rs

@@ -26,6 +26,7 @@
 compile_error!("at least one of the `std` or `no-std` features must be enabled");
 
 pub mod payment;
+pub mod rgb_utils;
 pub mod utils;
 
 pub(crate) mod time_utils;

lightning-invoice/src/payment.rs

@@ -141,6 +141,7 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
+use crate::rgb_utils::{filter_first_hops, write_rgb_payment_info_file};
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
@@ -150,6 +151,8 @@ use lightning::util::logger::Logger;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
+use rgb::ContractId;
+
 use secp256k1::PublicKey;
 
 use core::fmt;
@@ -158,6 +161,8 @@ use core::future::Future;
 use core::ops::Deref;
 use core::time::Duration;
 #[cfg(feature = "std")]
+use std::path::PathBuf;
+#[cfg(feature = "std")]
 use std::time::SystemTime;
 
 /// A utility for paying [`Invoice`]s and sending spontaneous payments.
@@ -199,6 +204,7 @@ pub struct InvoicePayerUsingTime<
 	/// Caches the overall attempts at making a payment, which is updated prior to retrying.
 	payment_cache: Mutex<HashMap<PaymentHash, PaymentAttempts<T>>>,
 	retry: Retry,
+	ldk_data_dir: PathBuf,
 }
 
 /// Storing minimal payment attempts information required for determining if a outbound payment can
@@ -327,7 +333,7 @@ where
 	/// Will forward any [`Event::PaymentPathFailed`] events to the decorated `event_handler` once
 	/// `retry` has been exceeded for a given [`Invoice`].
 	pub fn new(
-		payer: P, router: R, logger: L, event_handler: E, retry: Retry
+		payer: P, router: R, logger: L, event_handler: E, retry: Retry, ldk_data_dir: PathBuf
 	) -> Self {
 		Self {
 			payer,
@@ -336,6 +342,7 @@ where
 			event_handler,
 			payment_cache: Mutex::new(HashMap::new()),
 			retry,
+			ldk_data_dir,
 		}
 	}
 
@@ -448,10 +455,11 @@ where
 	/// ensure that a second payment with the same [`PaymentPreimage`] is never sent.
 	pub fn pay_pubkey(
 		&self, pubkey: PublicKey, payment_preimage: PaymentPreimage, amount_msats: u64,
-		final_cltv_expiry_delta: u32
+		final_cltv_expiry_delta: u32, contract_id: ContractId, amount_rgb: u64
 	) -> Result<PaymentId, PaymentError> {
 		let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
 		let payment_id = PaymentId(payment_hash.0);
+		write_rgb_payment_info_file(&self.ldk_data_dir, &payment_hash, contract_id, amount_rgb);
 		self.do_pay_pubkey(pubkey, payment_preimage, payment_hash, payment_id, amount_msats,
 				final_cltv_expiry_delta)
 			.map(|()| payment_id)
@@ -467,9 +475,10 @@ where
 	/// [`PaymentHash`] has never been paid before.
 	pub fn pay_pubkey_with_id(
 		&self, pubkey: PublicKey, payment_preimage: PaymentPreimage, payment_id: PaymentId,
-		amount_msats: u64, final_cltv_expiry_delta: u32
+		amount_msats: u64, final_cltv_expiry_delta: u32, contract_id: ContractId, amount_rgb: u64
 	) -> Result<(), PaymentError> {
 		let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
+		write_rgb_payment_info_file(&self.ldk_data_dir, &payment_hash, contract_id, amount_rgb);
 		self.do_pay_pubkey(pubkey, payment_preimage, payment_hash, payment_id, amount_msats,
 				final_cltv_expiry_delta)
 	}
@@ -507,10 +516,11 @@ where
 		}
 
 		let payer = self.payer.node_id();
-		let first_hops = self.payer.first_hops();
+		let mut first_hops = self.payer.first_hops();
+		let contract_id = filter_first_hops(&self.ldk_data_dir, &payment_hash, &mut first_hops);
 		let inflight_htlcs = self.payer.inflight_htlcs();
 		let route = self.router.find_route(
-			&payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
+			&payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs, contract_id
 		).map_err(|e| PaymentError::Routing(e))?;
 
 		match send_payment(&route) {
@@ -574,11 +584,12 @@ where
 		}
 
 		let payer = self.payer.node_id();
-		let first_hops = self.payer.first_hops();
+		let mut first_hops = self.payer.first_hops();
+		let contract_id = filter_first_hops(&self.ldk_data_dir, &payment_hash, &mut first_hops);
 		let inflight_htlcs = self.payer.inflight_htlcs();
 
 		let route = self.router.find_route(
-			&payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
+			&payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs, contract_id
 		);
 
 		if route.is_err() {
@@ -727,6 +738,7 @@ where
 	}
 }
 
+/*
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -2307,3 +2319,4 @@ mod tests {
 		assert!(expected_events.borrow().is_empty());
 	}
 }
+*/

lightning-invoice/src/rgb_utils.rs

@@ -0,0 +1,44 @@
+//! A module to provide RGB functionality
+
+use lightning::ln::PaymentHash;
+use lightning::ln::channelmanager::ChannelDetails;
+use lightning::rgb_utils::{RgbInfo, RgbPaymentInfo};
+
+use rgb::ContractId;
+
+#[cfg(feature = "std")]
+use std::fs;
+#[cfg(feature = "std")]
+use std::path::PathBuf;
+
+/// Write RGB payment info to file
+pub(crate) fn write_rgb_payment_info_file(ldk_data_dir: &PathBuf, payment_hash: &PaymentHash, contract_id: ContractId, amount_rgb: u64) {
+	let rgb_payment_info_path = ldk_data_dir.clone().join(hex::encode(payment_hash.0));
+	let rgb_payment_info = RgbPaymentInfo {
+		contract_id,
+		amount: amount_rgb,
+		local_rgb_amount: 0,
+		remote_rgb_amount: 0,
+	};
+	let serialized_info = serde_json::to_string(&rgb_payment_info).expect("valid rgb payment info");
+	std::fs::write(rgb_payment_info_path, serialized_info).expect("able to write rgb payment info file");
+}
+
+
+/// Filter first_hops for contract_id
+pub(crate) fn filter_first_hops(ldk_data_dir: &PathBuf, payment_hash: &PaymentHash, first_hops: &mut Vec<ChannelDetails>) -> ContractId {
+	let rgb_payment_info_path = ldk_data_dir.join(hex::encode(payment_hash.0));
+	let serialized_info = fs::read_to_string(rgb_payment_info_path).expect("valid rgb payment info file");
+	let rgb_payment_info: RgbPaymentInfo = serde_json::from_str(&serialized_info).expect("valid rgb payment info file");
+	let contract_id = rgb_payment_info.contract_id;
+	first_hops.retain(|h| {
+		let info_file_path = ldk_data_dir.join(hex::encode(&h.channel_id));
+		if !info_file_path.exists() {
+			return false
+		}
+		let serialized_info = fs::read_to_string(info_file_path).expect("valid rgb info file");
+		let rgb_info: RgbInfo = serde_json::from_str(&serialized_info).expect("valid rgb info file");
+		rgb_info.contract_id == contract_id.clone()
+	});
+	contract_id
+}

lightning-persister/src/lib.rs

@@ -95,7 +95,7 @@ impl FilesystemPersister {
 				));
 			}
 
-			let index = filename.unwrap().split_at(65).1.parse();
+			let index: Result<u16, _> = filename.unwrap().split_at(65).1.parse();
 			if index.is_err() {
 				return Err(std::io::Error::new(
 					std::io::ErrorKind::InvalidData,

lightning/Cargo.toml

@@ -17,7 +17,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 # Internal test utilities exposed to other repo crates
-_test_utils = ["hex", "regex", "bitcoin/bitcoinconsensus"]
+_test_utils = ["regex", "bitcoin/bitcoinconsensus"]
 # Unlog messages superior at targeted level.
 max_level_off = []
 max_level_error = []
@@ -42,12 +42,32 @@ default = ["std", "grind_signatures"]
 bitcoin = { version = "0.29.0", default-features = false, features = ["secp-recovery"] }
 
 hashbrown = { version = "0.8", optional = true }
-hex = { version = "0.4", optional = true }
 regex = { version = "1.5.6", optional = true }
 backtrace = { version = "0.3", optional = true }
 
 core2 = { version = "0.3.0", optional = true, default-features = false }
 
+# RGB and related
+amplify = "3.13.0"
+base64 = "0.13.0"
+bp-core = { version = "0.9.0", features = ["psbt", "wallet"] }
+commit_verify = "0.9.0"
+futures = "0.3"
+hex = { version = "0.4" }
+internet2 = "0.9.0"
+lnpbp = "0.9.0"
+lnpbp-invoice = { version = "0.9.0", features = ["rgb"] }
+psbt = "0.9.0"
+reqwest = { version = "0.11", default-features = false, features = ["json", "blocking"] }
+rgb-std = "0.9.0"
+rgb20 = "0.9.0"
+rgb_core = { package = "rgb-core", version = "0.9.0" }
+rgb_rpc = "0.9.1"
+serde = { version = "^1.0", features = ["derive"] }
+serde_json = { version = "^1.0" }
+strict_encoding = "0.9.0"
+tokio = { version = "1.14.1", features = ["macros", "rt-multi-thread"] }
+
 [dev-dependencies]
 hex = "0.4"
 regex = "1.5.6"

lightning/src/chain/channelmonitor.rs

@@ -57,6 +57,7 @@ use crate::util::events::{AnchorDescriptor, HTLCDescriptor, BumpTransactionEvent
 
 use crate::prelude::*;
 use core::{cmp, mem};
+use std::path::PathBuf;
 use crate::io::{self, Error};
 use core::convert::TryInto;
 use core::ops::Deref;
@@ -1104,7 +1105,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 	                  funding_redeemscript: Script, channel_value_satoshis: u64,
 	                  commitment_transaction_number_obscure_factor: u64,
 	                  initial_holder_commitment_tx: HolderCommitmentTransaction,
-	                  best_block: BestBlock, counterparty_node_id: PublicKey) -> ChannelMonitor<Signer> {
+	                  best_block: BestBlock, counterparty_node_id: PublicKey, ldk_data_dir: PathBuf) -> ChannelMonitor<Signer> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
 		let payment_key_hash = WPubkeyHash::hash(&keys.pubkeys().payment_point.serialize());
@@ -1140,7 +1141,7 @@ impl<Signer: Sign> ChannelMonitor<Signer> {
 
 		let onchain_tx_handler =
 			OnchainTxHandler::new(destination_script.clone(), keys,
-			channel_parameters.clone(), initial_holder_commitment_tx, secp_ctx.clone());
+			channel_parameters.clone(), initial_holder_commitment_tx, secp_ctx.clone(), ldk_data_dir);
 
 		let mut outputs_to_watch = HashMap::new();
 		outputs_to_watch.insert(funding_info.0.txid, vec![(funding_info.0.index as u32, funding_info.1.clone())]);
@@ -3770,9 +3771,10 @@ impl<'a, K: KeysInterface> ReadableArgs<&'a K>
 					let cltv_expiry: u32 = Readable::read(reader)?;
 					let payment_hash: PaymentHash = Readable::read(reader)?;
 					let transaction_output_index: Option<u32> = Readable::read(reader)?;
+					let amount_rgb: u64 = Readable::read(reader)?;
 
 					HTLCOutputInCommitment {
-						offered, amount_msat, cltv_expiry, payment_hash, transaction_output_index
+						offered, amount_msat, cltv_expiry, payment_hash, transaction_output_index, amount_rgb
 					}
 				}
 			}