Merge pull request #152 from joostjager/loop-in-last-hop

multi: allow loop in last hop restriction

Author: joostjager

client.go

@@ -437,9 +437,9 @@ func (s *Client) waitForInitialized(ctx context.Context) error {
 func (s *Client) LoopIn(globalCtx context.Context,
 	request *LoopInRequest) (*lntypes.Hash, btcutil.Address, error) {
 
-	log.Infof("Loop in %v (channel: %v)",
+	log.Infof("Loop in %v (last hop: %v)",
 		request.Amount,
-		request.LoopInChannel,
+		request.LastHop,
 	)
 
 	if err := s.waitForInitialized(globalCtx); err != nil {

cmd/loop/loopin.go

@@ -7,27 +7,36 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop/looprpc"
 	"github.com/lightninglabs/loop/swap"
+	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/urfave/cli"
 )
 
-var loopInCommand = cli.Command{
-	Name:      "in",
-	Usage:     "perform an on-chain to off-chain swap (loop in)",
-	ArgsUsage: "amt",
-	Description: `
+var (
+	lastHopFlag = cli.StringFlag{
+		Name:  "last_hop",
+		Usage: "the pubkey of the last hop to use for this swap",
+	}
+
+	loopInCommand = cli.Command{
+		Name:      "in",
+		Usage:     "perform an on-chain to off-chain swap (loop in)",
+		ArgsUsage: "amt",
+		Description: `
 		Send the amount in satoshis specified by the amt argument off-chain.`,
-	Flags: []cli.Flag{
-		cli.Uint64Flag{
-			Name:  "amt",
-			Usage: "the amount in satoshis to loop in",
-		},
-		cli.BoolFlag{
-			Name:  "external",
-			Usage: "expect htlc to be published externally",
+		Flags: []cli.Flag{
+			cli.Uint64Flag{
+				Name:  "amt",
+				Usage: "the amount in satoshis to loop in",
+			},
+			cli.BoolFlag{
+				Name:  "external",
+				Usage: "expect htlc to be published externally",
+			},
+			lastHopFlag,
 		},
-	},
-	Action: loopIn,
-}
+		Action: loopIn,
+	}
+)
 
 func loopIn(ctx *cli.Context) error {
 	args := ctx.Args()
@@ -73,12 +82,25 @@ func loopIn(ctx *cli.Context) error {
 		return err
 	}
 
-	resp, err := client.LoopIn(context.Background(), &looprpc.LoopInRequest{
+	req := &looprpc.LoopInRequest{
 		Amt:          int64(amt),
 		MaxMinerFee:  int64(limits.maxMinerFee),
 		MaxSwapFee:   int64(limits.maxSwapFee),
 		ExternalHtlc: external,
-	})
+	}
+
+	if ctx.IsSet(lastHopFlag.Name) {
+		lastHop, err := route.NewVertexFromStr(
+			ctx.String(lastHopFlag.Name),
+		)
+		if err != nil {
+			return err
+		}
+
+		req.LastHop = lastHop[:]
+	}
+
+	resp, err := client.LoopIn(context.Background(), req)
 	if err != nil {
 		return err
 	}

interface.go

@@ -7,6 +7,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 // OutRequest contains the required parameters for a loop out swap.
@@ -173,9 +174,9 @@ type LoopInRequest struct {
 	// client htlc tx.
 	HtlcConfTarget int32
 
-	// LoopInChannel optionally specifies the short channel id of the
-	// channel to loop in.
-	LoopInChannel *uint64
+	// LastHop optionally specifies the last hop to use for the loop in
+	// payment.
+	LastHop *route.Vertex
 
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.

loopd/swapclient_server.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/queue"
+	"github.com/lightningnetwork/lnd/routing/route"
 
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/lndclient"
@@ -387,8 +388,12 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		HtlcConfTarget: defaultConfTarget,
 		ExternalHtlc:   in.ExternalHtlc,
 	}
-	if in.LoopInChannel != 0 {
-		req.LoopInChannel = &in.LoopInChannel
+	if in.LastHop != nil {
+		lastHop, err := route.NewVertexFromBytes(in.LastHop)
+		if err != nil {
+			return nil, err
+		}
+		req.LastHop = &lastHop
 	}
 	hash, htlc, err := s.impl.LoopIn(ctx, req)
 	if err != nil {

loopdb/loopin.go

@@ -5,6 +5,8 @@ import (
 	"encoding/binary"
 	"fmt"
 	"time"
+
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 // LoopInContract contains the data that is serialized to persistent storage for
@@ -16,9 +18,8 @@ type LoopInContract struct {
 	// client sweep tx.
 	HtlcConfTarget int32
 
-	// LoopInChannel is the channel to charge. If zero, any channel may
-	// be used.
-	LoopInChannel *uint64
+	// LastHop is the last hop to use for the loop in swap (optional).
+	LastHop *route.Vertex
 
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.
@@ -96,11 +97,11 @@ func serializeLoopInContract(swap *LoopInContract) (
 		return nil, err
 	}
 
-	var chargeChannel uint64
-	if swap.LoopInChannel != nil {
-		chargeChannel = *swap.LoopInChannel
+	var lastHop route.Vertex
+	if swap.LastHop != nil {
+		lastHop = *swap.LastHop
 	}
-	if err := binary.Write(&b, byteOrder, chargeChannel); err != nil {
+	if err := binary.Write(&b, byteOrder, lastHop[:]); err != nil {
 		return nil, err
 	}
 
@@ -167,12 +168,13 @@ func deserializeLoopInContract(value []byte) (*LoopInContract, error) {
 		return nil, err
 	}
 
-	var loopInChannel uint64
-	if err := binary.Read(r, byteOrder, &loopInChannel); err != nil {
+	var lastHop route.Vertex
+	if err := binary.Read(r, byteOrder, lastHop[:]); err != nil {
 		return nil, err
 	}
-	if loopInChannel != 0 {
-		contract.LoopInChannel = &loopInChannel
+	var noLastHop route.Vertex
+	if lastHop != noLastHop {
+		contract.LastHop = &lastHop
 	}
 
 	if err := binary.Read(r, byteOrder, &contract.ExternalHtlc); err != nil {

loopdb/meta.go

@@ -35,6 +35,7 @@ var (
 	migrations = []migration{
 		migrateCosts,
 		migrateSwapPublicationDeadline,
+		migrateLastHop,
 	}
 
 	latestDBVersion = uint32(len(migrations))

loopdb/migration_03_last_hop.go

@@ -0,0 +1,86 @@
+package loopdb
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/coreos/bbolt"
+)
+
+// migrateLastHop migrates the database to v03, replacing the never used loop in
+// channel by a last hop pubkey.
+func migrateLastHop(tx *bbolt.Tx, chainParams *chaincfg.Params) error {
+	rootBucket := tx.Bucket(loopInBucketKey)
+	if rootBucket == nil {
+		return errors.New("bucket does not exist")
+	}
+
+	return rootBucket.ForEach(func(swapHash, v []byte) error {
+		// Only go into things that we know are sub-bucket
+		// keys.
+		if v != nil {
+			return nil
+		}
+
+		// From the root bucket, we'll grab the next swap
+		// bucket for this swap from its swaphash.
+		swapBucket := rootBucket.Bucket(swapHash)
+		if swapBucket == nil {
+			return fmt.Errorf("swap bucket %x not found",
+				swapHash)
+		}
+
+		// With the main swap bucket obtained, we'll grab the
+		// raw swap contract bytes.
+		contractBytes := swapBucket.Get(contractKey)
+		if contractBytes == nil {
+			return errors.New("contract not found")
+		}
+
+		const (
+			// deprecatedLoopInChannelStart is the starting offset
+			// of the old loop in channel field: 8 (initiation time)
+			// + 32 (preimage) + 8 (amount requested) + 33 + 33
+			// (sender and receiver keys) + 4 (cltv expiry) + 8 + 8
+			// (max miner and swap fee) + 4 (initiation height) + 4
+			// (conf target) = 142.
+			deprecatedLoopInChannelStart = 142
+
+			// expectedTotalLength is the expect total length of the
+			// serialized contract. It adds 8 (old loop in channel)
+			// + 1 (external htlc) = 9 bytes to
+			// deprecatedLoopInChannelStart.
+			expectedTotalLength = deprecatedLoopInChannelStart + 9
+		)
+
+		// Sanity check to see if the constants above match the contract
+		// bytes.
+		if len(contractBytes) != expectedTotalLength {
+			return errors.New("invalid serialized contract length")
+		}
+
+		// Copy the unchanged fields into the buffer.
+		b := &bytes.Buffer{}
+		_, err := b.Write(contractBytes[:deprecatedLoopInChannelStart])
+		if err != nil {
+			return err
+		}
+
+		// We now set the new last hop field to all zeroes to indicate
+		// that there is no restriction.
+		var noLastHop [33]byte
+		if _, err := b.Write(noLastHop[:]); err != nil {
+			return err
+		}
+
+		// Append the remaining field ExternalHtlc.
+		_, err = b.Write(contractBytes[deprecatedLoopInChannelStart+8:])
+		if err != nil {
+			return err
+		}
+
+		return swapBucket.Put(contractKey, b.Bytes())
+	})
+}

loopdb/store_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/coreos/bbolt"
 	"github.com/lightninglabs/loop/test"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/routing/route"
 )
 
 var (
@@ -197,7 +198,7 @@ func TestLoopInStore(t *testing.T) {
 
 	// Next, we'll make a new pending swap that we'll insert into the
 	// database shortly.
-	loopInChannel := uint64(123)
+	lastHop := route.Vertex{1, 2, 3}
 
 	pendingSwap := LoopInContract{
 		SwapContract: SwapContract{
@@ -215,7 +216,7 @@ func TestLoopInStore(t *testing.T) {
 			InitiationTime: time.Unix(0, initiationTime.UnixNano()),
 		},
 		HtlcConfTarget: 2,
-		LoopInChannel:  &loopInChannel,
+		LastHop:        &lastHop,
 		ExternalHtlc:   true,
 	}
 

loopin.go

@@ -114,7 +114,7 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 	// htlc.
 	log.Infof("Initiating swap request at height %v", currentHeight)
 	swapResp, err := cfg.server.NewLoopInSwap(globalCtx, swapHash,
-		request.Amount, senderKey, swapInvoice,
+		request.Amount, senderKey, swapInvoice, request.LastHop,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("cannot initiate swap: %v", err)
@@ -133,7 +133,7 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 
 	contract := loopdb.LoopInContract{
 		HtlcConfTarget: request.HtlcConfTarget,
-		LoopInChannel:  request.LoopInChannel,
+		LastHop:        request.LastHop,
 		ExternalHtlc:   request.ExternalHtlc,
 		SwapContract: loopdb.SwapContract{
 			InitiationHeight: currentHeight,