Merge pull request #97 from bottlepay/routing-policy

allow non-zero routing policy

Author: joostjager

cmd/lnmuxd/config.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"time"
 
+	"github.com/bottlepay/lnmux"
 	"github.com/urfave/cli/v2"
 	"gopkg.in/yaml.v2"
 )
@@ -43,6 +44,22 @@ type Config struct {
 	Logging LoggingConfig `yaml:"logging"`
 
 	DistributedLock DistributedLockConfig `yaml:"distributedLock"`
+
+	RoutingPolicy *RoutingPolicyConfig `yaml:"routingPolicy"`
+}
+
+type RoutingPolicyConfig struct {
+	// CltvDelta is the minimally required cltv delta for forwards towards the
+	// virtual channel.
+	CltvDelta int64 `yaml:"cltvDelta"`
+
+	// FeeBase is the base fee to charge for forwards towards the
+	// virtual channel.
+	FeeBaseMsat int64 `yaml:"feeBaseMsat"`
+
+	// FeeRate is the fee rate in ppm to charge for forwards towards the virtual
+	// channel.
+	FeeRatePpm int64 `yaml:"feeRatePpm"`
 }
 
 // LoggingConfig contains options related to log outputs.
@@ -80,6 +97,24 @@ func (c *Config) GetIdentityKey() ([32]byte, error) {
 	return key, nil
 }
 
