fn encode(&self) -> Vec<u8>;
#[inline]
fn encoded_len(&self) -> usize { self.encode().len() }
+ #[inline]
+ fn encode_with_len(&self) -> Vec<u8> {
+ let enc = self.encode();
+ let mut res = Vec::with_capacity(enc.len() + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(enc.len() as u16));
+ res.extend_from_slice(&enc);
+ res
+ }
}
#[derive(Debug)]
pub enum DecodeError {
self.flags.len() > 0 && (self.flags[0] & 1) != 0
}
- pub fn supports_initial_routing_sync(&self) -> bool {
+ pub fn initial_routing_sync(&self) -> bool {
self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
}
+ pub fn set_initial_routing_sync(&mut self) {
+ if self.flags.len() == 0 {
+ self.flags.resize(1, 1 << 3);
+ } else {
+ self.flags[0] |= 1 << 3;
+ }
+ }
pub fn supports_upfront_shutdown_script(&self) -> bool {
self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
pub local_features: LocalFeatures,
}
+pub struct Ping {
+ pub ponglen: u16,
+ pub byteslen: u16,
+}
+
+pub struct Pong {
+ pub byteslen: u16,
+}
+
pub struct OpenChannel {
pub chain_hash: Sha256dHash,
pub temporary_channel_id: Uint256,
msg: UpdateFailHTLC
},
/// The peer took some action which made us think they were useless. Disconnect them.
- DisconnectPeer {},
+ DisconnectPeer,
+ /// The peer did something harmless that we weren't able to process, just log and ignore
+ IgnoreError,
}
pub struct HandleError { //TODO: rename me
pub commitment_signed: CommitmentSigned,
}
+pub enum HTLCFailChannelUpdate {
+ ChannelUpdateMessage {
+ msg: ChannelUpdate,
+ },
+ ChannelClosed {
+ short_channel_id: u64,
+ },
+}
+
/// A trait to describe an object which can receive channel messages. Messages MAY be called in
/// paralell when they originate from different their_node_ids, however they MUST NOT be called in
/// paralell when the two calls have the same their_node_id.
-pub trait ChannelMessageHandler : events::EventsProvider {
+pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync {
//Channel init:
fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result<AcceptChannel, HandleError>;
fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>;
// HTLC handling:
fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC) -> Result<(), HandleError>;
fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>;
- fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<(), HandleError>;
+ fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<Option<HTLCFailChannelUpdate>, HandleError>;
fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>;
fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option<CommitmentSigned>), HandleError>;
fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result<Option<CommitmentUpdate>, HandleError>;
fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
}
-pub trait RoutingMessageHandler {
+pub trait RoutingMessageHandler : Send + Sync {
fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<(), HandleError>;
/// Handle a channel_announcement message, returning true if it should be forwarded on, false
/// or returning an Err otherwise.
fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, HandleError>;
fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<(), HandleError>;
+ fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate);
}
pub struct OnionRealm0HopData {
impl MsgDecodable for LocalFeatures {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 3 { return Err(DecodeError::WrongLength); }
+ if v.len() < 2 { return Err(DecodeError::WrongLength); }
let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
if v.len() < len + 2 { return Err(DecodeError::WrongLength); }
let mut flags = Vec::with_capacity(len);
impl MsgDecodable for GlobalFeatures {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
- if v.len() < 3 { return Err(DecodeError::WrongLength); }
+ if v.len() < 2 { return Err(DecodeError::WrongLength); }
let len = byte_utils::slice_to_be16(&v[0..2]) as usize;
if v.len() < len + 2 { return Err(DecodeError::WrongLength); }
let mut flags = Vec::with_capacity(len);
}
}
+impl MsgDecodable for Ping {
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 4 {
+ return Err(DecodeError::WrongLength);
+ }
+ let ponglen = byte_utils::slice_to_be16(&v[0..2]);
+ let byteslen = byte_utils::slice_to_be16(&v[2..4]);
+ if v.len() < 4 + byteslen as usize {
+ return Err(DecodeError::WrongLength);
+ }
+ Ok(Self {
+ ponglen,
+ byteslen,
+ })
+ }
+}
+impl MsgEncodable for Ping {
+ fn encode(&self) -> Vec<u8> {
+ let mut res = Vec::with_capacity(self.byteslen as usize + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
+ res.resize(2 + self.byteslen as usize, 0);
+ res
+ }
+}
+
+impl MsgDecodable for Pong {
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 2 {
+ return Err(DecodeError::WrongLength);
+ }
+ let byteslen = byte_utils::slice_to_be16(&v[0..2]);
+ if v.len() < 2 + byteslen as usize {
+ return Err(DecodeError::WrongLength);
+ }
+ Ok(Self {
+ byteslen
+ })
+ }
+}
+impl MsgEncodable for Pong {
+ fn encode(&self) -> Vec<u8> {
+ let mut res = Vec::with_capacity(self.byteslen as usize + 2);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen));
+ res.resize(2 + self.byteslen as usize, 0);
+ res
+ }
+}
+
impl MsgDecodable for OpenChannel {
fn decode(v: &[u8]) -> Result<Self, DecodeError> {
if v.len() < 2*32+6*8+4+2*2+6*33+1 {
}
impl MsgEncodable for OpenChannel {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = match &self.shutdown_scriptpubkey {
+ &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()),
+ &None => Vec::with_capacity(319),
+ };
+ res.extend_from_slice(&serialize(&self.chain_hash).unwrap());
+ res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat));
+ res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs));
+ res.extend_from_slice(&self.funding_pubkey.serialize());
+ res.extend_from_slice(&self.revocation_basepoint.serialize());
+ res.extend_from_slice(&self.payment_basepoint.serialize());
+ res.extend_from_slice(&self.delayed_payment_basepoint.serialize());
+ res.extend_from_slice(&self.htlc_basepoint.serialize());
+ res.extend_from_slice(&self.first_per_commitment_point.serialize());
+ res.push(self.channel_flags);
+ if let &Some(ref script) = &self.shutdown_scriptpubkey {
+ res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16));
+ res.extend_from_slice(&script[..]);
+ }
+ res
}
}
}
impl MsgEncodable for FundingSigned {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+64);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps()));
+ res
}
}
amount_msat: byte_utils::slice_to_be64(&v[40..48]),
payment_hash,
cltv_expiry: byte_utils::slice_to_be32(&v[80..84]),
- onion_routing_packet: OnionPacket::decode(&v[84..])?,
+ onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?,
})
}
}
impl MsgEncodable for UpdateAddHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+8+32+4+1+1366);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
+ res.extend_from_slice(&self.payment_hash);
+ res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry));
+ res.extend_from_slice(&self.onion_routing_packet.encode()[..]);
+ res
}
}
}
impl MsgEncodable for UpdateFulfillHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+32);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&self.payment_preimage);
+ res
}
}
}
impl MsgEncodable for UpdateFailHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let reason = self.reason.encode();
+ let mut res = Vec::with_capacity(32+8+reason.len());
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&reason[..]);
+ res
}
}
}
impl MsgEncodable for UpdateFailMalformedHTLC {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+8+32+2);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
+ res.extend_from_slice(&self.sha256_of_onion);
+ res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code));
+ res
}
}
}
impl MsgEncodable for CommitmentSigned {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ let secp_ctx = Secp256k1::without_caps();
+ res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16));
+ for i in 0..self.htlc_signatures.len() {
+ res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx));
+ }
+ res
}
}
}
impl MsgEncodable for RevokeAndACK {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+32+33);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&self.per_commitment_secret);
+ res.extend_from_slice(&self.next_per_commitment_point.serialize());
+ res
}
}
}
impl MsgEncodable for UpdateFee {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(32+4);
+ res.extend_from_slice(&serialize(&self.channel_id).unwrap());
+ res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw));
+ res
}
}
}
impl MsgEncodable for NodeAnnouncement {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let contents = self.contents.encode();
+ let mut res = Vec::with_capacity(64 + contents.len());
+ let secp_ctx = Secp256k1::without_caps();
+ res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&contents);
+ res
}
}
}
impl MsgEncodable for ChannelAnnouncement {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let secp_ctx = Secp256k1::without_caps();
+ let contents = self.contents.encode();
+ let mut res = Vec::with_capacity(64 + contents.len());
+ res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx));
+ res.extend_from_slice(&contents);
+ res
}
}
}
impl MsgDecodable for DecodedOnionErrorPacket {
- fn decode(_v: &[u8]) -> Result<Self, DecodeError> {
- unimplemented!();
+ fn decode(v: &[u8]) -> Result<Self, DecodeError> {
+ if v.len() < 32 + 4 {
+ return Err(DecodeError::WrongLength);
+ }
+ let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize;
+ if v.len() < 32 + 4 + failuremsg_len {
+ return Err(DecodeError::WrongLength);
+ }
+ let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize;
+ if v.len() < 32 + 4 + failuremsg_len + padding_len {
+ return Err(DecodeError::WrongLength);
+ }
+
+ let mut hmac = [0; 32];
+ hmac.copy_from_slice(&v[0..32]);
+ Ok(Self {
+ hmac,
+ failuremsg: v[34..34 + failuremsg_len].to_vec(),
+ pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(),
+ })
}
}
impl MsgEncodable for DecodedOnionErrorPacket {
}
impl MsgEncodable for OnionErrorPacket {
fn encode(&self) -> Vec<u8> {
- unimplemented!();
+ let mut res = Vec::with_capacity(2 + self.data.len());
+ res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16));
+ res.extend_from_slice(&self.data);
+ res
}
}
-