use crate::convert::{
- BlockchainInfo, FeeResponse, FundedTx, MempoolMinFeeResponse, NewAddress, RawTx, SignedTx,
+ BlockchainInfo, FeeResponse, FundedTx, ListUnspentResponse, MempoolMinFeeResponse, NewAddress,
+ RawTx, SignedTx,
};
use crate::disk::FilesystemLogger;
+use crate::hex_utils;
use base64;
+use bitcoin::blockdata::constants::WITNESS_SCALE_FACTOR;
use bitcoin::blockdata::transaction::Transaction;
-use bitcoin::consensus::encode;
+use bitcoin::consensus::{encode, Decodable, Encodable};
use bitcoin::hash_types::{BlockHash, Txid};
-use bitcoin::util::address::Address;
+use bitcoin::hashes::Hash;
+use bitcoin::util::address::{Address, Payload, WitnessVersion};
+use bitcoin::{OutPoint, Script, TxOut, WPubkeyHash, XOnlyPublicKey};
use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
+use lightning::events::bump_transaction::{Utxo, WalletSource};
use lightning::log_error;
use lightning::routing::utxo::{UtxoLookup, UtxoResult};
use lightning::util::logger::Logger;
.await
.unwrap()
}
+
+ pub async fn list_unspent(&self) -> ListUnspentResponse {
+ self.bitcoind_rpc_client
+ .call_method::<ListUnspentResponse>("listunspent", &vec![])
+ .await
+ .unwrap()
+ }
}
impl FeeEstimator for BitcoindClient {
todo!();
}
}
+
+impl WalletSource for BitcoindClient {
+ fn list_confirmed_utxos(&self) -> Result<Vec<Utxo>, ()> {
+ let utxos = tokio::task::block_in_place(move || {
+ self.handle.block_on(async move { self.list_unspent().await }).0
+ });
+ Ok(utxos
+ .into_iter()
+ .filter_map(|utxo| {
+ let outpoint = OutPoint { txid: utxo.txid, vout: utxo.vout };
+ match utxo.address.payload {
+ Payload::WitnessProgram { version, ref program } => match version {
+ WitnessVersion::V0 => WPubkeyHash::from_slice(program)
+ .map(|wpkh| Utxo::new_v0_p2wpkh(outpoint, utxo.amount, &wpkh))
+ .ok(),
+ // TODO: Add `Utxo::new_v1_p2tr` upstream.
+ WitnessVersion::V1 => XOnlyPublicKey::from_slice(program)
+ .map(|_| Utxo {
+ outpoint,
+ output: TxOut {
+ value: utxo.amount,
+ script_pubkey: Script::new_witness_program(version, program),
+ },
+ satisfaction_weight: 1 /* empty script_sig */ * WITNESS_SCALE_FACTOR as u64 +
+ 1 /* witness items */ + 1 /* schnorr sig len */ + 64, /* schnorr sig */
+ })
+ .ok(),
+ _ => None,
+ },
+ _ => None,
+ }
+ })
+ .collect())
+ }
+
+ fn get_change_script(&self) -> Result<Script, ()> {
+ tokio::task::block_in_place(move || {
+ Ok(self.handle.block_on(async move { self.get_new_address().await.script_pubkey() }))
+ })
+ }
+
+ fn sign_tx(&self, tx: Transaction) -> Result<Transaction, ()> {
+ let mut tx_bytes = Vec::new();
+ let _ = tx.consensus_encode(&mut tx_bytes).map_err(|_| ());
+ let tx_hex = hex_utils::hex_str(&tx_bytes);
+ let signed_tx = tokio::task::block_in_place(move || {
+ self.handle.block_on(async move { self.sign_raw_transaction_with_wallet(tx_hex).await })
+ });
+ let signed_tx_bytes = hex_utils::to_vec(&signed_tx.hex).ok_or(())?;
+ Transaction::consensus_decode(&mut signed_tx_bytes.as_slice()).map_err(|_| ())
+ }
+}
let peer_pubkey_and_ip_addr = words.next();
let channel_value_sat = words.next();
if peer_pubkey_and_ip_addr.is_none() || channel_value_sat.is_none() {
- println!("ERROR: openchannel has 2 required arguments: `openchannel pubkey@host:port channel_amt_satoshis` [--public]");
+ println!("ERROR: openchannel has 2 required arguments: `openchannel pubkey@host:port channel_amt_satoshis` [--public] [--with-anchors]");
continue;
}
let peer_pubkey_and_ip_addr = peer_pubkey_and_ip_addr.unwrap();
continue;
};
- let announce_channel = match words.next() {
- Some("--public") | Some("--public=true") => true,
- Some("--public=false") => false,
- Some(_) => {
- println!("ERROR: invalid `--public` command format. Valid formats: `--public`, `--public=true` `--public=false`");
- continue;
+ let (mut announce_channel, mut with_anchors) = (false, false);
+ while let Some(word) = words.next() {
+ match word {
+ "--public" | "--public=true" => announce_channel = true,
+ "--public=false" => announce_channel = false,
+ "--with-anchors" | "--with-anchors=true" => with_anchors = true,
+ "--with-anchors=false" => with_anchors = false,
+ _ => {
+ println!("ERROR: invalid boolean flag format. Valid formats: `--option`, `--option=true` `--option=false`");
+ continue;
+ }
}
- None => false,
- };
+ }
if open_channel(
pubkey,
chan_amt_sat.unwrap(),
announce_channel,
+ with_anchors,
channel_manager.clone(),
)
.is_ok()
"listpeers" => list_peers(peer_manager.clone()),
"signmessage" => {
const MSG_STARTPOS: usize = "signmessage".len() + 1;
- if line.as_bytes().len() <= MSG_STARTPOS {
+ if line.trim().as_bytes().len() <= MSG_STARTPOS {
println!("ERROR: signmsg requires a message");
continue;
}
println!(
"{:?}",
lightning::util::message_signing::sign(
- &line.as_bytes()[MSG_STARTPOS..],
+ &line.trim().as_bytes()[MSG_STARTPOS..],
&keys_manager.get_node_secret_key()
)
);
println!(" help\tShows a list of commands.");
println!(" quit\tClose the application.");
println!("\n Channels:");
- println!(" openchannel pubkey@host:port <amt_satoshis> [--public]");
+ println!(" openchannel pubkey@host:port <amt_satoshis> [--public] [--with-anchors]");
println!(" closechannel <channel_id> <peer_pubkey>");
println!(" forceclosechannel <channel_id> <peer_pubkey>");
println!(" listchannels");
}
fn open_channel(
- peer_pubkey: PublicKey, channel_amt_sat: u64, announced_channel: bool,
+ peer_pubkey: PublicKey, channel_amt_sat: u64, announced_channel: bool, with_anchors: bool,
channel_manager: Arc<ChannelManager>,
) -> Result<(), ()> {
let config = UserConfig {
},
channel_handshake_config: ChannelHandshakeConfig {
announced_channel,
+ negotiate_anchors_zero_fee_htlc_tx: with_anchors,
..Default::default()
},
..Default::default()
use bitcoin::hashes::hex::FromHex;
-use bitcoin::BlockHash;
+use bitcoin::{Address, BlockHash, Txid};
use lightning_block_sync::http::JsonResponse;
use std::convert::TryInto;
+use std::str::FromStr;
pub struct FundedTx {
pub changepos: i64,
})
}
}
+
+pub struct ListUnspentUtxo {
+ pub txid: Txid,
+ pub vout: u32,
+ pub amount: u64,
+ pub address: Address,
+}
+
+pub struct ListUnspentResponse(pub Vec<ListUnspentUtxo>);
+
+impl TryInto<ListUnspentResponse> for JsonResponse {
+ type Error = std::io::Error;
+ fn try_into(self) -> Result<ListUnspentResponse, Self::Error> {
+ let utxos = self
+ .0
+ .as_array()
+ .unwrap()
+ .iter()
+ .map(|utxo| ListUnspentUtxo {
+ txid: Txid::from_str(&utxo["txid"].as_str().unwrap().to_string()).unwrap(),
+ vout: utxo["vout"].as_u64().unwrap() as u32,
+ amount: bitcoin::Amount::from_btc(utxo["amount"].as_f64().unwrap())
+ .unwrap()
+ .to_sat(),
+ address: Address::from_str(&utxo["address"].as_str().unwrap().to_string()).unwrap(),
+ })
+ .collect();
+ Ok(ListUnspentResponse(utxos))
+ }
+}
use disk::{INBOUND_PAYMENTS_FNAME, OUTBOUND_PAYMENTS_FNAME};
use lightning::chain::{chainmonitor, ChannelMonitorUpdateStatus};
use lightning::chain::{Filter, Watch};
+use lightning::events::bump_transaction::{BumpTransactionEventHandler, Wallet};
use lightning::events::{Event, PaymentFailureReason, PaymentPurpose};
use lightning::ln::channelmanager::{self, RecentPaymentDetails};
use lightning::ln::channelmanager::{
type OnionMessenger = SimpleArcOnionMessenger<FilesystemLogger>;
+pub(crate) type BumpTxEventHandler = BumpTransactionEventHandler<
+ Arc<BitcoindClient>,
+ Arc<Wallet<Arc<BitcoindClient>, Arc<FilesystemLogger>>>,
+ Arc<KeysManager>,
+ Arc<FilesystemLogger>,
+>;
+
async fn handle_ldk_events(
channel_manager: &Arc<ChannelManager>, bitcoind_client: &BitcoindClient,
network_graph: &NetworkGraph, keys_manager: &KeysManager,
- inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
+ bump_tx_event_handler: &BumpTxEventHandler, inbound_payments: Arc<Mutex<PaymentInfoStorage>>,
outbound_payments: Arc<Mutex<PaymentInfoStorage>>, persister: &Arc<FilesystemPersister>,
network: Network, event: Event,
) {
}
persister.persist(OUTBOUND_PAYMENTS_FNAME, &*outbound).unwrap();
}
- Event::OpenChannelRequest { .. } => {
- // Unreachable, we don't set manually_accept_inbound_channels
+ Event::OpenChannelRequest {
+ ref temporary_channel_id, ref counterparty_node_id, ..
+ } => {
+ let mut random_bytes = [0u8; 16];
+ random_bytes.copy_from_slice(&keys_manager.get_secure_random_bytes()[..16]);
+ let user_channel_id = u128::from_be_bytes(random_bytes);
+ let res = channel_manager.accept_inbound_channel(
+ temporary_channel_id,
+ counterparty_node_id,
+ user_channel_id,
+ );
+
+ if let Err(e) = res {
+ print!(
+ "\nEVENT: Failed to accept inbound channel ({}) from {}: {:?}",
+ hex_utils::hex_str(&temporary_channel_id[..]),
+ hex_utils::hex_str(&counterparty_node_id.serialize()),
+ e,
+ );
+ } else {
+ print!(
+ "\nEVENT: Accepted inbound channel ({}) from {}",
+ hex_utils::hex_str(&temporary_channel_id[..]),
+ hex_utils::hex_str(&counterparty_node_id.serialize()),
+ );
+ }
+ print!("> ");
+ io::stdout().flush().unwrap();
}
Event::PaymentPathSuccessful { .. } => {}
Event::PaymentPathFailed { .. } => {}
// the funding transaction either confirms, or this event is generated.
}
Event::HTLCIntercepted { .. } => {}
- Event::BumpTransaction(_) => {}
+ Event::BumpTransaction(event) => bump_tx_event_handler.handle_event(&event),
}
}
let cur = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
let keys_manager = Arc::new(KeysManager::new(&keys_seed, cur.as_secs(), cur.subsec_nanos()));
+ let bump_tx_event_handler = Arc::new(BumpTransactionEventHandler::new(
+ Arc::clone(&broadcaster),
+ Arc::new(Wallet::new(Arc::clone(&bitcoind_client), Arc::clone(&logger))),
+ Arc::clone(&keys_manager),
+ Arc::clone(&logger),
+ ));
+
// Step 7: Read ChannelMonitor state from disk
let mut channelmonitors =
persister.read_channelmonitors(keys_manager.clone(), keys_manager.clone()).unwrap();
// Step 11: Initialize the ChannelManager
let mut user_config = UserConfig::default();
user_config.channel_handshake_limits.force_announced_channel_preference = false;
+ user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true;
+ user_config.manually_accept_inbound_channels = true;
let mut restarting_node = true;
let (channel_manager_blockhash, channel_manager) = {
if let Ok(mut f) = fs::File::open(format!("{}/manager", ldk_data_dir.clone())) {
let bitcoind_client_event_listener = Arc::clone(&bitcoind_client_event_listener);
let network_graph_event_listener = Arc::clone(&network_graph_event_listener);
let keys_manager_event_listener = Arc::clone(&keys_manager_event_listener);
+ let bump_tx_event_handler = Arc::clone(&bump_tx_event_handler);
let inbound_payments_event_listener = Arc::clone(&inbound_payments_event_listener);
let outbound_payments_event_listener = Arc::clone(&outbound_payments_event_listener);
let persister_event_listener = Arc::clone(&persister_event_listener);
&bitcoind_client_event_listener,
&network_graph_event_listener,
&keys_manager_event_listener,
+ &bump_tx_event_handler,
inbound_payments_event_listener,
outbound_payments_event_listener,
&persister_event_listener,