Skip to content

Commit f9fc2df

Browse files
TheBlueMattTheBlueMatt
authored
Merge pull request #3 from RCasatta/fixtry
use ? instead of try macro
2 parents f2eadb0 + b94365f commit f9fc2df

File tree

5 files changed

+72
-72
lines changed

5 files changed

+72
-72
lines changed

‎src/ln/chan_utils.rs

+16-16
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey
3535
sha.result(&mut res);
3636

3737
let mut key = base_secret.clone();
38-
try!(key.add_assign(&secp_ctx, &try!(SecretKey::from_slice(&secp_ctx, &res))));
38+
key.add_assign(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?)?;
3939
Ok(key)
4040
}
4141

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

49-
let hashkey = PublicKey::from_secret_key(&secp_ctx, &try!(SecretKey::from_slice(&secp_ctx, &res))).unwrap();
49+
let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?).unwrap();
5050
base_point.combine(&secp_ctx, &hashkey)
5151
}
5252

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

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

74-
try!(SecretKey::from_slice(&secp_ctx, &res))
74+
SecretKey::from_slice(&secp_ctx, &res)?
7575
};
7676

7777
let mut part_a = revocation_base_secret.clone();
78-
try!(part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key));
78+
part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key)?;
7979
let mut part_b = per_commitment_secret.clone();
80-
try!(part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key));
81-
try!(part_a.add_assign(&secp_ctx, &part_b));
80+
part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key)?;
81+
part_a.add_assign(&secp_ctx, &part_b)?;
8282
Ok(part_a)
8383
}
8484

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

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

102-
try!(SecretKey::from_slice(&secp_ctx, &res))
102+
SecretKey::from_slice(&secp_ctx, &res)?
103103
};
104104

105105
let mut part_a = revocation_base_point.clone();
106-
try!(part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key));
106+
part_a.mul_assign(&secp_ctx, &rev_append_commit_hash_key)?;
107107
let mut part_b = per_commitment_point.clone();
108-
try!(part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key));
108+
part_b.mul_assign(&secp_ctx, &commit_append_rev_hash_key)?;
109109
part_a.combine(&secp_ctx, &part_b)
110110
}
111111

@@ -122,11 +122,11 @@ impl TxCreationKeys {
122122
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> {
123123
Ok(TxCreationKeys {
124124
per_commitment_point: per_commitment_point.clone(),
125-
revocation_key: try!(derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)),
126-
a_htlc_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &a_htlc_base)),
127-
b_htlc_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &b_htlc_base)),
128-
a_delayed_payment_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &a_delayed_payment_base)),
129-
b_payment_key: try!(derive_public_key(&secp_ctx, &per_commitment_point, &b_payment_base)),
125+
revocation_key: derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)?,
126+
a_htlc_key: derive_public_key(&secp_ctx, &per_commitment_point, &a_htlc_base)?,
127+
b_htlc_key: derive_public_key(&secp_ctx, &per_commitment_point, &b_htlc_base)?,
128+
a_delayed_payment_key: derive_public_key(&secp_ctx, &per_commitment_point, &a_delayed_payment_base)?,
129+
b_payment_key: derive_public_key(&secp_ctx, &per_commitment_point, &b_payment_base)?,
130130
})
131131
}
132132
}

‎src/ln/channel.rs

+29-29
Original file line numberDiff line numberDiff line change
@@ -50,25 +50,25 @@ impl ChannelKeys {
5050

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

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

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

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

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

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

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

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

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

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

848-
let remote_keys = try!(self.build_remote_transaction_keys());
849-
let remote_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)).0;
848+
let remote_keys = self.build_remote_transaction_keys()?;
849+
let remote_initial_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)?.0;
850850
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)[..]));
851851

852-
let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
853-
let local_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)).0;
852+
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
853+
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?.0;
854854
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)[..]));
855855

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

912912
let funding_script = self.get_funding_redeemscript();
913913

914-
let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
915-
let local_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)).0;
914+
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
915+
let local_initial_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?.0;
916916
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)[..]));
917917

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

11571157
let funding_script = self.get_funding_redeemscript();
11581158

1159-
let local_keys = try!(self.build_local_transaction_keys(self.cur_local_commitment_transaction_number));
1160-
let local_commitment_tx = try!(self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false));
1159+
let local_keys = self.build_local_transaction_keys(self.cur_local_commitment_transaction_number)?;
1160+
let local_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false)?;
11611161
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)[..]));
11621162
secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey));
11631163

@@ -1166,13 +1166,13 @@ impl Channel {
11661166
}
11671167

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

1175-
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();
1175+
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();
11761176
let per_commitment_secret = chan_utils::build_commitment_secret(self.local_keys.commitment_seed, self.cur_local_commitment_transaction_number);
11771177

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

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

1396-
let local_commitment_secret = try!(self.build_local_commitment_secret(self.cur_local_commitment_transaction_number));
1396+
let local_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number)?;
13971397

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

1432-
let local_commitment_secret = try!(self.build_local_commitment_secret(self.cur_local_commitment_transaction_number));
1432+
let local_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number)?;
14331433

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

1456-
let remote_keys = try!(self.build_remote_transaction_keys());
1457-
let remote_initial_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)).0;
1456+
let remote_keys = self.build_remote_transaction_keys()?;
1457+
let remote_initial_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, false)?.0;
14581458
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)[..]));
14591459

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

16161616
let funding_script = self.get_funding_redeemscript();
16171617

1618-
let remote_keys = try!(self.build_remote_transaction_keys());
1619-
let remote_commitment_tx = try!(self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true));
1618+
let remote_keys = self.build_remote_transaction_keys()?;
1619+
let remote_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true)?;
16201620
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)[..]));
16211621
let our_sig = secp_call!(self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key));
16221622

16231623
let mut htlc_sigs = Vec::new();
16241624

16251625
for ref htlc in remote_commitment_tx.1.iter() {
1626-
let htlc_tx = try!(self.build_htlc_transaction(&remote_commitment_tx.0.txid(), htlc, false, &remote_keys));
1626+
let htlc_tx = self.build_htlc_transaction(&remote_commitment_tx.0.txid(), htlc, false, &remote_keys)?;
16271627
let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &remote_keys, htlc.offered);
16281628
let htlc_sighash = secp_call!(Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx, 0, &htlc_redeemscript, htlc.amount_msat / 1000)[..]));
16291629
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));
@@ -1645,9 +1645,9 @@ impl Channel {
16451645
/// Shorthand for calling send_htlc() followed by send_commitment(), see docs on those for
16461646
/// more info.
16471647
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> {
1648-
match try!(self.send_htlc(amount_msat, payment_hash, cltv_expiry, onion_routing_packet)) {
1648+
match self.send_htlc(amount_msat, payment_hash, cltv_expiry, onion_routing_packet)? {
16491649
Some(update_add_htlc) =>
1650-
Ok(Some((update_add_htlc, try!(self.send_commitment())))),
1650+
Ok(Some((update_add_htlc, self.send_commitment()?))),
16511651
None => Ok(None)
16521652
}
16531653
}

0 commit comments

Comments
 (0)