You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
508 lines
26 KiB
508 lines
26 KiB
# Copyright (C) 2018 The Electrum developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file LICENCE or http://www.opensource.org/licenses/mit-license.php
|
|
|
|
from typing import Optional, Dict, List, Tuple, TYPE_CHECKING
|
|
|
|
from .util import bfh, bh2u
|
|
from .bitcoin import TYPE_ADDRESS, redeem_script_to_address, dust_threshold
|
|
from . import ecc
|
|
from .lnutil import (make_commitment_output_to_remote_address, make_commitment_output_to_local_witness_script,
|
|
derive_privkey, derive_pubkey, derive_blinded_pubkey, derive_blinded_privkey,
|
|
make_htlc_tx_witness, make_htlc_tx_with_open_channel, UpdateAddHtlc,
|
|
LOCAL, REMOTE, make_htlc_output_witness_script, UnknownPaymentHash,
|
|
get_ordered_channel_configs, privkey_to_pubkey, get_per_commitment_secret_from_seed,
|
|
RevocationStore, extract_ctn_from_tx_and_chan, UnableToDeriveSecret, SENT, RECEIVED)
|
|
from .transaction import Transaction, TxOutput, construct_witness
|
|
from .simple_config import SimpleConfig, FEERATE_FALLBACK_STATIC_FEE
|
|
from .logging import get_logger
|
|
|
|
if TYPE_CHECKING:
|
|
from .lnchannel import Channel
|
|
|
|
|
|
_logger = get_logger(__name__)
|
|
|
|
|
|
def maybe_create_sweeptx_for_their_ctx_to_remote(ctx: Transaction, sweep_address: str,
|
|
our_payment_privkey: ecc.ECPrivkey) -> Optional[Transaction]:
|
|
our_payment_pubkey = our_payment_privkey.get_public_key_bytes(compressed=True)
|
|
to_remote_address = make_commitment_output_to_remote_address(our_payment_pubkey)
|
|
output_idx = ctx.get_output_idx_from_address(to_remote_address)
|
|
if output_idx is None: return None
|
|
sweep_tx = create_sweeptx_their_ctx_to_remote(sweep_address=sweep_address,
|
|
ctx=ctx,
|
|
output_idx=output_idx,
|
|
our_payment_privkey=our_payment_privkey)
|
|
return sweep_tx
|
|
|
|
|
|
def maybe_create_sweeptx_for_their_ctx_to_local(ctx: Transaction, revocation_privkey: bytes,
|
|
to_self_delay: int, delayed_pubkey: bytes,
|
|
sweep_address: str) -> Optional[Transaction]:
|
|
revocation_pubkey = ecc.ECPrivkey(revocation_privkey).get_public_key_bytes(compressed=True)
|
|
witness_script = bh2u(make_commitment_output_to_local_witness_script(
|
|
revocation_pubkey, to_self_delay, delayed_pubkey))
|
|
to_local_address = redeem_script_to_address('p2wsh', witness_script)
|
|
output_idx = ctx.get_output_idx_from_address(to_local_address)
|
|
if output_idx is None: return None
|
|
sweep_tx = create_sweeptx_ctx_to_local(sweep_address=sweep_address,
|
|
ctx=ctx,
|
|
output_idx=output_idx,
|
|
witness_script=witness_script,
|
|
privkey=revocation_privkey,
|
|
is_revocation=True)
|
|
return sweep_tx
|
|
|
|
|
|
def create_sweeptxs_for_their_just_revoked_ctx(chan: 'Channel', ctx: Transaction, per_commitment_secret: bytes,
|
|
sweep_address: str) -> Dict[str,Transaction]:
|
|
"""Presign sweeping transactions using the just received revoked pcs.
|
|
These will only be utilised if the remote breaches.
|
|
Sweep 'lo_local', and all the HTLCs (two cases: directly from ctx, or from HTLC tx).
|
|
"""
|
|
# prep
|
|
pcp = ecc.ECPrivkey(per_commitment_secret).get_public_key_bytes(compressed=True)
|
|
this_conf, other_conf = get_ordered_channel_configs(chan=chan, for_us=False)
|
|
other_revocation_privkey = derive_blinded_privkey(other_conf.revocation_basepoint.privkey,
|
|
per_commitment_secret)
|
|
to_self_delay = other_conf.to_self_delay
|
|
this_delayed_pubkey = derive_pubkey(this_conf.delayed_basepoint.pubkey, pcp)
|
|
txs = {}
|
|
# to_local
|
|
sweep_tx = maybe_create_sweeptx_for_their_ctx_to_local(ctx=ctx,
|
|
revocation_privkey=other_revocation_privkey,
|
|
to_self_delay=to_self_delay,
|
|
delayed_pubkey=this_delayed_pubkey,
|
|
sweep_address=sweep_address)
|
|
if sweep_tx:
|
|
txs[ctx.txid()] = sweep_tx
|
|
# HTLCs
|
|
def create_sweeptx_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool) -> Tuple[Optional[Transaction],
|
|
Optional[Transaction],
|
|
Transaction]:
|
|
htlc_tx_witness_script, htlc_tx = make_htlc_tx_with_open_channel(chan=chan,
|
|
pcp=pcp,
|
|
for_us=False,
|
|
we_receive=not is_received_htlc,
|
|
commit=ctx,
|
|
htlc=htlc)
|
|
htlc_tx_txin = htlc_tx.inputs()[0]
|
|
htlc_output_witness_script = bfh(Transaction.get_preimage_script(htlc_tx_txin))
|
|
# sweep directly from ctx
|
|
direct_sweep_tx = maybe_create_sweeptx_for_their_ctx_htlc(
|
|
ctx=ctx,
|
|
sweep_address=sweep_address,
|
|
htlc_output_witness_script=htlc_output_witness_script,
|
|
privkey=other_revocation_privkey,
|
|
preimage=None,
|
|
is_revocation=True)
|
|
# sweep from htlc tx
|
|
secondstage_sweep_tx = create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
|
|
'sweep_from_their_ctx_htlc_',
|
|
to_self_delay=0,
|
|
htlc_tx=htlc_tx,
|
|
htlctx_witness_script=htlc_tx_witness_script,
|
|
sweep_address=sweep_address,
|
|
privkey=other_revocation_privkey,
|
|
is_revocation=True)
|
|
return direct_sweep_tx, secondstage_sweep_tx, htlc_tx
|
|
ctn = extract_ctn_from_tx_and_chan(ctx, chan)
|
|
assert ctn == chan.config[REMOTE].ctn
|
|
# received HTLCs, in their ctx
|
|
received_htlcs = chan.included_htlcs(REMOTE, RECEIVED, ctn)
|
|
for htlc in received_htlcs:
|
|
direct_sweep_tx, secondstage_sweep_tx, htlc_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=True)
|
|
if direct_sweep_tx:
|
|
txs[ctx.txid()] = direct_sweep_tx
|
|
if secondstage_sweep_tx:
|
|
txs[htlc_tx.txid()] = secondstage_sweep_tx
|
|
# offered HTLCs, in their ctx
|
|
offered_htlcs = chan.included_htlcs(REMOTE, SENT, ctn)
|
|
for htlc in offered_htlcs:
|
|
direct_sweep_tx, secondstage_sweep_tx, htlc_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=False)
|
|
if direct_sweep_tx:
|
|
txs[ctx.txid()] = direct_sweep_tx
|
|
if secondstage_sweep_tx:
|
|
txs[htlc_tx.txid()] = secondstage_sweep_tx
|
|
return txs
|
|
|
|
|
|
def create_sweeptxs_for_our_latest_ctx(chan: 'Channel', ctx: Transaction,
|
|
sweep_address: str) -> Dict[str,Transaction]:
|
|
"""Handle the case where we force close unilaterally with our latest ctx.
|
|
Construct sweep txns for 'to_local', and for all HTLCs (2 txns each).
|
|
'to_local' can be swept even if this is a breach (by us),
|
|
but HTLCs cannot (old HTLCs are no longer stored).
|
|
"""
|
|
this_conf, other_conf = get_ordered_channel_configs(chan=chan, for_us=True)
|
|
ctn = extract_ctn_from_tx_and_chan(ctx, chan)
|
|
our_per_commitment_secret = get_per_commitment_secret_from_seed(
|
|
this_conf.per_commitment_secret_seed, RevocationStore.START_INDEX - ctn)
|
|
our_pcp = ecc.ECPrivkey(our_per_commitment_secret).get_public_key_bytes(compressed=True)
|
|
# prep
|
|
this_delayed_bp_privkey = ecc.ECPrivkey(this_conf.delayed_basepoint.privkey)
|
|
this_localdelayed_privkey = derive_privkey(this_delayed_bp_privkey.secret_scalar, our_pcp)
|
|
this_localdelayed_privkey = ecc.ECPrivkey.from_secret_scalar(this_localdelayed_privkey)
|
|
other_revocation_pubkey = derive_blinded_pubkey(other_conf.revocation_basepoint.pubkey, our_pcp)
|
|
to_self_delay = chan.config[REMOTE].to_self_delay
|
|
this_htlc_privkey = derive_privkey(secret=int.from_bytes(this_conf.htlc_basepoint.privkey, 'big'),
|
|
per_commitment_point=our_pcp).to_bytes(32, 'big')
|
|
txs = {}
|
|
# to_local
|
|
sweep_tx = maybe_create_sweeptx_that_spends_to_local_in_our_ctx(ctx=ctx,
|
|
sweep_address=sweep_address,
|
|
our_localdelayed_privkey=this_localdelayed_privkey,
|
|
remote_revocation_pubkey=other_revocation_pubkey,
|
|
to_self_delay=to_self_delay)
|
|
if sweep_tx:
|
|
txs[sweep_tx.prevout(0)] = sweep_tx
|
|
# HTLCs
|
|
def create_txns_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool) -> Tuple[Optional[Transaction], Optional[Transaction]]:
|
|
if is_received_htlc:
|
|
try:
|
|
preimage = chan.lnworker.get_preimage(htlc.payment_hash)
|
|
except UnknownPaymentHash as e:
|
|
_logger.info(f'trying to sweep htlc from our latest ctx but getting {repr(e)}')
|
|
return None, None
|
|
else:
|
|
preimage = None
|
|
htlctx_witness_script, htlc_tx = create_htlctx_that_spends_from_our_ctx(
|
|
chan=chan,
|
|
our_pcp=our_pcp,
|
|
ctx=ctx,
|
|
htlc=htlc,
|
|
local_htlc_privkey=this_htlc_privkey,
|
|
preimage=preimage,
|
|
is_received_htlc=is_received_htlc)
|
|
to_wallet_tx = create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
|
|
'sweep_from_our_ctx_htlc_',
|
|
to_self_delay=to_self_delay,
|
|
htlc_tx=htlc_tx,
|
|
htlctx_witness_script=htlctx_witness_script,
|
|
sweep_address=sweep_address,
|
|
privkey=this_localdelayed_privkey.get_secret_bytes(),
|
|
is_revocation=False)
|
|
return htlc_tx, to_wallet_tx
|
|
# offered HTLCs, in our ctx --> "timeout"
|
|
# received HTLCs, in our ctx --> "success"
|
|
offered_htlcs = chan.included_htlcs(LOCAL, SENT, ctn) # type: List[UpdateAddHtlc]
|
|
received_htlcs = chan.included_htlcs(LOCAL, RECEIVED, ctn) # type: List[UpdateAddHtlc]
|
|
for htlc in offered_htlcs:
|
|
htlc_tx, to_wallet_tx = create_txns_for_htlc(htlc, is_received_htlc=False)
|
|
if htlc_tx and to_wallet_tx:
|
|
txs[to_wallet_tx.prevout(0)] = to_wallet_tx
|
|
txs[htlc_tx.prevout(0)] = htlc_tx
|
|
for htlc in received_htlcs:
|
|
htlc_tx, to_wallet_tx = create_txns_for_htlc(htlc, is_received_htlc=True)
|
|
if htlc_tx and to_wallet_tx:
|
|
txs[to_wallet_tx.prevout(0)] = to_wallet_tx
|
|
txs[htlc_tx.prevout(0)] = htlc_tx
|
|
return txs
|
|
|
|
|
|
def create_sweeptxs_for_their_latest_ctx(chan: 'Channel', ctx: Transaction,
|
|
sweep_address: str) -> Dict[str,Transaction]:
|
|
"""Handle the case when the remote force-closes with their ctx.
|
|
Regardless of it is a breach or not, construct sweep tx for 'to_remote'.
|
|
If it is a breach, also construct sweep tx for 'to_local'.
|
|
Sweep txns for HTLCs are only constructed if it is NOT a breach, as
|
|
lnchannel does not store old HTLCs.
|
|
"""
|
|
this_conf, other_conf = get_ordered_channel_configs(chan=chan, for_us=False)
|
|
ctn = extract_ctn_from_tx_and_chan(ctx, chan)
|
|
# note: the remote sometimes has two valid non-revoked commitment transactions,
|
|
# either of which could be broadcast (this_conf.ctn, this_conf.ctn+1)
|
|
per_commitment_secret = None
|
|
if ctn == this_conf.ctn:
|
|
their_pcp = this_conf.current_per_commitment_point
|
|
elif ctn == this_conf.ctn + 1:
|
|
their_pcp = this_conf.next_per_commitment_point
|
|
elif ctn < this_conf.ctn: # breach
|
|
try:
|
|
per_commitment_secret = this_conf.revocation_store.retrieve_secret(RevocationStore.START_INDEX - ctn)
|
|
except UnableToDeriveSecret:
|
|
return {}
|
|
their_pcp = ecc.ECPrivkey(per_commitment_secret).get_public_key_bytes(compressed=True)
|
|
else:
|
|
return {}
|
|
# prep
|
|
other_revocation_pubkey = derive_blinded_pubkey(other_conf.revocation_basepoint.pubkey, their_pcp)
|
|
other_htlc_privkey = derive_privkey(secret=int.from_bytes(other_conf.htlc_basepoint.privkey, 'big'),
|
|
per_commitment_point=their_pcp)
|
|
other_htlc_privkey = ecc.ECPrivkey.from_secret_scalar(other_htlc_privkey)
|
|
this_htlc_pubkey = derive_pubkey(this_conf.htlc_basepoint.pubkey, their_pcp)
|
|
other_payment_bp_privkey = ecc.ECPrivkey(other_conf.payment_basepoint.privkey)
|
|
other_payment_privkey = derive_privkey(other_payment_bp_privkey.secret_scalar, their_pcp)
|
|
other_payment_privkey = ecc.ECPrivkey.from_secret_scalar(other_payment_privkey)
|
|
|
|
txs = {}
|
|
if per_commitment_secret: # breach
|
|
# to_local
|
|
other_revocation_privkey = derive_blinded_privkey(other_conf.revocation_basepoint.privkey,
|
|
per_commitment_secret)
|
|
this_delayed_pubkey = derive_pubkey(this_conf.delayed_basepoint.pubkey, their_pcp)
|
|
sweep_tx = maybe_create_sweeptx_for_their_ctx_to_local(ctx=ctx,
|
|
revocation_privkey=other_revocation_privkey,
|
|
to_self_delay=other_conf.to_self_delay,
|
|
delayed_pubkey=this_delayed_pubkey,
|
|
sweep_address=sweep_address)
|
|
if sweep_tx:
|
|
txs[sweep_tx.prevout(0)] = sweep_tx
|
|
# to_remote
|
|
sweep_tx = maybe_create_sweeptx_for_their_ctx_to_remote(ctx=ctx,
|
|
sweep_address=sweep_address,
|
|
our_payment_privkey=other_payment_privkey)
|
|
if sweep_tx:
|
|
txs[sweep_tx.prevout(0)] = sweep_tx
|
|
# HTLCs
|
|
# from their ctx, we can only redeem HTLCs if the ctx was not revoked,
|
|
# as old HTLCs are not stored. (if it was revoked, then we should have presigned txns
|
|
# to handle the breach already; out of scope here)
|
|
if ctn not in (this_conf.ctn, this_conf.ctn + 1):
|
|
return txs
|
|
def create_sweeptx_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool) -> Optional[Transaction]:
|
|
if not is_received_htlc:
|
|
try:
|
|
preimage = chan.lnworker.get_preimage(htlc.payment_hash)
|
|
except UnknownPaymentHash as e:
|
|
_logger.info(f'trying to sweep htlc from their latest ctx but getting {repr(e)}')
|
|
return None
|
|
else:
|
|
preimage = None
|
|
htlc_output_witness_script = make_htlc_output_witness_script(
|
|
is_received_htlc=is_received_htlc,
|
|
remote_revocation_pubkey=other_revocation_pubkey,
|
|
remote_htlc_pubkey=other_htlc_privkey.get_public_key_bytes(compressed=True),
|
|
local_htlc_pubkey=this_htlc_pubkey,
|
|
payment_hash=htlc.payment_hash,
|
|
cltv_expiry=htlc.cltv_expiry)
|
|
sweep_tx = maybe_create_sweeptx_for_their_ctx_htlc(
|
|
ctx=ctx,
|
|
sweep_address=sweep_address,
|
|
htlc_output_witness_script=htlc_output_witness_script,
|
|
privkey=other_htlc_privkey.get_secret_bytes(),
|
|
preimage=preimage,
|
|
is_revocation=False,
|
|
cltv_expiry=htlc.cltv_expiry if is_received_htlc else 0)
|
|
return sweep_tx
|
|
# received HTLCs, in their ctx --> "timeout"
|
|
received_htlcs = chan.included_htlcs_in_their_latest_ctxs(LOCAL)[ctn] # type: List[UpdateAddHtlc]
|
|
for htlc in received_htlcs:
|
|
sweep_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=True)
|
|
if sweep_tx:
|
|
txs[sweep_tx.prevout(0)] = sweep_tx
|
|
# offered HTLCs, in their ctx --> "success"
|
|
offered_htlcs = chan.included_htlcs_in_their_latest_ctxs(REMOTE)[ctn] # type: List[UpdateAddHtlc]
|
|
for htlc in offered_htlcs:
|
|
sweep_tx = create_sweeptx_for_htlc(htlc, is_received_htlc=False)
|
|
if sweep_tx:
|
|
txs[sweep_tx.prevout(0)] = sweep_tx
|
|
return txs
|
|
|
|
|
|
def maybe_create_sweeptx_that_spends_to_local_in_our_ctx(
|
|
ctx: Transaction, sweep_address: str, our_localdelayed_privkey: ecc.ECPrivkey,
|
|
remote_revocation_pubkey: bytes, to_self_delay: int) -> Optional[Transaction]:
|
|
our_localdelayed_pubkey = our_localdelayed_privkey.get_public_key_bytes(compressed=True)
|
|
to_local_witness_script = bh2u(make_commitment_output_to_local_witness_script(
|
|
remote_revocation_pubkey, to_self_delay, our_localdelayed_pubkey))
|
|
to_local_address = redeem_script_to_address('p2wsh', to_local_witness_script)
|
|
output_idx = ctx.get_output_idx_from_address(to_local_address)
|
|
if output_idx is None: return None
|
|
sweep_tx = create_sweeptx_ctx_to_local(sweep_address=sweep_address,
|
|
ctx=ctx,
|
|
output_idx=output_idx,
|
|
witness_script=to_local_witness_script,
|
|
privkey=our_localdelayed_privkey.get_secret_bytes(),
|
|
is_revocation=False,
|
|
to_self_delay=to_self_delay)
|
|
return sweep_tx
|
|
|
|
|
|
def create_htlctx_that_spends_from_our_ctx(chan: 'Channel', our_pcp: bytes,
|
|
ctx: Transaction, htlc: 'UpdateAddHtlc',
|
|
local_htlc_privkey: bytes, preimage: Optional[bytes],
|
|
is_received_htlc: bool) -> Tuple[bytes, Transaction]:
|
|
assert is_received_htlc == bool(preimage), 'preimage is required iff htlc is received'
|
|
preimage = preimage or b''
|
|
witness_script, htlc_tx = make_htlc_tx_with_open_channel(chan=chan,
|
|
pcp=our_pcp,
|
|
for_us=True,
|
|
we_receive=is_received_htlc,
|
|
commit=ctx,
|
|
htlc=htlc,
|
|
name=f'our_ctx_htlc_tx_{bh2u(htlc.payment_hash)}',
|
|
cltv_expiry=0 if is_received_htlc else htlc.cltv_expiry)
|
|
remote_htlc_sig = chan.get_remote_htlc_sig_for_htlc(htlc, we_receive=is_received_htlc, ctx=ctx)
|
|
local_htlc_sig = bfh(htlc_tx.sign_txin(0, local_htlc_privkey))
|
|
txin = htlc_tx.inputs()[0]
|
|
witness_program = bfh(Transaction.get_preimage_script(txin))
|
|
txin['witness'] = bh2u(make_htlc_tx_witness(remote_htlc_sig, local_htlc_sig, preimage, witness_program))
|
|
return witness_script, htlc_tx
|
|
|
|
|
|
def maybe_create_sweeptx_for_their_ctx_htlc(ctx: Transaction, sweep_address: str,
|
|
htlc_output_witness_script: bytes,
|
|
privkey: bytes, is_revocation: bool,
|
|
preimage: Optional[bytes], cltv_expiry: int = 0) -> Optional[Transaction]:
|
|
htlc_address = redeem_script_to_address('p2wsh', bh2u(htlc_output_witness_script))
|
|
# FIXME handle htlc_address collision
|
|
# also: https://github.com/lightningnetwork/lightning-rfc/issues/448
|
|
output_idx = ctx.get_output_idx_from_address(htlc_address)
|
|
if output_idx is None: return None
|
|
sweep_tx = create_sweeptx_their_ctx_htlc(ctx=ctx,
|
|
witness_script=htlc_output_witness_script,
|
|
sweep_address=sweep_address,
|
|
preimage=preimage,
|
|
output_idx=output_idx,
|
|
privkey=privkey,
|
|
is_revocation=is_revocation,
|
|
cltv_expiry=cltv_expiry)
|
|
return sweep_tx
|
|
|
|
|
|
def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep_address: str,
|
|
preimage: Optional[bytes], output_idx: int,
|
|
privkey: bytes, is_revocation: bool, cltv_expiry: int,
|
|
fee_per_kb: int=None) -> Optional[Transaction]:
|
|
assert type(cltv_expiry) is int
|
|
preimage = preimage or b'' # preimage is required iff (not is_revocation and htlc is offered)
|
|
val = ctx.outputs()[output_idx].value
|
|
sweep_inputs = [{
|
|
'scriptSig': '',
|
|
'type': 'p2wsh',
|
|
'signatures': [],
|
|
'num_sig': 0,
|
|
'prevout_n': output_idx,
|
|
'prevout_hash': ctx.txid(),
|
|
'value': val,
|
|
'coinbase': False,
|
|
'preimage_script': bh2u(witness_script),
|
|
}]
|
|
tx_size_bytes = 200 # TODO (depends on offered/received and is_revocation)
|
|
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
|
|
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
|
|
outvalue = val - fee
|
|
if outvalue <= dust_threshold(): return None
|
|
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
|
|
tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2
|
|
, name=f'their_ctx_sweep_htlc_{ctx.txid()[:8]}_{output_idx}'
|
|
# note that cltv_expiry, and therefore also locktime will be zero when breach!
|
|
, cltv_expiry=cltv_expiry, locktime=cltv_expiry)
|
|
|
|
sig = bfh(tx.sign_txin(0, privkey))
|
|
if not is_revocation:
|
|
witness = construct_witness([sig, preimage, witness_script])
|
|
else:
|
|
revocation_pubkey = privkey_to_pubkey(privkey)
|
|
witness = construct_witness([sig, revocation_pubkey, witness_script])
|
|
tx.inputs()[0]['witness'] = witness
|
|
assert tx.is_complete()
|
|
return tx
|
|
|
|
|
|
def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, output_idx: int,
|
|
our_payment_privkey: ecc.ECPrivkey,
|
|
fee_per_kb: int=None) -> Optional[Transaction]:
|
|
our_payment_pubkey = our_payment_privkey.get_public_key_hex(compressed=True)
|
|
val = ctx.outputs()[output_idx].value
|
|
sweep_inputs = [{
|
|
'type': 'p2wpkh',
|
|
'x_pubkeys': [our_payment_pubkey],
|
|
'num_sig': 1,
|
|
'prevout_n': output_idx,
|
|
'prevout_hash': ctx.txid(),
|
|
'value': val,
|
|
'coinbase': False,
|
|
'signatures': [None],
|
|
}]
|
|
tx_size_bytes = 110 # approx size of p2wpkh->p2wpkh
|
|
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
|
|
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
|
|
outvalue = val - fee
|
|
if outvalue <= dust_threshold(): return None
|
|
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
|
|
sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, name='their_ctx_to_remote')
|
|
sweep_tx.set_rbf(True)
|
|
sweep_tx.sign({our_payment_pubkey: (our_payment_privkey.get_secret_bytes(), True)})
|
|
if not sweep_tx.is_complete():
|
|
raise Exception('channel close sweep tx is not complete')
|
|
return sweep_tx
|
|
|
|
|
|
def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx: int, witness_script: str,
|
|
privkey: bytes, is_revocation: bool,
|
|
to_self_delay: int=None,
|
|
fee_per_kb: int=None) -> Optional[Transaction]:
|
|
"""Create a txn that sweeps the 'to_local' output of a commitment
|
|
transaction into our wallet.
|
|
|
|
privkey: either revocation_privkey or localdelayed_privkey
|
|
is_revocation: tells us which ^
|
|
"""
|
|
val = ctx.outputs()[output_idx].value
|
|
sweep_inputs = [{
|
|
'scriptSig': '',
|
|
'type': 'p2wsh',
|
|
'signatures': [],
|
|
'num_sig': 0,
|
|
'prevout_n': output_idx,
|
|
'prevout_hash': ctx.txid(),
|
|
'value': val,
|
|
'coinbase': False,
|
|
'preimage_script': witness_script,
|
|
}]
|
|
if not is_revocation:
|
|
assert isinstance(to_self_delay, int)
|
|
sweep_inputs[0]['sequence'] = to_self_delay
|
|
tx_size_bytes = 121 # approx size of to_local -> p2wpkh
|
|
if fee_per_kb is None:
|
|
fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
|
|
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
|
|
outvalue = val - fee
|
|
if outvalue <= dust_threshold():
|
|
return None
|
|
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
|
|
name = 'their_ctx_to_local' if is_revocation else 'our_ctx_to_local'
|
|
csv_delay = 0 if is_revocation else to_self_delay
|
|
sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, name=name, csv_delay=csv_delay)
|
|
sig = sweep_tx.sign_txin(0, privkey)
|
|
witness = construct_witness([sig, int(is_revocation), witness_script])
|
|
sweep_tx.inputs()[0]['witness'] = witness
|
|
return sweep_tx
|
|
|
|
|
|
def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
|
|
name_prefix: str,
|
|
htlc_tx: Transaction, htlctx_witness_script: bytes, sweep_address: str,
|
|
privkey: bytes, is_revocation: bool, to_self_delay: int,
|
|
fee_per_kb: int=None) -> Optional[Transaction]:
|
|
val = htlc_tx.outputs()[0].value
|
|
sweep_inputs = [{
|
|
'scriptSig': '',
|
|
'type': 'p2wsh',
|
|
'signatures': [],
|
|
'num_sig': 0,
|
|
'prevout_n': 0,
|
|
'prevout_hash': htlc_tx.txid(),
|
|
'value': val,
|
|
'coinbase': False,
|
|
'preimage_script': bh2u(htlctx_witness_script),
|
|
}]
|
|
if not is_revocation:
|
|
assert isinstance(to_self_delay, int)
|
|
sweep_inputs[0]['sequence'] = to_self_delay
|
|
tx_size_bytes = 200 # TODO
|
|
if fee_per_kb is None: fee_per_kb = FEERATE_FALLBACK_STATIC_FEE
|
|
fee = SimpleConfig.estimate_fee_for_feerate(fee_per_kb, tx_size_bytes)
|
|
outvalue = val - fee
|
|
if outvalue <= dust_threshold(): return None
|
|
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
|
|
tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, name=name_prefix + htlc_tx.txid(), csv_delay=to_self_delay)
|
|
|
|
sig = bfh(tx.sign_txin(0, privkey))
|
|
witness = construct_witness([sig, int(is_revocation), htlctx_witness_script])
|
|
tx.inputs()[0]['witness'] = witness
|
|
assert tx.is_complete()
|
|
return tx
|
|
|