Merge pull request #263 from carlaKC/205-addlabelling

multi: add labelling to swaps

Author: carlaKC

cmd/loop/loopin.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop"
+	"github.com/lightninglabs/loop/labels"
 	"github.com/lightninglabs/loop/looprpc"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/urfave/cli"
@@ -24,6 +25,14 @@ var (
 			"confirm within",
 	}
 
+	labelFlag = cli.StringFlag{
+		Name: "label",
+		Usage: fmt.Sprintf("an optional label for this swap,"+
+			"limited to %v characters. The label may not start "+
+			"with our reserved prefix: %v.",
+			labels.MaxLength, labels.Reserved),
+	}
+
 	loopInCommand = cli.Command{
 		Name:      "in",
 		Usage:     "perform an on-chain to off-chain swap (loop in)",
@@ -51,6 +60,7 @@ var (
 			},
 			confTargetFlag,
 			lastHopFlag,
+			labelFlag,
 		},
 		Action: loopIn,
 	}
@@ -93,6 +103,12 @@ func loopIn(ctx *cli.Context) error {
 		return fmt.Errorf("external and conf_target both set")
 	}
 
+	// Validate our label early so that we can fail before getting a quote.
+	label := ctx.String(labelFlag.Name)
+	if err := labels.Validate(label); err != nil {
+		return err
+	}
+
 	quote, err := client.GetLoopInQuote(
 		context.Background(),
 		&looprpc.QuoteRequest{
@@ -133,6 +149,7 @@ func loopIn(ctx *cli.Context) error {
 		MaxSwapFee:     int64(limits.maxSwapFee),
 		ExternalHtlc:   external,
 		HtlcConfTarget: htlcConfTarget,
+		Label:          label,
 	}
 
 	if ctx.IsSet(lastHopFlag.Name) {

cmd/loop/loopout.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/btcsuite/btcutil"
 	"github.com/lightninglabs/loop"
+	"github.com/lightninglabs/loop/labels"
 	"github.com/lightninglabs/loop/looprpc"
 	"github.com/urfave/cli"
 )
@@ -64,6 +65,7 @@ var loopOutCommand = cli.Command{
 				"Not setting this flag therefore might " +
 				"result in a lower swap fee.",
 		},
+		labelFlag,
 	},
 	Action: loopOut,
 }
@@ -104,6 +106,12 @@ func loopOut(ctx *cli.Context) error {
 		}
 	}
 
+	// Validate our label early so that we can fail before getting a quote.
+	label := ctx.String(labelFlag.Name)
+	if err := labels.Validate(label); err != nil {
+		return err
+	}
+
 	var destAddr string
 	switch {
 	case ctx.IsSet("addr"):
@@ -172,6 +180,7 @@ func loopOut(ctx *cli.Context) error {
 		OutgoingChanSet:         outgoingChanSet,
 		SweepConfTarget:         sweepConfTarget,
 		SwapPublicationDeadline: uint64(swapDeadline.Unix()),
+		Label:                   label,
 	})
 	if err != nil {
 		return err

interface.go

@@ -74,6 +74,9 @@ type OutRequest struct {
 
 	// Expiry is the absolute expiry height of the on-chain htlc.
 	Expiry int32
+
+	// Label contains an optional label for the swap.
+	Label string
 }
 
 // Out contains the full details of a loop out request. This includes things
@@ -186,6 +189,9 @@ type LoopInRequest struct {
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.
 	ExternalHtlc bool
+
+	// Label contains an optional label for the swap.
+	Label string
 }
 
 // LoopInTerms are the server terms on which it executes loop in swaps.

labels/labels.go

@@ -0,0 +1,46 @@
+package labels
+
+import (
+	"errors"
+)
+
+const (
+	// MaxLength is the maximum length we allow for labels.
+	MaxLength = 500
+
+	// Reserved is used as a prefix to separate labels that are created by
+	// loopd from those created by users.
+	Reserved = "[reserved]"
+)
+
+var (
+	// ErrLabelTooLong is returned when a label exceeds our length limit.
+	ErrLabelTooLong = errors.New("label exceeds maximum length")
+
+	// ErrReservedPrefix is returned when a label contains the prefix
+	// which is reserved for internally produced labels.
+	ErrReservedPrefix = errors.New("label contains reserved prefix")
+)
+
+// Validate checks that a label is of appropriate length and is not in our list
+// of reserved labels.
+func Validate(label string) error {
+	if len(label) > MaxLength {
+		return ErrLabelTooLong
+	}
+
+	// If the label is shorter than our reserved prefix, it cannot contain
+	// it.
+	if len(label) < len(Reserved) {
+		return nil
+	}
+
+	// Check if our label begins with our reserved prefix. We don't mind if
+	// it has our reserved prefix in another case, we just need to be able
+	// to reserve a subset of labels with this prefix.
+	if label[0:len(Reserved)] == Reserved {
+		return ErrReservedPrefix
+	}
+
+	return nil
+}

labels/labels_test.go

@@ -0,0 +1,53 @@
+package labels
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestValidate tests validation of labels.
+func TestValidate(t *testing.T) {
+	tests := []struct {
+		name  string
+		label string
+		err   error
+	}{
+		{
+			name:  "label ok",
+			label: "label",
+			err:   nil,
+		},
+		{
+			name:  "exceeds limit",
+			label: strings.Repeat(" ", MaxLength+1),
+			err:   ErrLabelTooLong,
+		},
+		{
+			name:  "exactly reserved prefix",
+			label: Reserved,
+			err:   ErrReservedPrefix,
+		},
+		{
+			name:  "starts with reserved prefix",
+			label: fmt.Sprintf("%v test", Reserved),
+			err:   ErrReservedPrefix,
+		},
+		{
+			name:  "ends with reserved prefix",
+			label: fmt.Sprintf("test %v", Reserved),
+			err:   nil,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			require.Equal(t, test.err, Validate(test.label))
+		})
+	}
+}

loopd/swapclient_server.go

@@ -89,6 +89,7 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
 		SwapPublicationDeadline: time.Unix(
 			int64(in.SwapPublicationDeadline), 0,
 		),
+		Label: in.Label,
 	}
 
 	switch {
@@ -214,6 +215,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		CostServer:        int64(loopSwap.Cost.Server),
 		CostOnchain:       int64(loopSwap.Cost.Onchain),
 		CostOffchain:      int64(loopSwap.Cost.Offchain),
+		Label:             loopSwap.Label,
 	}, nil
 }
 
@@ -478,6 +480,7 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		MaxSwapFee:     btcutil.Amount(in.MaxSwapFee),
 		HtlcConfTarget: htlcConfTarget,
 		ExternalHtlc:   in.ExternalHtlc,
+		Label:          in.Label,
 	}
 	if in.LastHop != nil {
 		lastHop, err := route.NewVertexFromBytes(in.LastHop)

loopdb/loop.go

@@ -43,6 +43,9 @@ type SwapContract struct {
 
 	// InitiationTime is the time at which the swap was initiated.
 	InitiationTime time.Time
+
+	// Label contains an optional label for the swap.
+	Label string
 }
 
 // Loop contains fields shared between LoopIn and LoopOut

loopdb/loopin.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/coreos/bbolt"
+	"github.com/lightninglabs/loop/labels"
 	"github.com/lightningnetwork/lnd/routing/route"
 )
 
@@ -24,6 +26,10 @@ type LoopInContract struct {
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.
 	ExternalHtlc bool
+
+	// Label contains an optional label for the swap. Note that this field
+	// is stored separately to the rest of the contract on disk.
+	Label string
 }
 
 // LoopIn is a combination of the contract and the updates.
@@ -112,6 +118,31 @@ func serializeLoopInContract(swap *LoopInContract) (
 	return b.Bytes(), nil
 }
 
+// putLabel performs validation of a label and writes it to the bucket provided
+// under the label key if it is non-zero.
+func putLabel(bucket *bbolt.Bucket, label string) error {
+	if len(label) == 0 {
+		return nil
+	}
+
+	if err := labels.Validate(label); err != nil {
+		return err
+	}
+
+	return bucket.Put(labelKey, []byte(label))
+}
+
+// getLabel attempts to get an optional label stored under the label key in a
+// bucket. If it is not present, an empty label is returned.
+func getLabel(bucket *bbolt.Bucket) string {
+	label := bucket.Get(labelKey)
+	if label == nil {
+		return ""
+	}
+
+	return string(label)
+}
+
 // deserializeLoopInContract deserializes the loop in contract from a byte slice.
 func deserializeLoopInContract(value []byte) (*LoopInContract, error) {
 	r := bytes.NewReader(value)

loopdb/store.go

@@ -60,6 +60,15 @@ var (
 	// value: time || rawSwapState
 	contractKey = []byte("contract")
 
+	// labelKey is the key that stores an optional label for the swap. If
+	// a swap was created before we started adding labels, or was created
+	// without a label, this key will not be present.
+	//
+	// path: loopInBucket/loopOutBucket -> swapBucket[hash] -> labelKey
+	//
+	// value: string label
+	labelKey = []byte("label")
+
 	// outgoingChanSetKey is the key that stores a list of channel ids that
 	// restrict the loop out swap payment.
 	//
@@ -207,6 +216,9 @@ func (s *boltSwapStore) FetchLoopOutSwaps() ([]*LoopOut, error) {
 				return err
 			}
 
+			// Get our label for this swap, if it is present.
+			contract.Label = getLabel(swapBucket)
+
 			// Read the list of concatenated outgoing channel ids
 			// that form the outgoing set.
 			setBytes := swapBucket.Get(outgoingChanSetKey)
@@ -352,6 +364,9 @@ func (s *boltSwapStore) FetchLoopInSwaps() ([]*LoopIn, error) {
 				return err
 			}
 
+			// Get our label for this swap, if it is present.
+			contract.Label = getLabel(swapBucket)
+
 			updates, err := deserializeUpdates(swapBucket)
 			if err != nil {
 				return err
@@ -434,6 +449,10 @@ func (s *boltSwapStore) CreateLoopOut(hash lntypes.Hash,
 			return err
 		}
 
+		if err := putLabel(swapBucket, swap.Label); err != nil {
+			return err
+		}
+
 		// Write the outgoing channel set.
 		var b bytes.Buffer
 		for _, chanID := range swap.OutgoingChanSet {
@@ -447,6 +466,11 @@ func (s *boltSwapStore) CreateLoopOut(hash lntypes.Hash,
 			return err
 		}
 
+		// Write label to disk if we have one.
+		if err := putLabel(swapBucket, swap.Label); err != nil {
+			return err
+		}
+
 		// Finally, we'll create an empty updates bucket for this swap
 		// to track any future updates to the swap itself.
 		_, err = swapBucket.CreateBucket(updatesBucketKey)
@@ -485,6 +509,11 @@ func (s *boltSwapStore) CreateLoopIn(hash lntypes.Hash,
 			return err
 		}
 
+		// Write label to disk if we have one.
+		if err := putLabel(swapBucket, swap.Label); err != nil {
+			return err
+		}
+
 		// Finally, we'll create an empty updates bucket for this swap
 		// to track any future updates to the swap itself.
 		_, err = swapBucket.CreateBucket(updatesBucketKey)