+ fn pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys { self.inner.pubkeys() }
+
+ fn sign_remote_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, feerate_per_kw: u64, commitment_tx: &Transaction, keys: &TxCreationKeys, htlcs: &[&HTLCOutputInCommitment], to_self_delay: u16, secp_ctx: &Secp256k1<T>) -> Result<(Signature, Vec<Signature>), ()> {
+ if commitment_tx.input.len() != 1 { panic!("lightning commitment transactions have a single input"); }
+ self.check_keys(secp_ctx, keys);
+ let obscured_commitment_transaction_number = (commitment_tx.lock_time & 0xffffff) as u64 | ((commitment_tx.input[0].sequence as u64 & 0xffffff) << 3*8);
+
+ {
+ let mut commitment_data = self.commitment_number_obscure_and_last.lock().unwrap();
+ if commitment_data.0.is_none() {
+ commitment_data.0 = Some(obscured_commitment_transaction_number ^ commitment_data.1);
+ }
+ let commitment_number = obscured_commitment_transaction_number ^ commitment_data.0.unwrap();
+ assert!(commitment_number == commitment_data.1 || commitment_number == commitment_data.1 + 1);
+ commitment_data.1 = cmp::max(commitment_number, commitment_data.1)
+ }
+
+ Ok(self.inner.sign_remote_commitment(feerate_per_kw, commitment_tx, keys, htlcs, to_self_delay, secp_ctx).unwrap())
+ }
+
+ fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
+ Ok(self.inner.sign_closing_transaction(closing_tx, secp_ctx).unwrap())
+ }
+
+ fn sign_channel_announcement<T: secp256k1::Signing>(&self, msg: &msgs::UnsignedChannelAnnouncement, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
+ self.inner.sign_channel_announcement(msg, secp_ctx)
+ }
+
+ fn set_remote_channel_pubkeys(&mut self, channel_pubkeys: &ChannelPublicKeys) {
+ self.inner.set_remote_channel_pubkeys(channel_pubkeys)
+ }
+}
+
+impl Writeable for EnforcingChannelKeys {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
+ self.inner.write(writer)?;
+ let (obscure, last) = *self.commitment_number_obscure_and_last.lock().unwrap();
+ obscure.write(writer)?;
+ last.write(writer)?;
+ Ok(())
+ }