Archives
/
regolancer
mirror of https://github.com/rkfg/regolancer
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add lost profits accounting, fixes #2

Browse Source
pull/11/head
rkfg 2 years ago
parent 974e938313
commit 4a45b7a23c
5 changed files with 55 additions and 27 deletions
Show Stats Download Patch File Download Diff File

1
config.json.sample
Unescape Escape View File

@ -11,6 +11,7 @@
"pfrom": 10,
"pto": 30,
"stat": "stats.csv",
"lost_profit": true,
"exclude_channels_in": [
821913529170526209,
821280210377179136

1
config.toml.sample
Unescape Escape View File

@ -10,6 +10,7 @@ macaroon_filename = "admin.macaroon"
"pfrom"= 40
"pto"= 40
"stat"= "stats.csv"
lost_profit = true
"exclude_channels_in"= [
# River Financial
821913529170526209,

3
main.go
Unescape Escape View File

@ -32,6 +32,7 @@ var params struct {
Perc int64 `short:"p" long:"perc" description:"use this value as both pfrom and pto from above" json:"perc"`
Amount int64 `short:"a" long:"amount" description:"amount to rebalance" json:"amount"`
EconRatio float64 `short:"r" long:"econ-ratio" description:"economical ratio for fee limit calculation as a multiple of target channel fee (for example, 0.5 means you want to pay at max half the fee you might earn for routing out of the target channel)" json:"econ_ratio" toml:"econ_ratio"`
LostProfit bool `short:"l" long:"lost-profit" description:"also consider the outbound channel fees when looking for profitable routes so that outbound_fee+inbound_fee < route_fee" json:"lost_profit" toml:"lost_profit"`
ProbeSteps int `short:"b" long:"probe-steps" description:"if the payment fails at the last hop try to probe lower amount using this many steps" json:"probe_steps" toml:"probe_steps"`
MinAmount int64 `long:"min-amount" description:"if probing is enabled this will be the minimum amount to try" json:"min_amount" toml:"min_amount"`
ExcludeChannelsIn []uint64 `short:"i" long:"exclude-channel-in" description:"don't use this channel as incoming (can be specified multiple times)" json:"exclude_channels_in" toml:"exclude_channels_in"`
@ -104,7 +105,7 @@ func tryRebalance(ctx context.Context, r *regolancer, invoice **lnrpc.AddInvoice
}
routeCtx, routeCtxCancel := context.WithTimeout(ctx, time.Second*30)
defer routeCtxCancel()
routes, fee, err := r.getRoutes(routeCtx, from, to, amt*1000, params.EconRatio)
routes, fee, err := r.getRoutes(routeCtx, from, to, amt*1000)
if err != nil {
if routeCtx.Err() == context.DeadlineExceeded {
log.Print(errColor("Timed out looking for a route"))

7
payment.go
Unescape Escape View File

@ -27,8 +27,8 @@ func (r *regolancer) createInvoice(ctx context.Context, from, to uint64, amount
Expiry: int64(time.Hour.Seconds() * 24)})
}
func (r *regolancer) pay(ctx context.Context, invoice *lnrpc.AddInvoiceResponse, amount int64,
minAmount int64, route *lnrpc.Route, probeSteps int) error {
func (r *regolancer) pay(ctx context.Context, invoice *lnrpc.AddInvoiceResponse,
amount int64, minAmount int64, route *lnrpc.Route, probeSteps int) error {
fmt.Println()
defer fmt.Println()
lastHop := route.Hops[len(route.Hops)-1]
@ -84,7 +84,8 @@ func (r *regolancer) pay(ctx context.Context, invoice *lnrpc.AddInvoiceResponse,
min = -minAmount - 1
start = minAmount
}
maxAmount, err := r.probeRoute(ctx, route, min, amount, start, probeSteps, params.EconRatio)
maxAmount, err := r.probeRoute(ctx, route, min, amount, start,
probeSteps)
if err != nil {
return err
}

70
routes.go
Unescape Escape View File

@ -28,26 +28,41 @@ func (r *regolancer) getChanInfo(ctx context.Context, chanId uint64) (*lnrpc.Cha
return c, nil
}
func (r *regolancer) calcFeeMsat(ctx context.Context, to uint64, amtMsat int64, ratio float64) (feeMsat int64,
func (r *regolancer) calcFeeMsat(ctx context.Context, from, to uint64, amtMsat int64, ratio float64) (feeMsat int64,
lastPKstr string, err error) {
c, err := r.getChanInfo(ctx, to)
cTo, err := r.getChanInfo(ctx, to)
if err != nil {
return 0, "", err
}
lastPKstr = c.Node1Pub
policy := c.Node2Policy
lastPKstr = cTo.Node1Pub
policyTo := cTo.Node2Policy
if lastPKstr == r.myPK {
lastPKstr = c.Node2Pub
policy = c.Node1Policy
lastPKstr = cTo.Node2Pub
policyTo = cTo.Node1Policy
}
feeMsat = int64(float64(policy.FeeBaseMsat+amtMsat*policy.FeeRateMilliMsat) * ratio / 1e6)
lostProfitMsat := int64(0)
if params.LostProfit {
cFrom, err := r.getChanInfo(ctx, from)
if err != nil {
return 0, "", err
}
policyFrom := cFrom.Node1Policy
if cFrom.Node2Pub == r.myPK {
policyFrom = cFrom.Node2Policy
}
lostProfitMsat = int64(float64(policyFrom.FeeBaseMsat+
amtMsat*policyFrom.FeeRateMilliMsat) / 1e6)
}
feeMsat = int64(float64(policyTo.FeeBaseMsat+amtMsat*
policyTo.FeeRateMilliMsat)*ratio/1e6) - lostProfitMsat
return
}
func (r *regolancer) getRoutes(ctx context.Context, from, to uint64, amtMsat int64, ratio float64) ([]*lnrpc.Route, int64, error) {
func (r *regolancer) getRoutes(ctx context.Context, from, to uint64, amtMsat int64) ([]*lnrpc.Route, int64, error) {
routeCtx, cancel := context.WithTimeout(ctx, time.Second*30)
defer cancel()
feeMsat, lastPKstr, err := r.calcFeeMsat(routeCtx, to, amtMsat, ratio)
feeMsat, lastPKstr, err := r.calcFeeMsat(routeCtx, from, to, amtMsat,
params.EconRatio)
if err != nil {
return nil, 0, err
}
@ -145,8 +160,8 @@ func (r *regolancer) rebuildRoute(ctx context.Context, route *lnrpc.Route, amoun
return resultRoute.Route, err
}
func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route, goodAmount, badAmount, amount int64,
steps int, ratio float64) (maxAmount int64, err error) {
func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route,
goodAmount, badAmount, amount int64, steps int) (maxAmount int64, err error) {
if amount == badAmount || amount == goodAmount || amount == -goodAmount {
bestAmount := hiWhiteColor(goodAmount)
if goodAmount <= 0 {
@ -160,18 +175,21 @@ func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route, goodAmo
if err != nil {
return 0, err
}
maxFeeMsat, _, err := r.calcFeeMsat(ctx, probedRoute.Hops[len(probedRoute.Hops)-1].ChanId, amount*1000, ratio)
maxFeeMsat, _, err := r.calcFeeMsat(ctx, probedRoute.Hops[0].ChanId,
probedRoute.Hops[len(probedRoute.Hops)-1].ChanId, amount*1000,
params.EconRatio)
if err != nil {
return 0, err
}
if probedRoute.TotalFeesMsat > maxFeeMsat {
nextAmount := amount + (badAmount-amount)/2
log.Printf("%s requires too high fee %s (max allowed is %s), increasing amount to %s",
hiWhiteColor(amount), hiWhiteColor(probedRoute.TotalFeesMsat/1000), hiWhiteColor(maxFeeMsat/1000),
hiWhiteColor(nextAmount))
// returning negative amount as "good", it's a special case which means this is
// rather the lower bound and the actual good amount is still unknown
return r.probeRoute(ctx, route, -amount, badAmount, nextAmount, steps, ratio)
hiWhiteColor(amount), hiWhiteColor(probedRoute.TotalFeesMsat/1000),
hiWhiteColor(maxFeeMsat/1000), hiWhiteColor(nextAmount))
// returning negative amount as "good", it's a special case which means
// this is rather the lower bound and the actual good amount is still
// unknown
return r.probeRoute(ctx, route, -amount, badAmount, nextAmount, steps)
}
fakeHash := make([]byte, 32)
rand.Read(fakeHash)
@ -194,8 +212,10 @@ func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route, goodAmo
}
nextAmount := amount + (badAmount-amount)/2
log.Printf("%s is good enough, trying amount %s, %s steps left",
hiWhiteColor(amount), hiWhiteColor(nextAmount), hiWhiteColor(steps-1))
return r.probeRoute(ctx, route, amount, badAmount, nextAmount, steps-1, ratio)
hiWhiteColor(amount), hiWhiteColor(nextAmount),
hiWhiteColor(steps-1))
return r.probeRoute(ctx, route, amount, badAmount, nextAmount,
steps-1)
}
if result.Failure.Code == lnrpc.Failure_TEMPORARY_CHANNEL_FAILURE {
if steps == 1 {
@ -204,7 +224,8 @@ func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route, goodAmo
bestAmount = hiWhiteColor("unknown")
goodAmount = 0
}
log.Printf("%s is too much, best amount is %s", hiWhiteColor(amount), bestAmount)
log.Printf("%s is too much, best amount is %s",
hiWhiteColor(amount), bestAmount)
return goodAmount, nil
}
var nextAmount int64
@ -214,12 +235,15 @@ func (r *regolancer) probeRoute(ctx context.Context, route *lnrpc.Route, goodAmo
nextAmount = amount - (goodAmount+amount)/2
}
log.Printf("%s is too much, lowering amount to %s, %s steps left",
hiWhiteColor(amount), hiWhiteColor(nextAmount), hiWhiteColor(steps-1))
return r.probeRoute(ctx, route, goodAmount, amount, nextAmount, steps-1, ratio)
hiWhiteColor(amount), hiWhiteColor(nextAmount),
hiWhiteColor(steps-1))
return r.probeRoute(ctx, route, goodAmount, amount, nextAmount,
steps-1)
}
if result.Failure.Code == lnrpc.Failure_FEE_INSUFFICIENT {
log.Printf("Fee insufficient, retrying...")
return r.probeRoute(ctx, route, goodAmount, badAmount, amount, steps, ratio)
return r.probeRoute(ctx, route, goodAmount, badAmount, amount,
steps)
}
}
return 0, fmt.Errorf("unknown error: %+v", result)

Write Preview
Loading…
Cancel
Save