Merge pull request #75 from halseth/batcher-impl

SwapPublicationDeadline for LoopOut contracts

Author: alexbosworth

cmd/loop/loopin.go

@@ -68,7 +68,7 @@ func loopIn(ctx *cli.Context) error {
 	}
 
 	limits := getInLimits(amt, quote)
-	err = displayLimits(swap.TypeIn, amt, limits, external)
+	err = displayLimits(swap.TypeIn, amt, limits, external, "")
 	if err != nil {
 		return err
 	}

cmd/loop/loopout.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/looprpc"
@@ -44,6 +45,16 @@ var loopOutCommand = cli.Command{
 				"should be swept within",
 			Value: uint64(loop.DefaultSweepConfTarget),
 		},
+		cli.BoolFlag{
+			Name: "fast",
+			Usage: "Indicate you want to swap immediately, " +
+				"paying potentially a higher fee. If not " +
+				"set the swap server might choose to wait up " +
+				"to 30 minutes before publishing the swap " +
+				"HTLC on-chain, to save on chain fees. Not " +
+				"setting this flag might result in a lower " +
+				"swap fee.",
+		},
 	},
 	Action: loopOut,
 }
@@ -92,9 +103,19 @@ func loopOut(ctx *cli.Context) error {
 		return err
 	}
 
-	limits := getLimits(amt, quote)
+	// Show a warning if a slow swap was requested.
+	fast := ctx.Bool("fast")
+	warning := ""
+	if fast {
+		warning = "Fast swap requested."
+	} else {
+		warning = fmt.Sprintf("Regular swap speed requested, it "+
+			"might take up to %v for the swap to be executed.",
+			defaultSwapWaitTime)
+	}
 
-	err = displayLimits(swap.TypeOut, amt, limits, false)
+	limits := getLimits(amt, quote)
+	err = displayLimits(swap.TypeOut, amt, limits, false, warning)
 	if err != nil {
 		return err
 	}
@@ -104,16 +125,24 @@ func loopOut(ctx *cli.Context) error {
 		unchargeChannel = ctx.Uint64("channel")
 	}
 
