Skip to content

use ? instead of try macro #3

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
merged 1 commit into from
Mar 2, 2018
Merged

use ? instead of try macro #3

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
32 changes: 16 additions & 16 deletions src/ln/chan_utils.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey
sha.result(&mut res);

let mut key = base_secret.clone();
try!(key.add_assign(&secp_ctx, &try!(SecretKey::from_slice(&secp_ctx, &res))));
key.add_assign(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?)?;
Ok(key)
}

Expand All @@ -46,7 +46,7 @@ pub fn derive_public_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey,
let mut res = [0; 32];
sha.result(&mut res);

let hashkey = PublicKey::from_secret_key(&secp_ctx, &try!(SecretKey::from_slice(&secp_ctx, &res))).unwrap();
let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?).unwrap();
base_point.combine(&secp_ctx, &hashkey)
}

Expand All @@ -62,7 +62,7 @@ pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret
let mut res = [0; 32];
sha.result(&mut res);

try!(SecretKey::from_slice(&secp_ctx, &res))
SecretKey::from_slice(&secp_ctx, &res)?
};
let commit_append_rev_hash_key = {
let mut sha = Sha256::new();
Expand All @@ -71,14 +71,14 @@ pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret
let mut res = [0; 32];
sha.result(&mut res);

try!(SecretKey::from_slice(&secp_ctx, &res))
SecretKey::from_slice(&secp_ctx, &res)?
};

let mut part_a = revocation_base_secret.clone();
try!(part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key));
part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key)?;
let mut part_b = per_commitment_secret.clone();
try!(part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key));
try!(part_a.add_assign(&secp_ctx, &part_b));
part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key)?;
part_a.add_assign(&secp_ctx, &part_b)?;
Ok(part_a)
}

Expand All @@ -90,7 +90,7 @@ pub fn derive_public_revocation_key(secp_ctx: &Secp256k1, per_commitment_point:
let mut res = [0; 32];
sha.result(&mut res);

try!(SecretKey::from_slice(&secp_ctx, &res))
SecretKey::from_slice(&secp_ctx, &res)?
};
let commit_append_rev_hash_key = {
let mut sha = Sha256::new();
Expand All @@ -99,13 +99,13 @@ pub fn derive_public_revocation_key(secp_ctx: &Secp256k1, per_commitment_point:
let mut res = [0; 32];
sha.result(&mut res);

try!(SecretKey::from_slice(&secp_ctx, &res))
SecretKey::from_slice(&secp_ctx, &res)?
};

let mut part_a = revocation_base_point.clone();
try!(part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key));
part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key)?;
let mut part_b = per_commitment_point.clone();
try!(part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key));
part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key)?;
part_a.combine(&secp_ctx, &part_b)
}

Expand All @@ -122,11 +122,11 @@ impl TxCreationKeys {
pub fn new(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, a_delayed_payment_base: &PublicKey, a_htlc_base: &PublicKey, b_revocation_base: &PublicKey, b_payment_base: &PublicKey, b_htlc_base: &PublicKey) -> Result<TxCreationKeys, secp256k1::Error> {
Ok(TxCreationKeys {
per_commitment_point: per_commitment_point.clone(),
revocation_key: try!(derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)),
a_htlc_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &a_htlc_base)),
b_htlc_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &b_htlc_base)),
a_delayed_payment_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &a_delayed_payment_base)),
b_payment_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &b_payment_base)),
revocation_key: derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)?,
a_htlc_key: derive_public_key(&secp_ctx, &per_commitment_point, &a_htlc_base)?,
b_htlc_key: derive_public_key(&secp_ctx, &per_commitment_point, &b_htlc_base)?,
a_delayed_payment_key: derive_public_key(&secp_ctx, &per_commitment_point, &a_delayed_payment_base)?,
b_payment_key: derive_public_key(&secp_ctx, &per_commitment_point, &b_payment_base)?,
})
}
}
Expand Down
58 changes: 29 additions & 29 deletions src/ln/channel.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,25 +50,25 @@ impl ChannelKeys {

let mut okm = [0; 32];
hkdf_expand(sha, &prk, b"rust-lightning funding key info", &mut okm);
let funding_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let funding_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning revocation base key info", &mut okm);
let revocation_base_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let revocation_base_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning payment base key info", &mut okm);
let payment_base_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let payment_base_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning delayed payment base key info", &mut okm);
let delayed_payment_base_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let delayed_payment_base_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning htlc base key info", &mut okm);
let htlc_base_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let htlc_base_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning channel close key info", &mut okm);
let channel_close_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let channel_close_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning channel monitor claim key info", &mut okm);
let channel_monitor_claim_key = try!(SecretKey::from_slice(&secp_ctx, &okm));
let channel_monitor_claim_key = SecretKey::from_slice(&secp_ctx, &okm)?;

hkdf_expand(sha, &prk, b"rust-lightning local commitment seed info", &mut okm);

Expand Down Expand Up @@ -610,7 +610,7 @@ impl Channel {
/// The result is a transaction which we can revoke ownership of (ie a "local" transaction)
/// TODO Some magic rust shit to compile-time check this?
fn build_local_transaction_keys(&self, commitment_number: u64) -> Result<TxCreationKeys, HandleError> {
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &try!(self.build_local_commitment_secret(commitment_number))).unwrap();
let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(commitment_number)?).unwrap();
let delayed_payment_base = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap();
let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap();

Expand Down Expand Up @@ -845,12 +845,12 @@ impl Channel {
fn funding_created_signature(&mut self, sig: &Signature) -> Result<(Transaction, Signature), HandleError> {
let funding_script = self.get_funding_redeemscript();

let remote_keys = try!(self.build_remote_transaction_keys());
let remote_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)).0;
let remote_keys = self.build_remote_transaction_keys()?;
let remote_initial_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)?.0;
let remote_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&remote_initial_commitment_tx).sighash_all(&remote_initial_commitment_tx, 0, &funding_script, self.channel_value_satoshis)[..]));

let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
let local_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)).0;
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?.0;
let local_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx, 0, &funding_script, self.channel_value_satoshis)[..]));

// They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish.
Expand Down Expand Up @@ -911,8 +911,8 @@ impl Channel {

let funding_script = self.get_funding_redeemscript();

let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
let local_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)).0;
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?.0;
let local_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx, 0, &funding_script, self.channel_value_satoshis)[..]));

// They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish.
Expand Down Expand Up @@ -1061,7 +1061,7 @@ impl Channel {
//TODO: Need to examine the type of err - if its a fee issue or similar we may want to
//fail it back the route, if its a temporary issue we can ignore it...
if update_add_msgs.len() > 0 {
Ok(Some((update_add_msgs, try!(self.send_commitment()))))
Ok(Some((update_add_msgs, self.send_commitment()?)))
} else {
Err(err.unwrap())
}
Expand Down Expand Up @@ -1156,8 +1156,8 @@ impl Channel {

let funding_script = self.get_funding_redeemscript();

let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
let local_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false));
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
let local_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?;
let local_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&local_commitment_tx.0).sighash_all(&local_commitment_tx.0, 0, &funding_script, self.channel_value_satoshis)[..]));
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey));

Expand All @@ -1166,13 +1166,13 @@ impl Channel {
}

for (idx, ref htlc) in local_commitment_tx.1.iter().enumerate() {
let htlc_tx = try!(self.build_htlc_transaction(&local_commitment_tx.0.txid(), htlc, true, &local_keys));
let htlc_tx = self.build_htlc_transaction(&local_commitment_tx.0.txid(), htlc, true, &local_keys)?;
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &local_keys, htlc.offered);
let htlc_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx, 0, &htlc_redeemscript, htlc.amount_msat / 1000)[..]));
secp_call!(self.secp_ctx.verify(&htlc_sighash, &msg.htlc_signatures[idx], &local_keys.b_htlc_key));
}

let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &try!(self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1))).unwrap();
let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1)?).unwrap();
let per_commitment_secret = chan_utils::build_commitment_secret(self.local_keys.commitment_seed, self.cur_local_commitment_transaction_number);

