mirror of
https://github.com/LBRYFoundation/LBRY-Vault.git
synced 2025-08-31 09:21:39 +00:00
transaction: kill "name", "csv_delay", "cltv_expiry" fields
This commit is contained in:
SomberNight
parent
e5502a58ba
commit
befa8ea771
9 changed files with 81 additions and 75 deletions
|
|
@ -49,7 +49,7 @@ from .lnutil import (Outpoint, LocalConfig, RemoteConfig, Keypair, OnlyPubkeyKey
|
|||
ShortChannelID, map_htlcs_to_ctx_output_idxs)
|
||||
from .lnutil import FeeUpdate
|
||||
from .lnsweep import create_sweeptxs_for_our_ctx, create_sweeptxs_for_their_ctx
|
||||
from .lnsweep import create_sweeptx_for_their_revoked_htlc
|
||||
from .lnsweep import create_sweeptx_for_their_revoked_htlc, SweepInfo
|
||||
from .lnhtlc import HTLCManager
|
||||
|
||||
|
||||
|
|
@ -146,7 +146,7 @@ class Channel(Logger):
|
|||
self._is_funding_txo_spent = None # "don't know"
|
||||
self._state = None
|
||||
self.set_state('DISCONNECTED')
|
||||
self.sweep_info = {}
|
||||
self.sweep_info = {} # type: Dict[str, Dict[str, SweepInfo]]
|
||||
self._outgoing_channel_update = None # type: Optional[bytes]
|
||||
|
||||
def get_feerate(self, subject, ctn):
|
||||
|
|
@ -756,7 +756,7 @@ class Channel(Logger):
|
|||
assert tx.is_complete()
|
||||
return tx
|
||||
|
||||
def sweep_ctx(self, ctx: Transaction):
|
||||
def sweep_ctx(self, ctx: Transaction) -> Dict[str, SweepInfo]:
|
||||
txid = ctx.txid()
|
||||
if self.sweep_info.get(txid) is None:
|
||||
our_sweep_info = create_sweeptxs_for_our_ctx(chan=self, ctx=ctx, sweep_address=self.sweep_address)
|
||||
|
|
|
|||
|
|
@ -26,6 +26,11 @@ if TYPE_CHECKING:
|
|||
_logger = get_logger(__name__)
|
||||
|
||||
|
||||
class SweepInfo(NamedTuple):
|
||||
name: str
|
||||
csv_delay: int
|
||||
cltv_expiry: int
|
||||
gen_tx: Callable[[], Optional[Transaction]]
|
||||
|
||||
|
||||
def create_sweeptxs_for_watchtower(chan: 'Channel', ctx: Transaction, per_commitment_secret: bytes,
|
||||
|
|
@ -70,7 +75,6 @@ def create_sweeptxs_for_watchtower(chan: 'Channel', ctx: Transaction, per_commit
|
|||
htlc=htlc,
|
||||
ctx_output_idx=ctx_output_idx)
|
||||
return 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,
|
||||
|
|
@ -122,7 +126,7 @@ def create_sweeptx_for_their_revoked_ctx(chan: 'Channel', ctx: Transaction, per_
|
|||
return None
|
||||
|
||||
def create_sweeptx_for_their_revoked_htlc(chan: 'Channel', ctx: Transaction, htlc_tx: Transaction,
|
||||
sweep_address: str) -> Optional[Tuple[str, int, int, Callable]]:
|
||||
sweep_address: str) -> Optional[SweepInfo]:
|
||||
x = analyze_ctx(chan, ctx)
|
||||
if not x:
|
||||
return
|
||||
|
|
@ -153,12 +157,15 @@ def create_sweeptx_for_their_revoked_htlc(chan: 'Channel', ctx: Transaction, htl
|
|||
privkey=other_revocation_privkey,
|
||||
is_revocation=True)
|
||||
|
||||
return 'redeem_htlc2', 0, 0, gen_tx
|
||||
return SweepInfo(name='redeem_htlc2',
|
||||
csv_delay=0,
|
||||
cltv_expiry=0,
|
||||
gen_tx=gen_tx)
|
||||
|
||||
|
||||
|
||||
def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
|
||||
sweep_address: str) -> Optional[Dict[str, Tuple]]:
|
||||
sweep_address: str) -> Optional[Dict[str, SweepInfo]]:
|
||||
"""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),
|
||||
|
|
@ -194,7 +201,7 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
if ctn < chan.get_oldest_unrevoked_ctn(LOCAL):
|
||||
_logger.info("we breached.")
|
||||
return {}
|
||||
txs = {}
|
||||
txs = {} # type: Dict[str, SweepInfo]
|
||||
# to_local
|
||||
output_idxs = ctx.get_output_idxs_from_address(to_local_address)
|
||||
if output_idxs:
|
||||
|
|
@ -208,7 +215,10 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
is_revocation=False,
|
||||
to_self_delay=to_self_delay)
|
||||
prevout = ctx.txid() + ':%d'%output_idx
|
||||
txs[prevout] = ('our_ctx_to_local', to_self_delay, 0, sweep_tx)
|
||||
txs[prevout] = SweepInfo(name='our_ctx_to_local',
|
||||
csv_delay=to_self_delay,
|
||||
cltv_expiry=0,
|
||||
gen_tx=sweep_tx)
|
||||
# HTLCs
|
||||
def create_txns_for_htlc(*, htlc: 'UpdateAddHtlc', htlc_direction: Direction,
|
||||
ctx_output_idx: int, htlc_relative_idx: int):
|
||||
|
|
@ -231,7 +241,6 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
ctx_output_idx=ctx_output_idx,
|
||||
htlc_relative_idx=htlc_relative_idx)
|
||||
sweep_tx = lambda: create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
|
||||
'our_ctx_htlc_',
|
||||
to_self_delay=to_self_delay,
|
||||
htlc_tx=htlc_tx,
|
||||
htlctx_witness_script=htlctx_witness_script,
|
||||
|
|
@ -239,8 +248,14 @@ def create_sweeptxs_for_our_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
privkey=our_localdelayed_privkey.get_secret_bytes(),
|
||||
is_revocation=False)
|
||||
# side effect
|
||||
txs[htlc_tx.prevout(0)] = ('first-stage-htlc', 0, htlc_tx.cltv_expiry, lambda: htlc_tx)
|
||||
txs[htlc_tx.txid() + ':0'] = ('second-stage-htlc', to_self_delay, 0, sweep_tx)
|
||||
txs[htlc_tx.prevout(0)] = SweepInfo(name='first-stage-htlc',
|
||||
csv_delay=0,
|
||||
cltv_expiry=htlc_tx.locktime,
|
||||
gen_tx=lambda: htlc_tx)
|
||||
txs[htlc_tx.txid() + ':0'] = SweepInfo(name='second-stage-htlc',
|
||||
csv_delay=to_self_delay,
|
||||
cltv_expiry=0,
|
||||
gen_tx=sweep_tx)
|
||||
|
||||
# offered HTLCs, in our ctx --> "timeout"
|
||||
# received HTLCs, in our ctx --> "success"
|
||||
|
|
@ -285,12 +300,12 @@ def analyze_ctx(chan: 'Channel', ctx: Transaction):
|
|||
return ctn, their_pcp, is_revocation, per_commitment_secret
|
||||
|
||||
def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
|
||||
sweep_address: str) -> Optional[Dict[str,Tuple]]:
|
||||
sweep_address: str) -> Optional[Dict[str,SweepInfo]]:
|
||||
"""Handle the case when the remote force-closes with their ctx.
|
||||
Sweep outputs that do not have a CSV delay ('to_remote' and first-stage HTLCs).
|
||||
Outputs with CSV delay ('to_local' and second-stage HTLCs) are redeemed by LNWatcher.
|
||||
"""
|
||||
txs = {}
|
||||
txs = {} # type: Dict[str, SweepInfo]
|
||||
our_conf, their_conf = get_ordered_channel_configs(chan=chan, for_us=True)
|
||||
x = analyze_ctx(chan, ctx)
|
||||
if not x:
|
||||
|
|
@ -315,7 +330,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
gen_tx = create_sweeptx_for_their_revoked_ctx(chan, ctx, per_commitment_secret, chan.sweep_address)
|
||||
if gen_tx:
|
||||
tx = gen_tx()
|
||||
txs[tx.prevout(0)] = ('to_local_for_revoked_ctx', 0, 0, gen_tx)
|
||||
txs[tx.prevout(0)] = SweepInfo(name='to_local_for_revoked_ctx',
|
||||
csv_delay=0,
|
||||
cltv_expiry=0,
|
||||
gen_tx=gen_tx)
|
||||
# prep
|
||||
our_htlc_privkey = derive_privkey(secret=int.from_bytes(our_conf.htlc_basepoint.privkey, 'big'), per_commitment_point=their_pcp)
|
||||
our_htlc_privkey = ecc.ECPrivkey.from_secret_scalar(our_htlc_privkey)
|
||||
|
|
@ -335,7 +353,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
ctx=ctx,
|
||||
output_idx=output_idx,
|
||||
our_payment_privkey=our_payment_privkey)
|
||||
txs[prevout] = ('their_ctx_to_remote', 0, 0, sweep_tx)
|
||||
txs[prevout] = SweepInfo(name='their_ctx_to_remote',
|
||||
csv_delay=0,
|
||||
cltv_expiry=0,
|
||||
gen_tx=sweep_tx)
|
||||
# HTLCs
|
||||
def create_sweeptx_for_htlc(htlc: 'UpdateAddHtlc', is_received_htlc: bool,
|
||||
ctx_output_idx: int) -> None:
|
||||
|
|
@ -366,8 +387,10 @@ def create_sweeptxs_for_their_ctx(*, chan: 'Channel', ctx: Transaction,
|
|||
privkey=our_revocation_privkey if is_revocation else our_htlc_privkey.get_secret_bytes(),
|
||||
is_revocation=is_revocation,
|
||||
cltv_expiry=cltv_expiry)
|
||||
name = f'their_ctx_htlc_{ctx_output_idx}'
|
||||
txs[prevout] = (name, 0, cltv_expiry, sweep_tx)
|
||||
txs[prevout] = SweepInfo(name=f'their_ctx_htlc_{ctx_output_idx}',
|
||||
csv_delay=0,
|
||||
cltv_expiry=cltv_expiry,
|
||||
gen_tx=sweep_tx)
|
||||
|
||||
# received HTLCs, in their ctx --> "timeout"
|
||||
# offered HTLCs, in their ctx --> "success"
|
||||
|
|
@ -429,10 +452,7 @@ def create_sweeptx_their_ctx_htlc(ctx: Transaction, witness_script: bytes, sweep
|
|||
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_htlc_{output_idx}'
|
||||
# note that cltv_expiry, and therefore also locktime will be zero when breach!
|
||||
, cltv_expiry=cltv_expiry, locktime=cltv_expiry)
|
||||
tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, locktime=cltv_expiry)
|
||||
sig = bfh(tx.sign_txin(0, privkey))
|
||||
if not is_revocation:
|
||||
witness = construct_witness([sig, preimage, witness_script])
|
||||
|
|
@ -463,7 +483,7 @@ def create_sweeptx_their_ctx_to_remote(sweep_address: str, ctx: Transaction, out
|
|||
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 = Transaction.from_io(sweep_inputs, sweep_outputs)
|
||||
sweep_tx.set_rbf(True)
|
||||
sweep_tx.sign({our_payment_pubkey: (our_payment_privkey.get_secret_bytes(), True)})
|
||||
if not sweep_tx.is_complete():
|
||||
|
|
@ -501,17 +521,14 @@ def create_sweeptx_ctx_to_local(sweep_address: str, ctx: Transaction, output_idx
|
|||
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)
|
||||
sweep_tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2)
|
||||
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,
|
||||
def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(*,
|
||||
htlc_tx: Transaction, htlctx_witness_script: bytes, sweep_address: str,
|
||||
privkey: bytes, is_revocation: bool, to_self_delay: int) -> Optional[Transaction]:
|
||||
val = htlc_tx.outputs()[0].value
|
||||
|
|
@ -534,8 +551,7 @@ def create_sweeptx_that_spends_htlctx_that_spends_htlc_in_ctx(
|
|||
outvalue = val - fee
|
||||
if outvalue <= dust_threshold(): return None
|
||||
sweep_outputs = [TxOutput(TYPE_ADDRESS, sweep_address, outvalue)]
|
||||
name = name_prefix + htlc_tx.txid()[0:4]
|
||||
tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2, name=name, csv_delay=to_self_delay)
|
||||
tx = Transaction.from_io(sweep_inputs, sweep_outputs, version=2)
|
||||
|
||||
sig = bfh(tx.sign_txin(0, privkey))
|
||||
witness = construct_witness([sig, int(is_revocation), htlctx_witness_script])
|
||||
|
|
|
|||
|
|
@ -318,10 +318,10 @@ def make_htlc_tx_inputs(htlc_output_txid: str, htlc_output_index: int,
|
|||
}]
|
||||
return c_inputs
|
||||
|
||||
def make_htlc_tx(cltv_timeout, inputs, output, name, cltv_expiry):
|
||||
assert type(cltv_timeout) is int
|
||||
def make_htlc_tx(*, cltv_expiry: int, inputs, output) -> Transaction:
|
||||
assert type(cltv_expiry) is int
|
||||
c_outputs = [output]
|
||||
tx = Transaction.from_io(inputs, c_outputs, locktime=cltv_timeout, version=2, name=name, cltv_expiry=cltv_expiry)
|
||||
tx = Transaction.from_io(inputs, c_outputs, locktime=cltv_expiry, version=2)
|
||||
return tx
|
||||
|
||||
def make_offered_htlc(revocation_pubkey: bytes, remote_htlcpubkey: bytes,
|
||||
|
|
@ -468,8 +468,7 @@ def make_htlc_tx_with_open_channel(*, chan: 'Channel', pcp: bytes, subject: 'HTL
|
|||
witness_script=bh2u(preimage_script))
|
||||
if is_htlc_success:
|
||||
cltv_expiry = 0
|
||||
htlc_tx = make_htlc_tx(cltv_expiry, inputs=htlc_tx_inputs, output=htlc_tx_output,
|
||||
name=name, cltv_expiry=cltv_expiry)
|
||||
htlc_tx = make_htlc_tx(cltv_expiry=cltv_expiry, inputs=htlc_tx_inputs, output=htlc_tx_output)
|
||||
return witness_script_of_htlc_tx_output, htlc_tx
|
||||
|
||||
def make_funding_input(local_funding_pubkey: bytes, remote_funding_pubkey: bytes,
|
||||
|
|
@ -672,7 +671,8 @@ def get_compressed_pubkey_from_bech32(bech32_pubkey: str) -> bytes:
|
|||
|
||||
|
||||
def make_closing_tx(local_funding_pubkey: bytes, remote_funding_pubkey: bytes,
|
||||
funding_txid: bytes, funding_pos: int, funding_sat: int, outputs: List[TxOutput]):
|
||||
funding_txid: bytes, funding_pos: int, funding_sat: int,
|
||||
outputs: List[TxOutput]) -> Transaction:
|
||||
c_input = make_funding_input(local_funding_pubkey, remote_funding_pubkey,
|
||||
funding_pos, funding_txid, funding_sat)
|
||||
c_input['sequence'] = 0xFFFF_FFFF
|
||||
|
|
|
|||
|
|
@ -268,16 +268,16 @@ class WatchTower(LNWatcher):
|
|||
for tx in sweep_txns:
|
||||
await self.broadcast_or_log(funding_outpoint, tx)
|
||||
|
||||
async def broadcast_or_log(self, funding_outpoint, tx):
|
||||
async def broadcast_or_log(self, funding_outpoint: str, tx: Transaction):
|
||||
height = self.get_tx_height(tx.txid()).height
|
||||
if height != TX_HEIGHT_LOCAL:
|
||||
return
|
||||
try:
|
||||
txid = await self.network.broadcast_transaction(tx)
|
||||
except Exception as e:
|
||||
self.logger.info(f'broadcast failure: {tx.name}: {repr(e)}')
|
||||
self.logger.info(f'broadcast failure: txid={tx.txid()}, funding_outpoint={funding_outpoint}: {repr(e)}')
|
||||
else:
|
||||
self.logger.info(f'broadcast success: {tx.name}')
|
||||
self.logger.info(f'broadcast success: txid={tx.txid()}, funding_outpoint={funding_outpoint}')
|
||||
if funding_outpoint in self.tx_progress:
|
||||
await self.tx_progress[funding_outpoint].tx_queue.put(tx)
|
||||
return txid
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@ from .lnwatcher import LNWatcher
|
|||
if TYPE_CHECKING:
|
||||
from .network import Network
|
||||
from .wallet import Abstract_Wallet
|
||||
from .lnsweep import SweepInfo
|
||||
|
||||
|
||||
NUM_PEERS_TARGET = 4
|
||||
|
|
@ -601,11 +602,11 @@ class LNWallet(LNWorker):
|
|||
if chan.short_channel_id is not None:
|
||||
self.channel_db.remove_channel(chan.short_channel_id)
|
||||
# detect who closed and set sweep_info
|
||||
sweep_info = chan.sweep_ctx(closing_tx)
|
||||
self.logger.info(f'sweep_info length: {len(sweep_info)}')
|
||||
sweep_info_dict = chan.sweep_ctx(closing_tx)
|
||||
self.logger.info(f'sweep_info_dict length: {len(sweep_info_dict)}')
|
||||
# create and broadcast transaction
|
||||
for prevout, e_tx in sweep_info.items():
|
||||
name, csv_delay, cltv_expiry, gen_tx = e_tx
|
||||
for prevout, sweep_info in sweep_info_dict.items():
|
||||
name = sweep_info.name
|
||||
spender = spenders.get(prevout)
|
||||
if spender is not None:
|
||||
spender_tx = await self.network.get_transaction(spender)
|
||||
|
|
@ -622,31 +623,31 @@ class LNWallet(LNWorker):
|
|||
self.logger.info(f'outpoint already spent {name}: {prevout}')
|
||||
else:
|
||||
self.logger.info(f'trying to redeem {name}: {prevout}')
|
||||
await self.try_redeem(prevout, e_tx)
|
||||
await self.try_redeem(prevout, sweep_info)
|
||||
|
||||
@log_exceptions
|
||||
async def try_redeem(self, prevout, e_tx):
|
||||
name, csv_delay, cltv_expiry, gen_tx = e_tx
|
||||
async def try_redeem(self, prevout: str, sweep_info: 'SweepInfo') -> None:
|
||||
name = sweep_info.name
|
||||
prev_txid, prev_index = prevout.split(':')
|
||||
broadcast = True
|
||||
if cltv_expiry:
|
||||
if sweep_info.cltv_expiry:
|
||||
local_height = self.network.get_local_height()
|
||||
remaining = cltv_expiry - local_height
|
||||
remaining = sweep_info.cltv_expiry - local_height
|
||||
if remaining > 0:
|
||||
self.logger.info('waiting for {}: CLTV ({} > {}), prevout {}'
|
||||
.format(name, local_height, cltv_expiry, prevout))
|
||||
.format(name, local_height, sweep_info.cltv_expiry, prevout))
|
||||
broadcast = False
|
||||
if csv_delay:
|
||||
if sweep_info.csv_delay:
|
||||
prev_height = self.lnwatcher.get_tx_height(prev_txid)
|
||||
remaining = csv_delay - prev_height.conf
|
||||
remaining = sweep_info.csv_delay - prev_height.conf
|
||||
if remaining > 0:
|
||||
self.logger.info('waiting for {}: CSV ({} >= {}), prevout: {}'
|
||||
.format(name, prev_height.conf, csv_delay, prevout))
|
||||
.format(name, prev_height.conf, sweep_info.csv_delay, prevout))
|
||||
broadcast = False
|
||||
tx = gen_tx()
|
||||
self.wallet.set_label(tx.txid(), name)
|
||||
tx = sweep_info.gen_tx()
|
||||
if tx is None:
|
||||
self.logger.info(f'{name} could not claim output: {prevout}, dust')
|
||||
self.wallet.set_label(tx.txid(), name)
|
||||
if broadcast:
|
||||
try:
|
||||
await self.network.broadcast_transaction(tx)
|
||||
|
|
|
|||
|
|
@ -62,6 +62,8 @@ from .logging import get_logger, Logger
|
|||
|
||||
if TYPE_CHECKING:
|
||||
from .channel_db import ChannelDB
|
||||
from .lnworker import LNGossip
|
||||
from .lnwatcher import WatchTower
|
||||
|
||||
|
||||
_logger = get_logger(__name__)
|
||||
|
|
@ -311,8 +313,8 @@ class Network(Logger):
|
|||
self.local_watchtower = lnwatcher.WatchTower(self) if self.config.get('local_watchtower', False) else None
|
||||
else:
|
||||
self.channel_db = None # type: Optional[ChannelDB]
|
||||
self.lngossip = None
|
||||
self.local_watchtower = None
|
||||
self.lngossip = None # type: Optional[LNGossip]
|
||||
self.local_watchtower = None # type: Optional[WatchTower]
|
||||
|
||||
def run_from_another_thread(self, coro, *, timeout=None):
|
||||
assert self._loop_thread != threading.current_thread(), 'must not be called from network thread'
|
||||
|
|
|
|||
|
|
@ -553,11 +553,10 @@ class TestLNUtil(unittest.TestCase):
|
|||
htlc_output_index=htlc_output_index,
|
||||
amount_msat=amount_msat,
|
||||
witness_script=bh2u(htlc))
|
||||
our_htlc_tx = make_htlc_tx(cltv_timeout,
|
||||
our_htlc_tx = make_htlc_tx(
|
||||
cltv_expiry=cltv_timeout,
|
||||
inputs=our_htlc_tx_inputs,
|
||||
output=our_htlc_tx_output,
|
||||
name='test',
|
||||
cltv_expiry=0)
|
||||
output=our_htlc_tx_output)
|
||||
|
||||
local_sig = our_htlc_tx.sign_txin(0, local_privkey[:-1])
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ class TestTransaction(SequentialTestCase):
|
|||
self.assertEqual(tx.deserialize(), expected)
|
||||
self.assertEqual(tx.deserialize(), None)
|
||||
|
||||
self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True, 'csv_delay': 0, 'cltv_expiry': 0, 'name': None})
|
||||
self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True})
|
||||
self.assertEqual(tx.get_outputs_for_UI(), [TxOutputForUI('14CHYaaByjJZpx4oHBpfDMdqhTyXnZ3kVs', 1000000)])
|
||||
|
||||
self.assertTrue(tx.has_address('14CHYaaByjJZpx4oHBpfDMdqhTyXnZ3kVs'))
|
||||
|
|
@ -127,7 +127,7 @@ class TestTransaction(SequentialTestCase):
|
|||
tx = transaction.Transaction(signed_blob)
|
||||
self.assertEqual(tx.deserialize(), expected)
|
||||
self.assertEqual(tx.deserialize(), None)
|
||||
self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True, 'csv_delay': 0, 'cltv_expiry': 0, 'name': None})
|
||||
self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True})
|
||||
|
||||
self.assertEqual(tx.serialize(), signed_blob)
|
||||
|
||||
|
|
|
|||
|
|
@ -607,9 +607,6 @@ class Transaction:
|
|||
self._outputs = None # type: List[TxOutput]
|
||||
self.locktime = 0
|
||||
self.version = 2
|
||||
self.name = None
|
||||
self.csv_delay = 0
|
||||
self.cltv_expiry = 0
|
||||
# by default we assume this is a partial txn;
|
||||
# this value will get properly set when deserializing
|
||||
self.is_partial_originally = True
|
||||
|
|
@ -720,16 +717,13 @@ class Transaction:
|
|||
return d
|
||||
|
||||
@classmethod
|
||||
def from_io(klass, inputs, outputs, locktime=0, version=None, name=None, csv_delay=0, cltv_expiry=0):
|
||||
def from_io(klass, inputs, outputs, *, locktime=0, version=None):
|
||||
self = klass(None)
|
||||
self._inputs = inputs
|
||||
self._outputs = outputs
|
||||
self.locktime = locktime
|
||||
if version is not None:
|
||||
self.version = version
|
||||
self.name = name
|
||||
self.csv_delay = csv_delay
|
||||
self.cltv_expiry = cltv_expiry
|
||||
self.BIP69_sort()
|
||||
return self
|
||||
|
||||
|
|
@ -1229,9 +1223,6 @@ class Transaction:
|
|||
'hex': self.raw,
|
||||
'complete': self.is_complete(),
|
||||
'final': self.is_final(),
|
||||
'name': self.name,
|
||||
'csv_delay': self.csv_delay,
|
||||
'cltv_expiry': self.cltv_expiry,
|
||||
}
|
||||
return out
|
||||
|
||||
|
|
@ -1239,9 +1230,6 @@ class Transaction:
|
|||
def from_dict(cls, d):
|
||||
tx = cls(d['hex'])
|
||||
tx.deserialize(True)
|
||||
tx.name = d.get('name')
|
||||
tx.csv_delay = d.get('csv_delay', 0)
|
||||
tx.cltv_expiry = d.get('cltv_expiry', 0)
|
||||
return tx
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue