mirror of
https://github.com/aljazceru/plugins.git
synced 2025-12-25 08:54:20 +01:00
295 lines
10 KiB
Python
295 lines
10 KiB
Python
import os
|
|
import random
|
|
import string
|
|
|
|
import unittest
|
|
from pyln.testing.fixtures import * # noqa: F401,F403
|
|
from pyln.testing.utils import DEVELOPER, wait_for
|
|
|
|
|
|
plugin_path = os.path.join(os.path.dirname(__file__), "feeadjuster.py")
|
|
|
|
|
|
def test_feeadjuster_starts(node_factory):
|
|
l1 = node_factory.get_node()
|
|
# Test dynamically
|
|
l1.rpc.plugin_start(plugin_path)
|
|
l1.daemon.wait_for_log("Plugin feeadjuster initialized.*")
|
|
l1.rpc.plugin_stop(plugin_path)
|
|
l1.rpc.plugin_start(plugin_path)
|
|
l1.daemon.wait_for_log("Plugin feeadjuster initialized.*")
|
|
l1.stop()
|
|
# Then statically
|
|
l1.daemon.opts["plugin"] = plugin_path
|
|
l1.start()
|
|
# Start at 0 and 're-await' the two inits above. Otherwise this is flaky.
|
|
l1.daemon.logsearch_start = 0
|
|
l1.daemon.wait_for_logs(["Plugin feeadjuster initialized.*",
|
|
"Plugin feeadjuster initialized.*",
|
|
"Plugin feeadjuster initialized.*"])
|
|
l1.rpc.plugin_stop(plugin_path)
|
|
|
|
# We adjust fees in init
|
|
l1, l2, l3 = node_factory.line_graph(3, wait_for_announce=True)
|
|
scid_A = l2.rpc.listpeers(
|
|
l1.info["id"])["peers"][0]["channels"][0]["short_channel_id"]
|
|
scid_B = l2.rpc.listpeers(
|
|
l3.info["id"])["peers"][0]["channels"][0]["short_channel_id"]
|
|
l2.rpc.plugin_start(plugin_path)
|
|
l2.daemon.wait_for_logs([f"Adjusted fees of {scid_A}.*",
|
|
f"Adjusted fees of {scid_B}.*"])
|
|
|
|
|
|
def get_chan_fees(l, scid):
|
|
for half in l.rpc.listchannels(scid)["channels"]:
|
|
if l.info["id"] == half["source"]:
|
|
return (half["base_fee_millisatoshi"], half["fee_per_millionth"])
|
|
|
|
|
|
def wait_for_fees(l, scids, fees):
|
|
for scid in scids:
|
|
wait_for(lambda: get_chan_fees(l, scid) == fees)
|
|
|
|
|
|
def wait_for_not_fees(l, scids, fees):
|
|
for scid in scids:
|
|
wait_for(lambda: not get_chan_fees(l, scid) == fees)
|
|
|
|
|
|
def pay(l, ll, amount):
|
|
label = ''.join(random.choices(string.ascii_letters, k=20))
|
|
invoice = ll.rpc.invoice(amount, label, "desc")
|
|
route = l.rpc.getroute(ll.info["id"], amount, riskfactor=0, fuzzpercent=0)
|
|
l.rpc.sendpay(route["route"], invoice["payment_hash"], payment_secret=invoice.get('payment_secret'))
|
|
l.rpc.waitsendpay(invoice["payment_hash"])
|
|
|
|
|
|
def sync_gossip(nodes, scids):
|
|
node = nodes[0]
|
|
nodes = nodes[1:]
|
|
for scid in scids:
|
|
for n in nodes:
|
|
wait_for(lambda: node.rpc.listchannels(scid) == n.rpc.listchannels(scid))
|
|
|
|
|
|
@unittest.skipIf(not DEVELOPER, "Too slow without fast gossip")
|
|
def test_feeadjuster_adjusts(node_factory):
|
|
"""
|
|
A rather simple network:
|
|
|
|
A B
|
|
l1 <========> l2 <=========> l3
|
|
|
|
l2 will adjust its configuration-set base and proportional fees for
|
|
channels A and B as l1 and l3 exchange payments.
|
|
"""
|
|
base_fee = 5000
|
|
ppm_fee = 300
|
|
l2_opts = {
|
|
"fee-base": base_fee,
|
|
"fee-per-satoshi": ppm_fee,
|
|
"plugin": plugin_path,
|
|
"feeadjuster-deactivate-fuzz": None,
|
|
}
|
|
l1, l2, l3 = node_factory.line_graph(3, opts=[{}, l2_opts, {}],
|
|
wait_for_announce=True)
|
|
|
|
chan_A = l2.rpc.listpeers(l1.info["id"])["peers"][0]["channels"][0]
|
|
chan_B = l2.rpc.listpeers(l3.info["id"])["peers"][0]["channels"][0]
|
|
scid_A = chan_A["short_channel_id"]
|
|
scid_B = chan_B["short_channel_id"]
|
|
nodes = [l1, l2, l3]
|
|
scids = [scid_A, scid_B]
|
|
|
|
# Fees don't get updated until there is a forwarding event!
|
|
assert all([get_chan_fees(l2, scid) == (base_fee, ppm_fee)
|
|
for scid in scids])
|
|
|
|
chan_total = int(chan_A["total_msat"])
|
|
assert chan_total == int(chan_B["total_msat"])
|
|
|
|
# The first payment will trigger fee adjustment, no matter its value
|
|
amount = int(chan_total * 0.04)
|
|
pay(l1, l3, amount)
|
|
wait_for(lambda: all([get_chan_fees(l2, scid) != (base_fee, ppm_fee)
|
|
for scid in scids]))
|
|
|
|
# Send most of the balance to the other side..
|
|
amount = int(chan_total * 0.8)
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([f'Adjusted fees of {scid_A} with a ratio of 0.2',
|
|
f'Adjusted fees of {scid_B} with a ratio of 3.'])
|
|
|
|
# ..And back
|
|
sync_gossip(nodes, scids)
|
|
pay(l3, l1, amount)
|
|
l2.daemon.wait_for_logs([f'Adjusted fees of {scid_A} with a ratio of 6.',
|
|
f'Adjusted fees of {scid_B} with a ratio of 0.1'])
|
|
|
|
# Sending a payment worth 3% of the channel balance should not trigger
|
|
# fee adjustment
|
|
sync_gossip(nodes, scids)
|
|
fees_before = [get_chan_fees(l2, scid) for scid in [scid_A, scid_B]]
|
|
amount = int(chan_total * 0.03)
|
|
pay(l1, l3, amount)
|
|
sync_gossip(nodes, scids)
|
|
assert fees_before == [get_chan_fees(l2, scid) for scid in scids]
|
|
|
|
# But sending another 3%-worth payment does trigger adjustment (total sent
|
|
# since last adjustment is >5%)
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([f'Adjusted fees of {scid_A} with a ratio of 4.',
|
|
f'Adjusted fees of {scid_B} with a ratio of 0.2'])
|
|
|
|
|
|
@unittest.skipIf(not DEVELOPER, "Too slow without fast gossip")
|
|
def test_feeadjuster_imbalance(node_factory):
|
|
"""
|
|
A rather simple network:
|
|
|
|
A B
|
|
l1 <========> l2 <=========> l3
|
|
|
|
l2 will adjust its configuration-set base and proportional fees for
|
|
channels A and B as l1 and l3 exchange payments.
|
|
"""
|
|
base_fee = 5000
|
|
ppm_fee = 300
|
|
l2_opts = {
|
|
"fee-base": base_fee,
|
|
"fee-per-satoshi": ppm_fee,
|
|
"plugin": plugin_path,
|
|
"feeadjuster-deactivate-fuzz": None,
|
|
"feeadjuster-imbalance": 0.7, # should be normalized to 30/70
|
|
}
|
|
l1, l2, l3 = node_factory.line_graph(3, opts=[{}, l2_opts, {}],
|
|
wait_for_announce=True)
|
|
|
|
chan_A = l2.rpc.listpeers(l1.info["id"])["peers"][0]["channels"][0]
|
|
chan_B = l2.rpc.listpeers(l3.info["id"])["peers"][0]["channels"][0]
|
|
scid_A = chan_A["short_channel_id"]
|
|
scid_B = chan_B["short_channel_id"]
|
|
scids = [scid_A, scid_B]
|
|
default_fees = [(base_fee, ppm_fee), (base_fee, ppm_fee)]
|
|
|
|
chan_total = int(chan_A["total_msat"])
|
|
assert chan_total == int(chan_B["total_msat"])
|
|
l2.daemon.logsearch_start = 0
|
|
l2.daemon.wait_for_log('imbalance of 30%/70%')
|
|
|
|
# we force feeadjust initially to test this method and check if it applies
|
|
# default fees when balancing the channel below
|
|
l2.rpc.feeadjust()
|
|
l2.daemon.wait_for_logs([
|
|
f"Adjusted fees.*{scid_A}",
|
|
f"Adjusted fees.*{scid_B}"
|
|
])
|
|
log_offset = len(l2.daemon.logs)
|
|
wait_for_not_fees(l2, scids, default_fees[0])
|
|
|
|
# First bring channel to somewhat of a balance
|
|
amount = int(chan_total * 0.5)
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([
|
|
f'Set default fees as imbalance is too low: {scid_A}',
|
|
f'Set default fees as imbalance is too low: {scid_B}'
|
|
])
|
|
wait_for_fees(l2, scids, default_fees[0])
|
|
|
|
# Because of the 70/30 imbalance limiter, a 15% payment must not yet trigger
|
|
# 50% + 15% = 65% .. which is < 70%
|
|
amount = int(chan_total * 0.15)
|
|
pay(l1, l3, amount)
|
|
assert not l2.daemon.is_in_log("Adjusted fees", log_offset)
|
|
|
|
# Sending another 20% must now trigger because the imbalance
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([
|
|
f"Adjusted fees.*{scid_A}",
|
|
f"Adjusted fees.*{scid_B}"
|
|
])
|
|
wait_for_not_fees(l2, scids, default_fees[0])
|
|
|
|
# Bringing it back must cause default fees
|
|
pay(l3, l1, amount)
|
|
l2.daemon.wait_for_logs([
|
|
f'Set default fees as imbalance is too low: {scid_A}',
|
|
f'Set default fees as imbalance is too low: {scid_B}'
|
|
])
|
|
wait_for_fees(l2, scids, default_fees[0])
|
|
|
|
|
|
@unittest.skipIf(not DEVELOPER, "Too slow without fast gossip")
|
|
def test_feeadjuster_big_enough_liquidity(node_factory):
|
|
"""
|
|
A rather simple network:
|
|
|
|
A B
|
|
l1 <========> l2 <=========> l3
|
|
|
|
l2 will adjust its configuration-set base and proportional fees for
|
|
channels A and B as l1 and l3 exchange payments.
|
|
"""
|
|
base_fee = 5000
|
|
ppm_fee = 300
|
|
l2_opts = {
|
|
"fee-base": base_fee,
|
|
"fee-per-satoshi": ppm_fee,
|
|
"plugin": plugin_path,
|
|
"feeadjuster-deactivate-fuzz": None,
|
|
"feeadjuster-imbalance": 0.5,
|
|
"feeadjuster-enough-liquidity": "0.001btc",
|
|
"feeadjuster-threshold-abs": "0.0001btc",
|
|
}
|
|
# channels' size: 0.01btc
|
|
# between 0.001btc and 0.009btc the liquidity is big enough
|
|
l1, l2, l3 = node_factory.line_graph(3, fundamount=10**6, opts=[{}, l2_opts, {}],
|
|
wait_for_announce=True)
|
|
|
|
chan_A = l2.rpc.listpeers(l1.info["id"])["peers"][0]["channels"][0]
|
|
chan_B = l2.rpc.listpeers(l3.info["id"])["peers"][0]["channels"][0]
|
|
scid_A = chan_A["short_channel_id"]
|
|
scid_B = chan_B["short_channel_id"]
|
|
scids = [scid_A, scid_B]
|
|
default_fees = [(base_fee, ppm_fee), (base_fee, ppm_fee)]
|
|
|
|
chan_total = int(chan_A["total_msat"])
|
|
assert chan_total == int(chan_B["total_msat"])
|
|
l2.daemon.logsearch_start = 0
|
|
l2.daemon.wait_for_log('enough_liquidity: 100000000msat')
|
|
|
|
# we force feeadjust initially to test this method and check if it applies
|
|
# default fees when balancing the channel below
|
|
l2.rpc.feeadjust()
|
|
l2.daemon.wait_for_logs([
|
|
f"Adjusted fees.*{scid_A}",
|
|
f"Adjusted fees.*{scid_B}"
|
|
])
|
|
wait_for_not_fees(l2, scids, default_fees[0])
|
|
|
|
# Bring channels to beyond big enough liquidity with 0.003btc
|
|
amount = 300000000
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([
|
|
f"Adjusted fees of {scid_A} with a ratio of 1.0",
|
|
f"Adjusted fees of {scid_B} with a ratio of 1.0"
|
|
])
|
|
log_offset = len(l2.daemon.logs)
|
|
wait_for_fees(l2, scids, default_fees[0])
|
|
|
|
# Let's move another 0.003btc -> the channels will be at 0.006btc
|
|
amount = 300000000
|
|
pay(l1, l3, amount)
|
|
l2.wait_for_htlcs()
|
|
assert not l2.daemon.is_in_log("Adjusted fees", log_offset)
|
|
|
|
# Sending another 0.0033btc will result in a channel balance of 0.0093btc
|
|
# It must trigger because the remaining liquidity is not big enough
|
|
amount = 330000000
|
|
pay(l1, l3, amount)
|
|
l2.daemon.wait_for_logs([
|
|
f"Adjusted fees.*{scid_A}",
|
|
f"Adjusted fees.*{scid_B}"
|
|
])
|
|
wait_for_not_fees(l2, scids, default_fees[0])
|