//TODO: Store htlc keys in our channel_watcher
Expand Down Expand Up @@ -1208,7 +1208,7 @@ impl Channel {
if PublicKey::from_secret_key(&self.secp_ctx, &get_key!(&self.secp_ctx, &msg.per_commitment_secret)).unwrap() != self.their_cur_commitment_point {
return Err(HandleError{err: "Got a revoke commitment secret which didn't correspond to their current pubkey", msg: None});
}
try!(self.channel_monitor.provide_secret(self.cur_remote_commitment_transaction_number, msg.per_commitment_secret));
self.channel_monitor.provide_secret(self.cur_remote_commitment_transaction_number, msg.per_commitment_secret)?;

// Update state now that we've passed all the can-fail calls...
// (note that we may still fail to generate the new commitment_signed message, but that's
Expand Down Expand Up @@ -1393,7 +1393,7 @@ impl Channel {
panic!("Tried to send an open_channel for a channel that has already advanced");
}

let local_commitment_secret = try!(self.build_local_commitment_secret(self.cur_local_commitment_transaction_number));
let local_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number)?;

Ok(msgs::OpenChannel {
chain_hash: chain_hash,
Expand Down Expand Up @@ -1429,7 +1429,7 @@ impl Channel {
panic!("Tried to send an accept_channel for a channel that has already advanced");
}

let local_commitment_secret = try!(self.build_local_commitment_secret(self.cur_local_commitment_transaction_number));
let local_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number)?;

Ok(msgs::AcceptChannel {
temporary_channel_id: self.channel_id,
Expand All @@ -1453,8 +1453,8 @@ impl Channel {
fn get_outbound_funding_created_signature(&mut self) -> Result<Signature, HandleError> {
let funding_script = self.get_funding_redeemscript();

let remote_keys = try!(self.build_remote_transaction_keys());
let remote_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)).0;
let remote_keys = self.build_remote_transaction_keys()?;
let remote_initial_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)?.0;
let remote_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&remote_initial_commitment_tx).sighash_all(&remote_initial_commitment_tx, 0, &funding_script, self.channel_value_satoshis)[..]));

// We sign the "remote" commitment transaction, allowing them to broadcast the tx if they wish.
Expand Down Expand Up @@ -1615,15 +1615,15 @@ impl Channel {

let funding_script = self.get_funding_redeemscript();

let remote_keys = try!(self.build_remote_transaction_keys());
let remote_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true));
let remote_keys = self.build_remote_transaction_keys()?;
let remote_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true)?;
let remote_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&remote_commitment_tx.0).sighash_all(&remote_commitment_tx.0, 0, &funding_script, self.channel_value_satoshis)[..]));
let our_sig = secp_call!(self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key));

let mut htlc_sigs = Vec::new();

for ref htlc in remote_commitment_tx.1.iter() {
let htlc_tx = try!(self.build_htlc_transaction(&remote_commitment_tx.0.txid(), htlc, false, &remote_keys));
let htlc_tx = self.build_htlc_transaction(&remote_commitment_tx.0.txid(), htlc, false, &remote_keys)?;
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &remote_keys, htlc.offered);
let htlc_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx, 0, &htlc_redeemscript, htlc.amount_msat / 1000)[..]));
let our_htlc_key = secp_call!(chan_utils::derive_private_key(&self.secp_ctx, &remote_keys.per_commitment_point, &self.local_keys.htlc_base_key));
Expand All @@ -1645,9 +1645,9 @@ impl Channel {
/// Shorthand for calling send_htlc() followed by send_commitment(), see docs on those for
/// more info.
pub fn send_htlc_and_commit(&mut self, amount_msat: u64, payment_hash: [u8; 32], cltv_expiry: u32, onion_routing_packet: msgs::OnionPacket) -> Result<Option<(msgs::UpdateAddHTLC, msgs::CommitmentSigned)>, HandleError> {
match try!(self.send_htlc(amount_msat, payment_hash, cltv_expiry, onion_routing_packet)) {
match self.send_htlc(amount_msat, payment_hash, cltv_expiry, onion_routing_packet)? {
Some(update_add_htlc) =>
Ok(Some((update_add_htlc, try!(self.send_commitment())))),
Ok(Some((update_add_htlc, self.send_commitment()?))),
None => Ok(None)
}
}
Expand Down
Loading