class TestRebalance(TestCase):
def setUp(self):
self.node = LndNode()
def test_manual_rebalance(self):
manual_rebalance(self.node, 000000000000000000, 000000000000000000, amt=141248, number_of_routes=5)
def test_auto_rebalance(self):
rebalancer = Rebalancer(self.node, max_effective_fee_rate=1, budget_sat=10)
invoice_r_hash = self.node.get_rebalance_invoice(memo='autorebalance test')
rebalancer.rebalance_two_channels(000000000000000000, 000000000000000000, amt_sat=1,
invoice_r_hash=invoice_r_hash, budget_sat=10)
def test_rebalance(self):
rebalancer = Rebalancer(self.node, max_effective_fee_rate=0.0001, budget_sat=50)
channel_id = 000000000000000000
fee = rebalancer.rebalance(channel_id)
print(fee)
def main():
parser = Parser()
args = parser.parse_arguments()
# print(args)
if args.cmd is None:
parser.parser.print_help()
return 0
# program execution
if args.loglevel:
# update the loglevel of the stdout handler to the user choice
logger.handlers[0].setLevel(args.loglevel)
node = LndNode()
if args.cmd == 'status':
node.print_status()
elif args.cmd == 'listchannels':
if not args.subcmd:
print_channels_rebalance(node, unbalancedness_greater_than=0)
if args.subcmd == 'rebalance':
print_channels_rebalance(node, args.unbalancedness, sort_by='ub')
elif args.subcmd == 'inactive':
print_channels_hygiene(node)
elif args.subcmd == 'forwardings':
# convert time interval into unix timestamp
time_from = time.time() - args.from_days_ago * 24 * 60 * 60
time_to = time.time() - args.to_days_ago * 24 * 60 * 60
print_channels_forwardings(node,
sort_by=args.sort_by,
time_interval_start=time_from,
time_interval_end=time_to)
elif args.cmd == 'rebalance':
if args.target:
logger.warning(
"Warning: Target is set, this is still an experimental feature."
)
rebalancer = Rebalancer(node, args.max_fee_rate, args.max_fee_sat)
try:
rebalancer.rebalance(args.channel,
dry=not args.reckless,
chunksize=args.chunksize,
target=args.target,
allow_unbalancing=args.allow_unbalancing,
strategy=args.strategy)
except RebalanceFailure as e:
logger.error(f"Error: {e}")
elif args.cmd == 'circle':
rebalancer = Rebalancer(node, args.max_fee_rate, args.max_fee_sat)
invoice_r_hash = node.get_rebalance_invoice(memo='circular payment')
try:
rebalancer.rebalance_two_channels(args.channel_from,
args.channel_to,
args.amt_sats,
invoice_r_hash,
args.max_fee_sat,
dry=not args.reckless)
except DryRunException:
logger.info("This was just a dry run.")
except TooExpensive:
logger.error(
"Payment failed. This is likely due to a too low default --max-fee-rate."
)
except PaymentTimeOut:
logger.error(
"Payment failed because the payment timed out. This is an unresolved issue."
)
elif args.cmd == 'recommend-nodes':
if not args.subcmd:
parser.parser_recommend_nodes.print_help()
return 0
recommend_nodes = RecommendNodes(node,
show_connected=args.show_connected,
show_addresses=args.show_addresses)
if args.subcmd == 'good-old':
recommend_nodes.print_good_old(number_of_nodes=args.nnodes,
sort_by=args.sort_by)
