How to implement rebalancing?

[bonomat]

Hi all,

we are in the need of rebalancing our channels and wondered what the best approach would be to implement it.

I've explored two approaches but neither worked so far

1. Create an invoice and add 2 routing hints for the inbound and outbound channel.
   1. This fails with no-route-found error
2. Use get_route and then I wanted to use send_payment_with_route
   1. This fails with Cannot generate a route to ourselves.

Might be related to #959

Thank you for your help.

[valentinewallace]

Currently you would have to manually construct a route using a custom Router trait implementation, until we fix #959 :/

Discussing raising the priority level of this with the team! Would be helpful to know how urgently y'all need this feature.

Edit: Added #959 to the 0.0.120 milestone, the milestone after the upcoming one.

[TheBlueMatt]

I have some code I'd previously hacked up locally that may work for this, but, indeed, it always requires some manual effort to build a route:

    let chans = channel_manager.list_usable_channels();
    let mut sources: Vec<_> = chans.iter()
        .filter(|c| c.outbound_capacity_msat / 1000 > c.channel_value_satoshis * 7 / 8).collect();
    sources.sort_unstable_by(|a, b| a.counterparty.node_id.cmp(&b.counterparty.node_id)
        .then(b.channel_value_satoshis.cmp(&a.channel_value_satoshis))); // decreasing amt
    sources.dedup_by_key(|c| c.counterparty.node_id);
    let mut sinks: Vec<_> = chans.iter().filter(|c| c.counterparty.forwarding_info.is_some())
        .filter(|c| c.outbound_capacity_msat / 1000 < c.channel_value_satoshis / 8).collect();
    sinks.sort_unstable_by(|a, b| a.counterparty.node_id.cmp(&b.counterparty.node_id)
        .then(b.channel_value_satoshis.cmp(&a.channel_value_satoshis))); // decreasing amt
    sinks.dedup_by_key(|c| c.counterparty.node_id);
    sinks.retain(|c| sources.iter().all(|s| s.counterparty.node_id != c.counterparty.node_id));
    if sources.is_empty() || sinks.is_empty() { return; }

    let sink_hints = sinks.iter().map(|c| {
        let forwarding_info = c.counterparty.forwarding_info.clone().unwrap();
        RouteHint(vec![RouteHintHop {
            src_node_id: c.counterparty.node_id,
            short_channel_id: c.get_inbound_payment_scid().unwrap(),
            fees: RoutingFees {
                base_msat: forwarding_info.fee_base_msat,
                proportional_millionths: forwarding_info.fee_proportional_millionths,
            },
            cltv_expiry_delta: forwarding_info.cltv_expiry_delta,
            htlc_minimum_msat: None,
            htlc_maximum_msat: None,
        }])}).collect();
    let recipient = PublicKey::from_secret_key(&Secp256k1::new(),
        &SecretKey::from_slice(&[42; 32]).unwrap());
    let mut route_params = RouteParameters::from_payment_params_and_value(
        PaymentParameters::from_node_id(
                recipient,
                lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA as u32)
            .with_route_hints(sink_hints).unwrap(),
        final_value_msat,
    );
    let route_res = {
        let in_flight = channel_manager.compute_inflight_htlcs();
        let scorer = scorer.read().unwrap();
        find_route(&channel_manager.get_our_node_id(),
            &route_params, graph, Some(&sources[..]), &*logger,
            &scorer, &Default::default(), &[42; 32])
    };

[bonomat]

Would be helpful to know how urgently y'all need this feature.

We were (un)lucky and the unbalanced channel we wanted to rebalance was force-closed 🙈 It will become important again in the future though.

Thanks for putting #959 into scope. Meanwhile I'll try the snippet from @TheBlueMatt .

[bonomat]

Unfortunately it doesn't work because find_route will eventually check if payee_node_id_opt.map_or(false, |payee| payee == our_node_id) and fail.

Note: I'm still on 116, so maybe this has changed in the meantime already.