+	// Set our maximum swap wait time. If a fast swap is requested we set
+	// it to now, otherwise to 30 minutes in the future.
+	swapDeadline := time.Now()
+	if !fast {
+		swapDeadline = time.Now().Add(defaultSwapWaitTime)
+	}
+
 	resp, err := client.LoopOut(context.Background(), &looprpc.LoopOutRequest{
-		Amt:                 int64(amt),
-		Dest:                destAddr,
-		MaxMinerFee:         int64(limits.maxMinerFee),
-		MaxPrepayAmt:        int64(*limits.maxPrepayAmt),
-		MaxSwapFee:          int64(limits.maxSwapFee),
-		MaxPrepayRoutingFee: int64(*limits.maxPrepayRoutingFee),
-		MaxSwapRoutingFee:   int64(*limits.maxSwapRoutingFee),
-		LoopOutChannel:      unchargeChannel,
-		SweepConfTarget:     sweepConfTarget,
+		Amt:                     int64(amt),
+		Dest:                    destAddr,
+		MaxMinerFee:             int64(limits.maxMinerFee),
+		MaxPrepayAmt:            int64(*limits.maxPrepayAmt),
+		MaxSwapFee:              int64(limits.maxSwapFee),
+		MaxPrepayRoutingFee:     int64(*limits.maxPrepayRoutingFee),
+		MaxSwapRoutingFee:       int64(*limits.maxSwapRoutingFee),
+		LoopOutChannel:          unchargeChannel,
+		SweepConfTarget:         sweepConfTarget,
+		SwapPublicationDeadline: uint64(swapDeadline.Unix()),
 	})
 	if err != nil {
 		return err

cmd/loop/main.go

@@ -26,6 +26,8 @@ var (
 	maxRoutingFeeBase = btcutil.Amount(10)
 
 	maxRoutingFeeRate = int64(20000)
+
+	defaultSwapWaitTime = 30 * time.Minute
 )
 
 func printRespJSON(resp proto.Message) {
@@ -117,7 +119,7 @@ func getLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
 }
 
 func displayLimits(swapType swap.Type, amt btcutil.Amount, l *limits,
-	externalHtlc bool) error {
+	externalHtlc bool, warning string) error {
 
 	totalSuccessMax := l.maxMinerFee + l.maxSwapFee
 	if l.maxSwapRoutingFee != nil {
@@ -138,6 +140,10 @@ func displayLimits(swapType swap.Type, amt btcutil.Amount, l *limits,
 		amt, swapType, totalSuccessMax,
 	)
 
+	if warning != "" {
+		fmt.Println(warning)
+	}
+
 	fmt.Printf("CONTINUE SWAP? (y/n), expand fee detail (x): ")
 
 	var answer string

cmd/loopd/swapclient_server.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"sort"
+	"time"
 
 	"github.com/lightningnetwork/lnd/queue"
 
@@ -76,6 +77,9 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
 		MaxSwapRoutingFee:   btcutil.Amount(in.MaxSwapRoutingFee),
 		MaxSwapFee:          btcutil.Amount(in.MaxSwapFee),
 		SweepConfTarget:     sweepConfTarget,
+		SwapPublicationDeadline: time.Unix(
+			int64(in.SwapPublicationDeadline), 0,
+		),
 	}
 	if in.LoopOutChannel != 0 {
 		req.LoopOutChannel = &in.LoopOutChannel

interface.go

@@ -64,8 +64,12 @@ type OutRequest struct {
 	SweepConfTarget int32
 
 	// LoopOutChannel optionally specifies the short channel id of the
-	// channel to uncharge.
+	// channel to loop out.
 	LoopOutChannel *uint64
+
+	// SwapPublicationDeadline can be set by the client to allow the server
+	// delaying publication of the swap HTLC to save on chain fees.
+	SwapPublicationDeadline time.Time
 }
 
 // Out contains the full details of a loop out request. This includes things
@@ -149,15 +153,15 @@ type LoopInRequest struct {
 	// MaxSwapFee is the maximum we are willing to pay the server for the
 	// swap. This value is not disclosed in the swap initiation call, but if
 	// the server asks for a higher fee, we abort the swap. Typically this
-	// value is taken from the response of the UnchargeQuote call. It
+	// value is taken from the response of the LoopInQuote call. It
 	// includes the prepay amount.
 	MaxSwapFee btcutil.Amount
 
 	// MaxMinerFee is the maximum in on-chain fees that we are willing to
 	// spent. If we publish the on-chain htlc and the fee estimate turns out
 	// higher than this value, we cancel the swap.
 	//
-	// MaxMinerFee is typically taken from the response of the UnchargeQuote
+	// MaxMinerFee is typically taken from the response of the LoopInQuote
 	// call.
 	MaxMinerFee btcutil.Amount
 
@@ -166,15 +170,15 @@ type LoopInRequest struct {
 	HtlcConfTarget int32
 
 	// LoopInChannel optionally specifies the short channel id of the
-	// channel to charge.
+	// channel to loop in.
 	LoopInChannel *uint64
 
 	// ExternalHtlc specifies whether the htlc is published by an external
 	// source.
 	ExternalHtlc bool
 }
 
-// LoopInTerms are the server terms on which it executes charge swaps.
+// LoopInTerms are the server terms on which it executes loop in swaps.
 type LoopInTerms struct {
 	// MinSwapAmount is the minimum amount that the server requires for a
 	// swap.

loopdb/loopout.go

@@ -45,6 +45,12 @@ type LoopOutContract struct {
 	// MaxPrepayRoutingFee is the maximum off-chain fee in msat that may be
 	// paid for the prepayment to the server.
 	MaxPrepayRoutingFee btcutil.Amount
+
+	// SwapPublicationDeadline is a timestamp that the server commits to
+	// have the on-chain swap published by. It is set by the client to
+	// allow the server to delay the publication in exchange for possibly
+	// lower fees.
+	SwapPublicationDeadline time.Time
 }
 
 // LoopOut is a combination of the contract and the updates.
@@ -158,6 +164,13 @@ func deserializeLoopOutContract(value []byte, chainParams *chaincfg.Params) (
 		contract.UnchargeChannel = &unchargeChannel
 	}
 
+	var deadlineNano int64
+	err = binary.Read(r, byteOrder, &deadlineNano)
+	if err != nil {
+		return nil, err
+	}
+	contract.SwapPublicationDeadline = time.Unix(0, deadlineNano)
+
 	return &contract, nil
 }
 
@@ -243,5 +256,10 @@ func serializeLoopOutContract(swap *LoopOutContract) (
 		return nil, err
 	}
 
+	err = binary.Write(&b, byteOrder, swap.SwapPublicationDeadline.UnixNano())
+	if err != nil {
+		return nil, err
+	}
+
 	return b.Bytes(), nil
 }

loopdb/meta.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/coreos/bbolt"
 )
 
@@ -24,14 +25,17 @@ var (
 // migration is a function which takes a prior outdated version of the database
 // instances and mutates the key/bucket structure to arrive at a more
 // up-to-date version of the database.
-type migration func(tx *bbolt.Tx) error
+type migration func(tx *bbolt.Tx, chainParams *chaincfg.Params) error
 
 var (
 	// dbVersions is storing all versions of database. If current version
 	// of database don't match with latest version this list will be used
 	// for retrieving all migration function that are need to apply to the
 	// current db.
-	migrations = []migration{migrateCosts}
+	migrations = []migration{
+		migrateCosts,
+		migrateSwapPublicationDeadline,
+	}
 
 	latestDBVersion = uint32(len(migrations))
 )
@@ -76,7 +80,7 @@ func setDBVersion(tx *bbolt.Tx, version uint32) error {
 // syncVersions function is used for safe db version synchronization. It
 // applies migration functions to the current database and recovers the
 // previous state of db if at least one error/panic appeared during migration.
-func syncVersions(db *bbolt.DB) error {
+func syncVersions(db *bbolt.DB, chainParams *chaincfg.Params) error {
 	currentVersion, err := getDBVersion(db)
 	if err != nil {
 		return err
@@ -112,7 +116,7 @@ func syncVersions(db *bbolt.DB) error {
 			log.Infof("Applying migration #%v", v+1)
 
 			migration := migrations[v]
-			if err := migration(tx); err != nil {
+			if err := migration(tx, chainParams); err != nil {
 				log.Infof("Unable to apply migration #%v",
 					v+1)
 				return err

loopdb/migration_01_costs.go

@@ -4,12 +4,13 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/coreos/bbolt"
 )
 
 // noMigrationAvailable is the fall back migration in case there is no migration
 // implemented.
-func migrateCosts(tx *bbolt.Tx) error {
+func migrateCosts(tx *bbolt.Tx, _ *chaincfg.Params) error {
 	if err := migrateCostsForBucket(tx, loopInBucketKey); err != nil {
 		return err
 	}

loopdb/migration_02_swap_publication_deadline.go

@@ -0,0 +1,58 @@
+package loopdb
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/coreos/bbolt"
+)
+
+// migrateSwapPublicationDeadline migrates the database to v02, by adding the
+// SwapPublicationDeadline field to loop out contracts.
+func migrateSwapPublicationDeadline(tx *bbolt.Tx, chainParams *chaincfg.Params) error {
+	rootBucket := tx.Bucket(loopOutBucketKey)
+	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")
+		}
+
+		// Write the current contract serialization into a buffer.
+		b := &bytes.Buffer{}
+		if _, err := b.Write(contractBytes); err != nil {
+			return err
+		}
+
+		// We migrate to the new format by copying the first 8 bytes
+		// (the creation time) to the end (the swap deadline)
+		var swapDeadline [8]byte
+		copy(swapDeadline[:], contractBytes[:8])
+		if _, err := b.Write(swapDeadline[:]); err != nil {
+			return err
+		}
+
+		return swapBucket.Put(contractKey, b.Bytes())
+	})
+}

loopdb/store.go

@@ -135,7 +135,7 @@ func NewBoltSwapStore(dbPath string, chainParams *chaincfg.Params) (
 
 	// Finally, before we start, we'll sync the DB versions to pick up any
 	// possible DB migrations.
-	err = syncVersions(bdb)
+	err = syncVersions(bdb, chainParams)
 	if err != nil {
 		return nil, err
 	}