Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
TheBlueMatt merged 7 commits into from
Apr 25, 2020
Merged

Clean up ChannelKeys API #598

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
359b3d5
Dry-up InputMaterial::Funding
Apr 21, 2020
ddd85fb
Track signing of local txn in channelmonitor and refuse updates
TheBlueMatt Apr 19, 2020
bf74bb6
Return Result<Signature> instead of modifying args in ChannelKeys
TheBlueMatt Apr 19, 2020
7159d15
Batch-sign local HTLC txn with a well-doc'd API, returning sigs
TheBlueMatt Apr 20, 2020
29199fa
Don't modify LocalCommitmemntTransaction after construction
TheBlueMatt Apr 23, 2020
92c0698
Remove TODOs from documentation in keysinterface
TheBlueMatt Apr 20, 2020
03316cd
Remove trivial assertions in LocalCommitmentTransaction fns
TheBlueMatt Apr 24, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 42 additions & 33 deletions lightning/src/chain/keysinterface.rs
View file
Open in desktop
Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
/// Gets the private key for the anchor tx
fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
/// Create a signature for a remote commitment transaction and associated HTLC transactions.
///
/// Note that if signing fails or is rejected, the channel will be force-closed.
///
/// TODO: Document the things someone using this interface should enforce before signing.
/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
/// making the callee generate it via some util function we expose)!
//
// TODO: Document the things someone using this interface should enforce before signing.
// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
// making the callee generate it via some util function we expose)!
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>), ()>;

/// Create a signature for a local commitment transaction
///
/// TODO: Document the things someone using this interface should enforce before signing.
/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
/// making the callee generate it via some util function we expose)!
fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
/// Create a signature for a local commitment transaction. This will only ever be called with
/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
/// that it will not be called multiple times.

@ariardariardApr 23, 2020

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.

//
// TODO: Document the things someone using this interface should enforce before signing.
// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
/// transactions which will be broadcasted later, after the channel has moved on to a newer
/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
/// get called once.
#[cfg(test)]
fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

/// Create a signature for a local commitment transaction without enforcing one-time signing.
/// Create a signature for each HTLC transaction spending a local commitment transaction.
///
/// Testing revocation logic by our test framework needs to sign multiple local commitment
/// transactions. This unsafe test-only version doesn't enforce one-time signing security
/// requirement.
#[cfg(test)]
fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
/// Unlike sign_local_commitment, this may be called multiple times with *different*
/// local_commitment_tx values. While this will never be called with a revoked
/// local_commitment_tx, it is possible that it is called with the second-latest
/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
/// ChannelMonitor decided to broadcast before it had been updated to the latest.
///
/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
/// (implying they were considered dust at the time the commitment transaction was negotiated),
/// a corresponding None should be included in the return value. All other positions in the
/// return value must contain a signature.
fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

/// Signs a transaction created by build_htlc_transaction. If the transaction is an
/// HTLC-Success transaction, preimage must be set!
/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
/// Create a signature for a (proposed) closing transaction.
///
/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
Ok((commitment_sig, htlc_sigs))
}

fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
}

#[cfg(test)]
fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
}

fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
}

fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading
, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
Clean up ChannelKeys API#598

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

TheBlueMatt
merged 7 commits into

from

Apr 25, 2020
 Merged


Clean up ChannelKeys API
#598
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


7 commits


Select commit
Hold shift + click to select a range
359b3d5

Dry-up InputMaterial::Funding

Apr 21, 2020
ddd85fb

Track signing of local txn in channelmonitor and refuse updates


TheBlueMatt Apr 19, 2020
bf74bb6

Return Result<Signature> instead of modifying args in ChannelKeys


TheBlueMatt Apr 19, 2020
7159d15

Batch-sign local HTLC txn with a well-doc'd API, returning sigs


TheBlueMatt Apr 20, 2020
29199fa

Don't modify LocalCommitmemntTransaction after construction


TheBlueMatt Apr 23, 2020
92c0698

Remove TODOs from documentation in keysinterface


TheBlueMatt Apr 20, 2020
03316cd

Remove trivial assertions in LocalCommitmentTransaction fns


TheBlueMatt Apr 24, 2020

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


75 changes: 42 additions & 33 deletions
lightning/src/chain/keysinterface.rs

View file


Open in desktop

Original file line numberDiff line numberDiff line change
Expand Up@@ -25,7 +25,6 @@ use util::ser::{Writeable, Writer, Readable};

use ln::chan_utils;
use ln::chan_utils::{TxCreationKeys, HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, LocalCommitmentTransaction};
use ln::channelmanager::PaymentPreimage;
use ln::msgs;

