mirror of
https://github.com/ElementsProject/lightning.git
synced 2025-02-22 22:45:27 +01:00
pytest: changed tests if we're using experimental-anchors.
This is in anticipation of changing the defaults for non-elements. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
parent
149be88b6e
commit
0a2f03ac1e
5 changed files with 119 additions and 74 deletions
|
|
@ -2643,8 +2643,9 @@ def test_onchain_different_fees(node_factory, bitcoind, executor):
|
|||
l2.daemon.wait_for_log('htlc 1: SENT_ADD_ACK_COMMIT->RCVD_ADD_ACK_REVOCATION')
|
||||
|
||||
# Restart with different feerate for second HTLC.
|
||||
l1.set_feerates((5000, 5000, 5000, 3750))
|
||||
l1.restart()
|
||||
l1.stop()
|
||||
l1.set_feerates((5000, 5000, 5000, 5000), wait_for_effect=False)
|
||||
l1.start()
|
||||
l1.daemon.wait_for_log('peer_out WIRE_UPDATE_FEE')
|
||||
|
||||
p3 = executor.submit(l1.pay, l2, 800000000)
|
||||
|
|
@ -2658,23 +2659,40 @@ def test_onchain_different_fees(node_factory, bitcoind, executor):
|
|||
l1.daemon.wait_for_log(' to ONCHAIN')
|
||||
l2.daemon.wait_for_log(' to ONCHAIN')
|
||||
|
||||
# Elements still uses non-anchor version.
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
expected = {'min_possible_feerate': 3750,
|
||||
'max_possible_feerate': 5005}
|
||||
else:
|
||||
expected = {'min_possible_feerate': 5005,
|
||||
'max_possible_feerate': 11005}
|
||||
|
||||
# Both sides should have correct feerate
|
||||
assert l1.db_query('SELECT min_possible_feerate, max_possible_feerate FROM channels;') == [{
|
||||
'min_possible_feerate': 5005,
|
||||
'max_possible_feerate': 11005
|
||||
}]
|
||||
assert l2.db_query('SELECT min_possible_feerate, max_possible_feerate FROM channels;') == [{
|
||||
'min_possible_feerate': 5005,
|
||||
'max_possible_feerate': 11005
|
||||
}]
|
||||
assert l1.db_query('SELECT min_possible_feerate, max_possible_feerate FROM channels;') == [expected]
|
||||
|
||||
assert l2.db_query('SELECT min_possible_feerate, max_possible_feerate FROM channels;') == [expected]
|
||||
|
||||
bitcoind.generate_block(5)
|
||||
# Three HTLCs, and one for the to-us output.
|
||||
l1.daemon.wait_for_logs(['sendrawtx exit 0'] * 4)
|
||||
|
||||
# We use 3 blocks for "reasonable depth"
|
||||
bitcoind.generate_block(3)
|
||||
# We will, over the next few blocks, spend the to-us and the HTLCs.
|
||||
# We don't have enough outputs, so the results are a bit random,
|
||||
# but we will make progress every block!
|
||||
mark = l1.daemon.logsearch_start
|
||||
|
||||
r = re.compile('sendrawtx exit 0')
|
||||
|
||||
def count_successful_txs():
|
||||
l1.daemon.logs_catchup()
|
||||
return sum([r.search(l) is not None for l in l1.daemon.logs[mark:]])
|
||||
|
||||
# First iteration we expect one HTLC-tx and the to-us, then two more htlc txs
|
||||
num_successful = 1
|
||||
while num_successful < 3 + 1:
|
||||
wait_for(lambda: count_successful_txs() > num_successful)
|
||||
num_successful = count_successful_txs()
|
||||
bitcoind.generate_block(1)
|
||||
|
||||
# This takes at least 3 blocks: now payments can fail
|
||||
with pytest.raises(Exception):
|
||||
p1.result(10)
|
||||
with pytest.raises(Exception):
|
||||
|
|
@ -2682,9 +2700,12 @@ def test_onchain_different_fees(node_factory, bitcoind, executor):
|
|||
with pytest.raises(Exception):
|
||||
p3.result(10)
|
||||
|
||||
# Two more for HTLC timeout tx to be spent.
|
||||
bitcoind.generate_block(2)
|
||||
l1.daemon.wait_for_logs(['sendrawtx exit 0'] * 3)
|
||||
# Now we need the return-to-wallet spending the htlc tx.
|
||||
bitcoind.generate_block(4)
|
||||
while num_successful < 3 + 3 + 1:
|
||||
wait_for(lambda: count_successful_txs() > num_successful)
|
||||
num_successful = count_successful_txs()
|
||||
bitcoind.generate_block(1)
|
||||
|
||||
# Now, 100 blocks it should be done.
|
||||
bitcoind.generate_block(100)
|
||||
|
|
@ -2898,7 +2919,7 @@ def test_onchain_multihtlc_our_unilateral(node_factory, bitcoind):
|
|||
# until l4 says 'all outputs resolved'.
|
||||
while not l4.daemon.is_in_log('All outputs resolved'):
|
||||
bitcoind.generate_block(1)
|
||||
assert bitcoind.rpc.getblockcount() < 200
|
||||
assert bitcoind.rpc.getblockcount() < 250
|
||||
sync_blockheight(bitcoind, [l4, l5])
|
||||
|
||||
# All payments should be long resolved.
|
||||
|
|
@ -2953,7 +2974,7 @@ def test_onchain_multihtlc_their_unilateral(node_factory, bitcoind):
|
|||
# until l5 says 'all outputs resolved'.
|
||||
while not l5.daemon.is_in_log('All outputs resolved'):
|
||||
bitcoind.generate_block(1)
|
||||
assert bitcoind.rpc.getblockcount() < 200
|
||||
assert bitcoind.rpc.getblockcount() < 250
|
||||
sync_blockheight(bitcoind, [l4, l5])
|
||||
|
||||
# All payments should be long resolved.
|
||||
|
|
@ -2981,6 +3002,8 @@ def test_permfail_htlc_in(node_factory, bitcoind, executor):
|
|||
|
||||
l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
|
||||
l1.fundchannel(l2, 10**6)
|
||||
# Give it some sats for anchor spend! (Extra for elements!)
|
||||
l2.fundwallet(30000, mine_block=False)
|
||||
|
||||
# This will fail at l2's end.
|
||||
t = executor.submit(l1.pay, l2, 200000000)
|
||||
|
|
@ -3574,11 +3597,9 @@ def test_close_feerate_range(node_factory, bitcoind, chainparams):
|
|||
|
||||
def test_close_twice(node_factory, executor):
|
||||
# First feerate is too low, second fixes it.
|
||||
l1, l2 = node_factory.line_graph(2, opts=[{'allow_warning': True,
|
||||
'may_reconnect': True},
|
||||
{'allow_warning': True,
|
||||
'may_reconnect': True,
|
||||
'feerates': (15000, 15000, 15000, 15000)}])
|
||||
l1, l2 = node_factory.line_graph(2, opts={'allow_warning': True,
|
||||
'may_reconnect': True,
|
||||
'feerates': (15000, 15000, 15000, 15000)})
|
||||
|
||||
# This makes it disconnect, since feerate is too low.
|
||||
fut = executor.submit(l1.rpc.close, l2.info['id'], feerange=['253perkw', '500perkw'])
|
||||
|
|
@ -3978,7 +3999,7 @@ def test_peer_anchor_push(node_factory, bitcoind, executor, chainparams):
|
|||
|
||||
|
||||
def test_closing_cpfp(node_factory, bitcoind):
|
||||
l1, l2 = node_factory.line_graph(2)
|
||||
l1, l2 = node_factory.line_graph(2, opts={'min-emergency-msat': '2500sat'})
|
||||
|
||||
# We want to ignore l1's change output
|
||||
change = only_one(l1.rpc.listfunds()['outputs'])
|
||||
|
|
@ -4004,4 +4025,8 @@ def test_closing_cpfp(node_factory, bitcoind):
|
|||
# They should now see a single additional output each
|
||||
sync_blockheight(bitcoind, [l1, l2])
|
||||
assert len(l1.rpc.listfunds()['outputs']) == 2
|
||||
assert len(l2.rpc.listfunds()['outputs']) == 1
|
||||
# This one will also have emergency change if anchors
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
assert len(l2.rpc.listfunds()['outputs']) == 2
|
||||
else:
|
||||
assert len(l2.rpc.listfunds()['outputs']) == 1
|
||||
|
|
|
|||
|
|
@ -437,8 +437,8 @@ def test_channel_abandon(node_factory, bitcoind):
|
|||
|
||||
SATS = 10**6
|
||||
|
||||
# Add some for fees
|
||||
l1.fundwallet(SATS + 10000)
|
||||
# Add some for fees/emergency-reserve
|
||||
l1.fundwallet(SATS + 35000)
|
||||
l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
|
||||
l1.rpc.fundchannel(l2.info['id'], SATS, feerate='1875perkw')
|
||||
|
||||
|
|
@ -1077,8 +1077,12 @@ def test_funding_all(node_factory, bitcoind):
|
|||
|
||||
l1.rpc.fundchannel(l2.info['id'], "all")
|
||||
|
||||
# Keeps emergency reserve!
|
||||
outputs = l1.db_query('SELECT value FROM outputs WHERE status=0;')
|
||||
assert len(outputs) == 0
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
assert outputs == [{'value': 25000}]
|
||||
else:
|
||||
assert outputs == []
|
||||
|
||||
|
||||
@pytest.mark.openchannel('v1')
|
||||
|
|
@ -1089,7 +1093,7 @@ def test_funding_all_too_much(node_factory):
|
|||
# l2 isn't wumbo, so channel should not be!
|
||||
l1, l2 = node_factory.line_graph(2, fundchannel=False, opts=[{}, {'dev-force-features': '-19'}])
|
||||
|
||||
addr, txid = l1.fundwallet(2**24 + 10000)
|
||||
addr, txid = l1.fundwallet(2**24 + 35000)
|
||||
l1.rpc.fundchannel(l2.info['id'], "all")
|
||||
assert l1.daemon.is_in_log("'all' was too large for non-wumbo channel, trimming")
|
||||
|
||||
|
|
@ -2419,7 +2423,10 @@ def test_update_fee(node_factory, bitcoind):
|
|||
# Make payments.
|
||||
l1.pay(l2, 200000000)
|
||||
# First payment causes fee update.
|
||||
l2.daemon.wait_for_log('peer updated fee to 11005')
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l2.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
l2.daemon.wait_for_log('peer updated fee to 3755')
|
||||
else:
|
||||
l2.daemon.wait_for_log('peer updated fee to 11005')
|
||||
l2.pay(l1, 100000000)
|
||||
|
||||
# Now shutdown cleanly.
|
||||
|
|
@ -2459,24 +2466,32 @@ def test_fee_limits(node_factory, bitcoind):
|
|||
# L1 asks for stupid low fee (will actually hit the floor of 253)
|
||||
l1.stop()
|
||||
l1.set_feerates((15, 15, 15, 15), False)
|
||||
# We need to increase l2's floor, so it rejects l1.
|
||||
l2.set_feerates((15000, 11000, 7500, 3750, 2000))
|
||||
l1.start()
|
||||
|
||||
l1.daemon.wait_for_log('Received WARNING .*: update_fee 258 outside range 1875-75000')
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
fee = 1255
|
||||
range = '2000-75000'
|
||||
else:
|
||||
fee = 258
|
||||
range = '1875-75000'
|
||||
l1.daemon.wait_for_log(f'Received WARNING .*: update_fee {fee} outside range {range}')
|
||||
# They hang up on *us*
|
||||
l1.daemon.wait_for_log('Peer transient failure in CHANNELD_NORMAL: channeld: Owning subdaemon channeld died')
|
||||
|
||||
# Disconnects, but does not error. Make sure it's noted in their status though.
|
||||
# FIXME: does not happen for l1!
|
||||
# assert 'update_fee 253 outside range 1875-75000' in only_one(l1.rpc.listpeerchannels(l2.info['id'])['channels'])['status'][0]
|
||||
assert 'update_fee 258 outside range 1875-75000' in only_one(l2.rpc.listpeerchannels(l1.info['id'])['channels'])['status'][0]
|
||||
assert f'update_fee {fee} outside range {range}' in only_one(l2.rpc.listpeerchannels(l1.info['id'])['channels'])['status'][0]
|
||||
|
||||
assert only_one(l2.rpc.listpeerchannels()['channels'])['feerate']['perkw'] != 258
|
||||
assert only_one(l2.rpc.listpeerchannels()['channels'])['feerate']['perkw'] != fee
|
||||
# Make l2 accept those fees, and it should recover.
|
||||
assert only_one(l2.rpc.setchannel(l1.get_channel_scid(l2), ignorefeelimits=True)['channels'])['ignore_fee_limits'] is True
|
||||
assert only_one(l2.rpc.listpeerchannels()['channels'])['ignore_fee_limits'] is True
|
||||
|
||||
# Now we stay happy (and connected!)
|
||||
wait_for(lambda: only_one(l2.rpc.listpeerchannels()['channels'])['feerate']['perkw'] == 258)
|
||||
wait_for(lambda: only_one(l2.rpc.listpeerchannels()['channels'])['feerate']['perkw'] == fee)
|
||||
assert only_one(l2.rpc.listpeerchannels()['channels'])['peer_connected'] is True
|
||||
|
||||
l1.rpc.close(l2.info['id'])
|
||||
|
|
@ -2490,7 +2505,7 @@ def test_fee_limits(node_factory, bitcoind):
|
|||
|
||||
# Trying to open a channel with too low a fee-rate is denied
|
||||
l1.rpc.connect(l4.info['id'], 'localhost', l4.port)
|
||||
with pytest.raises(RpcError, match='They sent (ERROR|WARNING) .* feerate_per_kw 253 below minimum'):
|
||||
with pytest.raises(RpcError, match='They sent (ERROR|WARNING) .* feerate_per_kw .* below minimum'):
|
||||
l1.fundchannel(l4, 10**6)
|
||||
|
||||
# Restore to normal.
|
||||
|
|
@ -2507,7 +2522,7 @@ def test_fee_limits(node_factory, bitcoind):
|
|||
|
||||
# Try stupid high fees
|
||||
l1.stop()
|
||||
l1.set_feerates((15000, 11000 * 10, 7500, 3750), False)
|
||||
l1.set_feerates((15000, 15000, 15000, 15000, 15000), False)
|
||||
l1.start()
|
||||
|
||||
l3.daemon.wait_for_log('peer_in WIRE_UPDATE_FEE')
|
||||
|
|
@ -2589,7 +2604,7 @@ def test_update_fee_reconnect(node_factory, bitcoind):
|
|||
|
||||
# Make l1 send out feechange; triggers disconnect/reconnect.
|
||||
# (Note: < 10% change, so no smoothing here!)
|
||||
l1.set_feerates((14000, 14000, 14000, 3750))
|
||||
l1.set_feerates((14000, 14000, 14000, 14000))
|
||||
l1.daemon.wait_for_log('Setting REMOTE feerate to 14005')
|
||||
l2.daemon.wait_for_log('Setting LOCAL feerate to 14005')
|
||||
l1.daemon.wait_for_log(r'dev_disconnect: \+WIRE_COMMITMENT_SIGNED')
|
||||
|
|
@ -3354,14 +3369,20 @@ def test_feerate_spam(node_factory, chainparams):
|
|||
l1.pay(l2, 10**9 - slack)
|
||||
|
||||
# It will send this once (may have happened before line_graph's wait)
|
||||
wait_for(lambda: l1.daemon.is_in_log('Setting REMOTE feerate to 11005'))
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
wait_for(lambda: l1.daemon.is_in_log('Setting REMOTE feerate to 3755'))
|
||||
else:
|
||||
wait_for(lambda: l1.daemon.is_in_log('Setting REMOTE feerate to 11005'))
|
||||
wait_for(lambda: l1.daemon.is_in_log('peer_out WIRE_UPDATE_FEE'))
|
||||
|
||||
# Now change feerates to something l1 can't afford.
|
||||
l1.set_feerates((100000, 100000, 100000, 100000))
|
||||
l1.set_feerates((200000, 200000, 200000, 200000))
|
||||
|
||||
# It will raise as far as it can (48000)
|
||||
maxfeerate = 48000
|
||||
# It will raise as far as it can (30000)
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
maxfeerate = 30000
|
||||
else:
|
||||
maxfeerate = 48000
|
||||
l1.daemon.wait_for_log('Setting REMOTE feerate to {}'.format(maxfeerate))
|
||||
l1.daemon.wait_for_log('peer_out WIRE_UPDATE_FEE')
|
||||
|
||||
|
|
|
|||
|
|
@ -295,15 +295,16 @@ def test_htlc_sig_persistence(node_factory, bitcoind, executor):
|
|||
_, txid, blocks = l1.wait_for_onchaind_tx('OUR_HTLC_TIMEOUT_TO_US',
|
||||
'THEIR_UNILATERAL/OUR_HTLC')
|
||||
assert blocks == 5
|
||||
|
||||
bitcoind.generate_block(5)
|
||||
bitcoind.generate_block(1, wait_for_mempool=txid)
|
||||
l1.daemon.wait_for_logs([
|
||||
r'Owning output . (\d+)sat .SEGWIT. txid',
|
||||
])
|
||||
|
||||
# We should now have a) the change from funding, b) the
|
||||
# unilateral to us, and c) the HTLC respend to us
|
||||
assert len(l1.rpc.listfunds()['outputs']) == 3
|
||||
# We should now have 1) the unilateral to us, and b) the HTLC respend to us
|
||||
# and maybe (c) change.
|
||||
assert 2 <= len(l1.rpc.listfunds()['outputs']) <= 3
|
||||
|
||||
|
||||
def test_htlc_out_timeout(node_factory, bitcoind, executor):
|
||||
|
|
@ -385,6 +386,8 @@ def test_htlc_in_timeout(node_factory, bitcoind, executor):
|
|||
options={'dev-no-reconnect': None},
|
||||
feerates=(7500, 7500, 7500, 7500))
|
||||
l2 = node_factory.get_node()
|
||||
# Give it some sats for anchor spend!
|
||||
l2.fundwallet(25000, mine_block=False)
|
||||
|
||||
l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
|
||||
chanid, _ = l1.fundchannel(l2, 10**6)
|
||||
|
|
@ -3876,9 +3879,15 @@ def test_set_feerate_offset(node_factory, bitcoind):
|
|||
|
||||
l1.pay(l2, 200000000)
|
||||
# First payment causes fee update, which should reflect the feerate offset.
|
||||
l1.daemon.wait_for_log('lightningd: update_feerates: feerate = 11100, '
|
||||
'min=1875, max=150000, penalty=7500')
|
||||
l2.daemon.wait_for_log('peer updated fee to 11100')
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
feerate = 3850
|
||||
min_feerate = 253
|
||||
else:
|
||||
feerate = 11100
|
||||
min_feerate = 1875
|
||||
l1.daemon.wait_for_log(f'lightningd: update_feerates: feerate = {feerate}, '
|
||||
f'min={min_feerate}, max=150000, penalty=7500')
|
||||
l2.daemon.wait_for_log(f'peer updated fee to {feerate}')
|
||||
l2.pay(l1, 100000000)
|
||||
|
||||
# Now shutdown cleanly.
|
||||
|
|
|
|||
|
|
@ -275,7 +275,10 @@ def test_pay_disconnect(node_factory, bitcoind):
|
|||
l1.set_feerates((10**6, 10**6, 10**6, 10**6), False)
|
||||
|
||||
# Wait for l1 notice
|
||||
l1.daemon.wait_for_log(r'WARNING .*: update_fee \d+ outside range 1875-75000')
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
l1.daemon.wait_for_log(r'WARNING .*: update_fee \d+ outside range 253-75000')
|
||||
else:
|
||||
l1.daemon.wait_for_log(r'WARNING .*: update_fee \d+ outside range 1875-75000')
|
||||
# They hang up on us
|
||||
l1.daemon.wait_for_log(r'Peer transient failure in CHANNELD_NORMAL')
|
||||
|
||||
|
|
@ -2736,42 +2739,25 @@ def test_htlc_too_dusty_outgoing(node_factory, bitcoind, chainparams):
|
|||
res = only_one(l1.rpc.listsendpays(payment_hash=inv['payment_hash'])['payments'])
|
||||
assert res['status'] == 'pending'
|
||||
|
||||
# Ok, adjust our feerate upward, so the non-dust htlcs are now dust
|
||||
# note that this is above the buffer we've been keeping, so the channel
|
||||
# should automatically fail
|
||||
l1.set_feerates([feerate * 2] * 4, False)
|
||||
l1.restart()
|
||||
|
||||
# Make sure fails before we try sending htlc!
|
||||
l1.daemon.wait_for_log('Too much dust to update fee')
|
||||
|
||||
# the channel should start warning -- too much dust
|
||||
inv = l2.rpc.invoice(htlc_val_msat, str(num_dusty_htlcs + 1), str(num_dusty_htlcs + 1))
|
||||
with pytest.raises(RpcError, match=r'WIRE_TEMPORARY_CHANNEL_FAILURE'):
|
||||
l1.rpc.sendpay(route, inv['payment_hash'], payment_secret=inv['payment_secret'])
|
||||
|
||||
|
||||
def test_htlc_too_dusty_incoming(node_factory, bitcoind):
|
||||
""" Try to hit the 'too much dust' limit, should fail the HTLC """
|
||||
feerate = 30000
|
||||
l1, l2, l3 = node_factory.line_graph(3, opts=[{'may_reconnect': True,
|
||||
'feerates': (feerate, feerate, feerate, feerate),
|
||||
'max-dust-htlc-exposure-msat': '200000sat'},
|
||||
{'may_reconnect': True,
|
||||
'feerates': (feerate, feerate, feerate, feerate),
|
||||
'max-dust-htlc-exposure-msat': '100000sat',
|
||||
'max-dust-htlc-exposure-msat': '1000sat',
|
||||
'fee-base': 0,
|
||||
'fee-per-satoshi': 0},
|
||||
{'max-dust-htlc-exposure-msat': '500000sat'}],
|
||||
{'max-dust-htlc-exposure-msat': '1000sat'}],
|
||||
wait_for_announce=True)
|
||||
|
||||
# on the l2->l3, and l3 holds all the htlcs hostage
|
||||
# have l3 hold onto all the htlcs and not fulfill them
|
||||
l3.rpc.dev_ignore_htlcs(id=l2.info['id'], ignore=True)
|
||||
|
||||
# l2's max dust limit is set to 100k
|
||||
max_dust_limit_sat = 100000
|
||||
htlc_val_sat = 10000
|
||||
# l2's max dust limit is set to 1k
|
||||
max_dust_limit_sat = 1000
|
||||
htlc_val_sat = 250
|
||||
htlc_val_msat = htlc_val_sat * 1000
|
||||
num_dusty_htlcs = max_dust_limit_sat // htlc_val_sat
|
||||
route = l1.rpc.getroute(l3.info['id'], htlc_val_msat, 1)['route']
|
||||
|
|
|
|||
|
|
@ -668,12 +668,16 @@ def test_openchannel_hook(node_factory, bitcoind):
|
|||
'to_self_delay': '5',
|
||||
}
|
||||
|
||||
if 'anchors_zero_fee_htlc_tx/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:
|
||||
feerate = 3750
|
||||
else:
|
||||
feerate = 7500
|
||||
if l2.config('experimental-dual-fund'):
|
||||
# openchannel2 var checks
|
||||
expected.update({
|
||||
'channel_id': '.*',
|
||||
'channel_max_msat': 2100000000000000000,
|
||||
'commitment_feerate_per_kw': '7500',
|
||||
'commitment_feerate_per_kw': feerate,
|
||||
'funding_feerate_per_kw': '7500',
|
||||
'feerate_our_max': '150000',
|
||||
'feerate_our_min': '1875',
|
||||
|
|
@ -684,7 +688,7 @@ def test_openchannel_hook(node_factory, bitcoind):
|
|||
else:
|
||||
expected.update({
|
||||
'channel_reserve_msat': 1000000,
|
||||
'feerate_per_kw': '7500',
|
||||
'feerate_per_kw': feerate,
|
||||
'funding_msat': 100000000,
|
||||
'push_msat': 0,
|
||||
})
|
||||
|
|
@ -1879,7 +1883,7 @@ def test_hook_crash(node_factory, executor, bitcoind):
|
|||
# For simplicity, give us N UTXOs to spend.
|
||||
addr = l1.rpc.newaddr('p2tr')['p2tr']
|
||||
for n in nodes:
|
||||
bitcoind.rpc.sendtoaddress(addr, (FUNDAMOUNT + 5000) / 10**8)
|
||||
bitcoind.rpc.sendtoaddress(addr, (FUNDAMOUNT + 30000) / 10**8)
|
||||
bitcoind.generate_block(1, wait_for_mempool=len(nodes))
|
||||
sync_blockheight(bitcoind, [l1])
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue