electrum

Electrum Bitcoin wallet
git clone https://git.parazyd.org/electrum
Log | Files | Refs | Submodules

commit 7fccd4fc5e0044d35b4cf717b1fc0137b6321b0e
parent 817411b889fa57ea8205ed4abea1cc08aa2d666a
Author: SomberNight <somber.night@protonmail.com>
Date:   Wed, 10 Jun 2020 20:23:12 +0200

lnchannel.available_to_spend: consider both receiver's and sender's ctx

Diffstat:
Melectrum/lnchannel.py | 85+++++++++++++++++++++++++++++++++++--------------------------------------------
1 file changed, 38 insertions(+), 47 deletions(-)

diff --git a/electrum/lnchannel.py b/electrum/lnchannel.py @@ -1054,53 +1054,44 @@ class Channel(AbstractChannel): assert type(subject) is HTLCOwner sender = subject receiver = subject.inverted() - ctx_owner = receiver - # TODO but what about the other ctx? BOLT-02 only talks about checking the receiver's ctx, - # however the channel reserve is only meaningful if we also check the sender's ctx! - # in particular, note that dust limits can be different between the parties! - # but due to the racy nature of this, we cannot be sure exactly what the sender's - # next ctx will look like (e.g. what feerate it will use). hmmm :/ - ctn = self.get_next_ctn(ctx_owner) - sender_balance_msat = self.balance_minus_outgoing_htlcs(whose=sender, ctx_owner=ctx_owner, ctn=ctn) - receiver_balance_msat = self.balance_minus_outgoing_htlcs(whose=receiver, ctx_owner=ctx_owner, ctn=ctn) - sender_reserve_msat = self.config[receiver].reserve_sat * 1000 - receiver_reserve_msat = self.config[sender].reserve_sat * 1000 - initiator = LOCAL if self.constraints.is_initiator else REMOTE - # the initiator/funder pays on-chain fees - num_htlcs_in_ctx = len(self.included_htlcs(ctx_owner, SENT, ctn=ctn) + self.included_htlcs(ctx_owner, RECEIVED, ctn=ctn)) - feerate = self.get_feerate(ctx_owner, ctn=ctn) - ctx_fees_msat = calc_fees_for_commitment_tx( - num_htlcs=num_htlcs_in_ctx, - feerate=feerate, - is_local_initiator=self.constraints.is_initiator, - round_to_sat=False, - ) - # note: if this supposed new HTLC is large enough to create an output, the initiator needs to pay for that too - # note: if sender != initiator, both the sender and the receiver need to "afford" the payment - htlc_fee_msat = fee_for_htlc_output(feerate=feerate) - # TODO stuck channels. extra funder reserve? "fee spike buffer" (maybe only if "strict") - # see https://github.com/lightningnetwork/lightning-rfc/issues/728 - # note: in terms of on-chain outputs, as we are considering the htlc_receiver's ctx, this is a "received" HTLC - htlc_trim_threshold_msat = received_htlc_trim_threshold_sat(dust_limit_sat=self.config[receiver].dust_limit_sat, feerate=feerate) * 1000 - if strict: - # also consider the other ctx, where the trim threshold is different - # note: the 'feerate' we use is not technically correct but we have no way - # of knowing the actual future feerate ahead of time (this is a protocol bug) - htlc_trim_threshold_msat = min(htlc_trim_threshold_msat, - offered_htlc_trim_threshold_sat(dust_limit_sat=self.config[sender].dust_limit_sat, feerate=feerate) * 1000) - max_send_msat = sender_balance_msat - sender_reserve_msat - ctx_fees_msat[sender] - if max_send_msat < htlc_trim_threshold_msat: - # there will be no corresponding HTLC output - return max_send_msat - if sender == initiator: - max_send_after_htlc_fee_msat = max_send_msat - htlc_fee_msat - max_send_msat = max(htlc_trim_threshold_msat - 1, max_send_after_htlc_fee_msat) - return max_send_msat - else: - # the receiver is the initiator, so they need to be able to pay tx fees - if receiver_balance_msat - receiver_reserve_msat - ctx_fees_msat[receiver] - htlc_fee_msat < 0: - max_send_msat = htlc_trim_threshold_msat - 1 - return max_send_msat + initiator = LOCAL if self.constraints.is_initiator else REMOTE # the initiator/funder pays on-chain fees + + def consider_ctx(*, ctx_owner: HTLCOwner) -> int: + ctn = self.get_next_ctn(ctx_owner) + sender_balance_msat = self.balance_minus_outgoing_htlcs(whose=sender, ctx_owner=ctx_owner, ctn=ctn) + receiver_balance_msat = self.balance_minus_outgoing_htlcs(whose=receiver, ctx_owner=ctx_owner, ctn=ctn) + sender_reserve_msat = self.config[receiver].reserve_sat * 1000 + receiver_reserve_msat = self.config[sender].reserve_sat * 1000 + num_htlcs_in_ctx = len(self.included_htlcs(ctx_owner, SENT, ctn=ctn) + self.included_htlcs(ctx_owner, RECEIVED, ctn=ctn)) + feerate = self.get_feerate(ctx_owner, ctn=ctn) + ctx_fees_msat = calc_fees_for_commitment_tx( + num_htlcs=num_htlcs_in_ctx, + feerate=feerate, + is_local_initiator=self.constraints.is_initiator, + round_to_sat=False, + ) + htlc_fee_msat = fee_for_htlc_output(feerate=feerate) + htlc_trim_func = received_htlc_trim_threshold_sat if ctx_owner == receiver else offered_htlc_trim_threshold_sat + htlc_trim_threshold_msat = htlc_trim_func(dust_limit_sat=self.config[ctx_owner].dust_limit_sat, feerate=feerate) * 1000 + max_send_msat = sender_balance_msat - sender_reserve_msat - ctx_fees_msat[sender] + if max_send_msat < htlc_trim_threshold_msat: + # there will be no corresponding HTLC output + return max_send_msat + if sender == initiator: + max_send_after_htlc_fee_msat = max_send_msat - htlc_fee_msat + max_send_msat = max(htlc_trim_threshold_msat - 1, max_send_after_htlc_fee_msat) + return max_send_msat + else: + # the receiver is the initiator, so they need to be able to pay tx fees + if receiver_balance_msat - receiver_reserve_msat - ctx_fees_msat[receiver] - htlc_fee_msat < 0: + max_send_msat = htlc_trim_threshold_msat - 1 + return max_send_msat + + max_send_msat = min(consider_ctx(ctx_owner=receiver), + consider_ctx(ctx_owner=sender)) + max_send_msat = max(max_send_msat, 0) + return max_send_msat + def included_htlcs(self, subject: HTLCOwner, direction: Direction, ctn: int = None) -> Sequence[UpdateAddHtlc]: """Returns list of non-dust HTLCs for subject's commitment tx at ctn,