use std::sync::Arc;
Expand DownExpand Up@@ -185,11 +184,11 @@ pub trait KeysInterface: Send + Sync {
/// Readable/Writable to serialize out a unique reference to this set of keys so
/// that you can serialize the full ChannelManager object.
///
/// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
/// to the possibility of reentrancy issues by calling the user's code during our deserialization
/// routine).
/// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
/// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
// (TODO: We shouldn't require that, and should have an API to get them at deser time, due mostly
// to the possibility of reentrancy issues by calling the user's code during our deserialization
// routine).
// TODO: We should remove Clone by instead requesting a new ChannelKeys copy when we create
// ChannelMonitors instead of expecting to clone the one out of the Channel into the monitors.
pub trait ChannelKeys : Send+Clone {
	/// Gets the private key for the anchor tx
	fn funding_key<'a>(&'a self) -> &'a SecretKey;
Expand All@@ -210,32 +209,42 @@ pub trait ChannelKeys : Send+Clone {
	/// Create a signature for a remote commitment transaction and associated HTLC transactions.
	///
	/// Note that if signing fails or is rejected, the channel will be force-closed.
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// making the callee generate it via some util function we expose)!
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	// making the callee generate it via some util function we expose)!
	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>), ()>;

	/// Create a signature for a local commitment transaction
	///
	/// TODO: Document the things someone using this interface should enforce before signing.
	/// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	/// TODO: Ensure test-only version doesn't enforce uniqueness of signature when it's enforced in this method
	/// making the callee generate it via some util function we expose)!
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a local commitment transaction. This will only ever be called with
	/// the same local_commitment_tx (or a copy thereof), though there are currently no guarantees
	/// that it will not be called multiple times.
@ariardariardApr 23, 2020

Copy link


Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree, I think that's good to say you may want to resign multiples times, even the same commitment transaction, like if you do a CPFP, you may want to verify every time the transaction chain back to the funding_outpoint, and therefore redoing the whole signing process.
	//
	// TODO: Document the things someone using this interface should enforce before signing.
	// TODO: Add more input vars to enable better checking (preferably removing commitment_tx and
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Same as sign_local_commitment, but exists only for tests to get access to local commitment
	/// transactions which will be broadcasted later, after the channel has moved on to a newer
	/// state. Thus, needs its own method as sign_local_commitment may enforce that we only ever
	/// get called once.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;

	/// Create a signature for a local commitment transaction without enforcing one-time signing.
	/// Create a signature for each HTLC transaction spending a local commitment transaction.
	///
	/// Testing revocation logic by our test framework needs to sign multiple local commitment
	/// transactions. This unsafe test-only version doesn't enforce one-time signing security
	/// requirement.
	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>);
	/// Unlike sign_local_commitment, this may be called multiple times with *different*
	/// local_commitment_tx values. While this will never be called with a revoked
	/// local_commitment_tx, it is possible that it is called with the second-latest
	/// local_commitment_tx (only if we haven't yet revoked it) if some watchtower/secondary
	/// ChannelMonitor decided to broadcast before it had been updated to the latest.
	///
	/// Either an Err should be returned, or a Vec with one entry for each HTLC which exists in
	/// local_commitment_tx. For those HTLCs which have transaction_output_index set to None
	/// (implying they were considered dust at the time the commitment transaction was negotiated),
	/// a corresponding None should be included in the return value. All other positions in the
	/// return value must contain a signature.
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;

	/// Signs a transaction created by build_htlc_transaction. If the transaction is an
	/// HTLC-Success transaction, preimage must be set!
	/// TODO: should be merged with sign_local_commitment as a slice of HTLC transactions to sign
	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>);
	/// Create a signature for a (proposed) closing transaction.
	///
	/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
Expand DownExpand Up@@ -363,25 +372,25 @@ impl ChannelKeys for InMemoryChannelKeys {
 Ok((commitment_sig, htlc_sigs))
	}

	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	#[cfg(test)]
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) {
	fn unsafe_sign_local_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 let remote_channel_pubkeys = self.remote_channel_pubkeys.as_ref().expect("must set remote channel pubkeys before signing");
 let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &remote_channel_pubkeys.funding_pubkey);

 local_commitment_tx.add_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
Ok(local_commitment_tx.get_local_sig(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
	}

	fn sign_htlc_transaction<T: secp256k1::Signing>(&self, local_commitment_tx: &mut LocalCommitmentTransaction, htlc_index: u32, preimage: Option<PaymentPreimage>, local_csv: u16, secp_ctx: &Secp256k1<T>) {
 local_commitment_tx.add_htlc_sig(&self.htlc_base_key, htlc_index, preimage, local_csv, secp_ctx);
	fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
	}

	fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
Expand Down
Loading