+var defaultRoutingPolicy = lnmux.RoutingPolicy{
+	FeeBaseMsat: 0,
+	FeeRatePpm:  0,
+	CltvDelta:   40,
+}
+
+func (c *Config) GetRoutingPolicy() lnmux.RoutingPolicy {
+	if c.RoutingPolicy == nil {
+		return defaultRoutingPolicy
+	}
+
+	return lnmux.RoutingPolicy{
+		CltvDelta:   c.RoutingPolicy.CltvDelta,
+		FeeBaseMsat: c.RoutingPolicy.FeeBaseMsat,
+		FeeRatePpm:  c.RoutingPolicy.FeeRatePpm,
+	}
+}
+
 type LndConfig struct {
 	Nodes []struct {
 		// PubKey is the public key of this node.

cmd/lnmuxd/run.go

@@ -131,6 +131,9 @@ func run(ctx context.Context, cfg *Config) error {
 		"key", key,
 		"network", activeNetParams.Name)
 
+	// Get routing policy.
+	routingPolicy := cfg.GetRoutingPolicy()
+
 	// Get a new creator instance.
 	var gwPubKeys []common.PubKey
 	for _, lnd := range lnds {
@@ -141,6 +144,7 @@ func run(ctx context.Context, cfg *Config) error {
 			KeyRing:         keyRing,
 			GwPubKeys:       gwPubKeys,
 			ActiveNetParams: activeNetParams,
+			RoutingPolicy:   routingPolicy,
 		},
 	)
 	if err != nil {
@@ -177,6 +181,7 @@ func run(ctx context.Context, cfg *Config) error {
 			Logger:          log,
 			Registry:        registry,
 			SettledHandler:  settledHandler,
+			RoutingPolicy:   routingPolicy,
 		})
 	if err != nil {
 		return err

interceptor.go

@@ -76,8 +76,10 @@ type queuedReply struct {
 }
 
 func (i *interceptor) start(ctx context.Context) error {
-	var cancel func()
-	ctx, cancel = context.WithCancel(ctx)
+	var wg sync.WaitGroup
+	defer wg.Wait()
+
+	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	send, recv, err := i.lnd.HtlcInterceptor(ctx)
@@ -117,9 +119,6 @@ func (i *interceptor) start(ctx context.Context) error {
 		replyChan = make(chan queuedReply, resolutionQueueSize)
 	)
 
-	var wg sync.WaitGroup
-	defer wg.Wait()
-
 	wg.Add(1)
 	go func(ctx context.Context) {
 		defer wg.Done()
@@ -233,7 +232,8 @@ func (i *interceptor) htlcReceiveLoop(ctx context.Context,
 			onionBlob:          htlc.OnionBlob,
 			incomingAmountMsat: htlc.IncomingAmountMsat,
 			outgoingAmountMsat: htlc.OutgoingAmountMsat,
-			expiry:             htlc.OutgoingExpiry,
+			incomingExpiry:     htlc.IncomingExpiry,
+			outgoingExpiry:     htlc.OutgoingExpiry,
 			outgoingChanID:     htlc.OutgoingRequestedChanId,
 			reply:              reply,
 		}:

invoice_creator.go

@@ -37,13 +37,17 @@ type InvoiceCreatorConfig struct {
 	KeyRing         keychain.SecretKeyRing
 	GwPubKeys       []common.PubKey
 	ActiveNetParams *chaincfg.Params
+
+	// RoutingPolicy is the policy that is used for the hop hints.
+	RoutingPolicy RoutingPolicy
 }
 
 type InvoiceCreator struct {
 	keyRing         keychain.SecretKeyRing
 	gwPubKeys       []*btcec.PublicKey
 	activeNetParams *chaincfg.Params
 	idKeyDesc       keychain.KeyDescriptor
+	routingPolicy   RoutingPolicy
 }
 
 func NewInvoiceCreator(cfg *InvoiceCreatorConfig) (*InvoiceCreator, error) {
@@ -71,6 +75,7 @@ func NewInvoiceCreator(cfg *InvoiceCreatorConfig) (*InvoiceCreator, error) {
 		activeNetParams: cfg.ActiveNetParams,
 		keyRing:         cfg.KeyRing,
 		idKeyDesc:       idKeyDesc,
+		routingPolicy:   cfg.RoutingPolicy,
 	}, nil
 }
 
@@ -172,10 +177,10 @@ func (c *InvoiceCreator) Create(amtMSat int64, expiry time.Duration,
 
 		hopHint := zpay32.HopHint{
 			NodeID:                    gwPubKey,
-			ChannelID:                 virtualChannel, // Rotate?
-			FeeBaseMSat:               0,
-			FeeProportionalMillionths: 0,
-			CLTVExpiryDelta:           40, // Can be zero?
+			ChannelID:                 virtualChannel,
+			FeeBaseMSat:               uint32(c.routingPolicy.FeeBaseMsat),
+			FeeProportionalMillionths: uint32(c.routingPolicy.FeeRatePpm),
+			CLTVExpiryDelta:           uint16(c.routingPolicy.CltvDelta),
 		}
 
 		options = append(options, zpay32.RouteHint([]zpay32.HopHint{hopHint}))

mux.go

@@ -29,6 +29,7 @@ type Mux struct {
 	logger *zap.SugaredLogger
 
 	settledHandler *SettledHandler
+	routingPolicy  RoutingPolicy
 }
 
 type MuxConfig struct {
@@ -39,6 +40,16 @@ type MuxConfig struct {
 	Lnd      []lnd.LndClient
 	Logger   *zap.SugaredLogger
 	Registry *InvoiceRegistry
+
+	// RoutingPolicy is the policy that is enforced for the hop towards the
+	// virtual channel.
+	RoutingPolicy RoutingPolicy
+}
+
+type RoutingPolicy struct {
+	CltvDelta   int64
+	FeeBaseMsat int64
+	FeeRatePpm  int64
 }
 
 func New(cfg *MuxConfig) (*Mux,
@@ -70,6 +81,7 @@ func New(cfg *MuxConfig) (*Mux,
 		lnd:            cfg.Lnd,
 		logger:         cfg.Logger,
 		settledHandler: cfg.SettledHandler,
+		routingPolicy:  cfg.RoutingPolicy,
 	}, nil
 }
 
@@ -95,7 +107,8 @@ type interceptedHtlc struct {
 	onionBlob          []byte
 	incomingAmountMsat uint64
 	outgoingAmountMsat uint64
-	expiry             uint32
+	incomingExpiry     uint32
+	outgoingExpiry     uint32
 	outgoingChanID     uint64
 
 	reply func(*interceptedHtlcResponse) error
@@ -109,12 +122,17 @@ type interceptedHtlcResponse struct {
 }
 
 func (p *Mux) run(mainCtx context.Context) error {
-	ctx, cancel := context.WithCancel(mainCtx)
-	defer cancel()
+	p.logger.Infow("Routing policy",
+		"cltvDelta", p.routingPolicy.CltvDelta,
+		"feeBaseMsat", p.routingPolicy.FeeBaseMsat,
+		"feeRatePpm", p.routingPolicy.FeeRatePpm)
 
 	var wg sync.WaitGroup
 	defer wg.Wait()
 
+	ctx, cancel := context.WithCancel(mainCtx)
+	defer cancel()
+
 	// Register for htlc interception and block events.
 	htlcChan := make(chan *interceptedHtlc)
 	heightChan := make(chan int)
@@ -192,10 +210,11 @@ func marshallFailureCode(code lnwire.FailCode) (
 	case lnwire.CodeInvalidOnionKey:
 		return lnrpc.Failure_INVALID_ONION_KEY, nil
 
-	case lnwire.CodeFeeInsufficient:
-		// Unfortunately lnrpc.Failure_FEE_INSUFFICIENT is not supported by lnd.
-		// Return 0, which is mapped to TemporaryChannelFailure.
-
+	// Unfortunately these codes are not supported by lnd. Return 0, which is
+	// mapped to TemporaryChannelFailure.
+	//
+	// See https://github.com/lightningnetwork/lnd/pull/7067
+	case lnwire.CodeFeeInsufficient, lnwire.CodeIncorrectCltvExpiry:
 		return 0, nil
 
 	default:
@@ -229,13 +248,26 @@ func (p *Mux) ProcessHtlc(
 	}
 
 	// Verify that the amount of the incoming htlc is at least what is forwarded
-	// over the virtual channel.
-	if htlc.incomingAmountMsat < htlc.outgoingAmountMsat {
-		logger.Debugw("Insufficient incoming htlc amount")
+	// over the virtual channel plus fee.
+	//
+	// TODO: Fee accounting for successful payments.
+	expectedFee := uint64(p.routingPolicy.FeeBaseMsat) +
+		(uint64(p.routingPolicy.FeeRatePpm)*htlc.outgoingAmountMsat)/1e6
+
+	if htlc.incomingAmountMsat < htlc.outgoingAmountMsat+expectedFee {
+		logger.Debugw("Insufficient incoming htlc amount",
+			"expectedFee", expectedFee)
 
 		return fail(lnwire.CodeFeeInsufficient)
 	}
 
+	// Verify that the cltv delta is sufficiently large.
+	if htlc.incomingExpiry < htlc.outgoingExpiry+uint32(p.routingPolicy.CltvDelta) {
+		logger.Debugw("Cltv delta insufficient")
+
+		return fail(lnwire.CodeIncorrectCltvExpiry)
+	}
+
 	// Try decode final hop onion. Expiry can be set to zero, because the
 	// replay log is disabled.
 	onionReader := bytes.NewReader(htlc.onionBlob)
@@ -278,7 +310,7 @@ func (p *Mux) ProcessHtlc(
 	}
 
 	// Verify that the amount going out over the virtual channel matches what
-	// the sender intended.
+	// the sender intended. See BOLT 04.
 	if uint64(payload.ForwardingInfo().AmountToForward) !=
 		htlc.outgoingAmountMsat {
 
@@ -289,6 +321,16 @@ func (p *Mux) ProcessHtlc(
 		})
 	}
 
+	// Verify that the expiry going out over the virtual channel matches what
+	// the sender intended. See BOLT 04.
+	if uint64(payload.ForwardingInfo().OutgoingCTLV) !=
+		uint64(htlc.outgoingExpiry) {
+
+		logger.Debugw("Final expiry mismatch")
+
+		return failLocal(&lnwire.FailFinalExpiryTooSoon{})
+	}
+
 	resolve := func(resolution HtlcResolution) error {
 		// Determine required action for the resolution based on the type of
 		// resolution we have received.
@@ -331,7 +373,7 @@ func (p *Mux) ProcessHtlc(
 		&registryHtlc{
 			rHash:         htlc.hash,
 			amtPaid:       lnwire.MilliSatoshi(htlc.outgoingAmountMsat),
-			expiry:        htlc.expiry,
+			expiry:        htlc.outgoingExpiry,
 			currentHeight: int32(height),
 			circuitKey:    htlc.circuitKey,
 			payload:       payload,

mux_test.go

@@ -118,11 +118,18 @@ func TestMux(t *testing.T) {
 	db, dropDB := setupTestDB(t)
 	defer dropDB()
 
+	routingPolicy := RoutingPolicy{
+		FeeBaseMsat: 1000,
+		FeeRatePpm:  10000,
+		CltvDelta:   10,
+	}
+
 	creator, err := NewInvoiceCreator(
 		&InvoiceCreatorConfig{
 			KeyRing:         keyRing,
 			GwPubKeys:       []common.PubKey{testPubKey1, testPubKey2},
 			ActiveNetParams: activeNetParams,
+			RoutingPolicy:   routingPolicy,
 		},
 	)
 	require.NoError(t, err)
@@ -159,6 +166,7 @@ func TestMux(t *testing.T) {
 		Logger:          logger.Sugar(),
 		Registry:        registry,
 		SettledHandler:  settledHandler,
+		RoutingPolicy:   routingPolicy,
 	})
 	require.NoError(t, err)
 
@@ -199,13 +207,15 @@ func TestMux(t *testing.T) {
 	require.NoError(t, err)
 
 	receiveHtlcInOut := func(sourceNodeIdx int, htlcID uint64,
-		incomingAmt, outgoingAmt, amtToForward uint64) {
+		incomingAmt, outgoingAmt, amtToForward uint64,
+		inExpiry, outExpiry, payloadExpiry uint32) {
 
 		route := &route.Route{
 			Hops: []*route.Hop{
 				{
-					AmtToForward: lnwire.MilliSatoshi(amtToForward),
-					PubKeyBytes:  dest,
+					AmtToForward:     lnwire.MilliSatoshi(amtToForward),
+					OutgoingTimeLock: payloadExpiry,
+					PubKeyBytes:      dest,
 					MPP: record.NewMPP(
 						invoice.Value, invoice.PaymentAddr,
 					),
@@ -226,10 +236,10 @@ func TestMux(t *testing.T) {
 		l[sourceNodeIdx].htlcChan <- &routerrpc.ForwardHtlcInterceptRequest{
 			IncomingCircuitKey:      &routerrpc.CircuitKey{HtlcId: htlcID},
 			PaymentHash:             testHash[:],
-			IncomingExpiry:          1050,
+			IncomingExpiry:          inExpiry,
 			IncomingAmountMsat:      incomingAmt,
 			OutgoingAmountMsat:      outgoingAmt,
-			OutgoingExpiry:          1040,
+			OutgoingExpiry:          outExpiry,
 			OnionBlob:               onionBlob[:],
 			OutgoingRequestedChanId: virtualChannel,
 		}
@@ -238,8 +248,13 @@ func TestMux(t *testing.T) {
 	receiveHtlc := func(sourceNodeIdx int, htlcID uint64,
 		outgoingAmt uint64) {
 
+		// Calculate required routing fee.
+		incomingAmt := outgoingAmt + uint64(routingPolicy.FeeBaseMsat+
+			(routingPolicy.FeeRatePpm*int64(outgoingAmt))/1e6)
+
 		receiveHtlcInOut(
-			sourceNodeIdx, htlcID, outgoingAmt, outgoingAmt, outgoingAmt,
+			sourceNodeIdx, htlcID, incomingAmt, outgoingAmt, outgoingAmt,
+			1050, 1040, 1040,
 		)
 	}
 
@@ -253,11 +268,19 @@ func TestMux(t *testing.T) {
 	}
 
 	// Test an htlc with an amount that is not high enough.
-	receiveHtlcInOut(0, 20, 5000, 6000, 6000)
+	receiveHtlcInOut(0, 20, 6000+1060-1, 6000, 6000, 1050, 1040, 1040)
 	expectResponse(<-l[0].responseChan, 20, routerrpc.ResolveHoldForwardAction_FAIL)
 
 	// Test an htlc with an amount mismatch in the payload.
-	receiveHtlcInOut(0, 20, 6000, 6000, 5900)
+	receiveHtlcInOut(0, 20, 6000+1060, 6000, 5900, 1050, 1040, 1040)
+	expectResponse(<-l[0].responseChan, 20, routerrpc.ResolveHoldForwardAction_FAIL)
+
+	// Test an htlc with a cltv delta that is too small.
+	receiveHtlcInOut(0, 20, 6000+1060, 6000, 6000, 1049, 1040, 1040)
+	expectResponse(<-l[0].responseChan, 20, routerrpc.ResolveHoldForwardAction_FAIL)
+
+	// Test an htlc with a cltv delta mismatch in the payload.
+	receiveHtlcInOut(0, 20, 6000+1060, 6000, 6000, 1051, 1041, 1040)
 	expectResponse(<-l[0].responseChan, 20, routerrpc.ResolveHoldForwardAction_FAIL)
 
 	// Notify arrival of part 1.