Merge pull request #595 from lightninglabs/manual_fee_rate_support

Manual fee rate support

Author: Roasbeef

cmd/tapcli/assets.go

@@ -3,6 +3,7 @@ package main
 import (
 	"encoding/hex"
 	"fmt"
+	"math"
 	"os"
 
 	taprootassets "github.com/lightninglabs/taproot-assets"
@@ -48,6 +49,7 @@ var (
 	groupByGroupName             = "by_group"
 	assetIDName                  = "asset_id"
 	shortResponseName            = "short"
+	feeRateName                  = "fee_rate"
 	assetAmountName              = "amount"
 	burnOverrideConfirmationName = "override_confirmation_destroy_assets"
 )
@@ -250,17 +252,41 @@ var finalizeBatchCommand = cli.Command{
 				"in order to avoid printing a large amount " +
 				"of data in case of large batches",
 		},
+		cli.Uint64Flag{
+			Name: feeRateName,
+			Usage: "if set, the fee rate in sat/kw to use for the" +
+				"minting transaction",
+		},
 	},
 	Action: finalizeBatch,
 }
 
+func parseFeeRate(ctx *cli.Context) (uint32, error) {
+	if ctx.IsSet(feeRateName) {
+		feeRate := ctx.Uint64(feeRateName)
+		if feeRate > math.MaxUint32 {
+			return 0, fmt.Errorf("fee rate exceeds 2^32")
+		}
+
+		return uint32(feeRate), nil
+	}
+
+	return uint32(0), nil
+}
+
 func finalizeBatch(ctx *cli.Context) error {
 	ctxc := getContext()
 	client, cleanUp := getMintClient(ctx)
 	defer cleanUp()
 
+	feeRate, err := parseFeeRate(ctx)
+	if err != nil {
+		return err
+	}
+
 	resp, err := client.FinalizeBatch(ctxc, &mintrpc.FinalizeBatchRequest{
 		ShortResponse: ctx.Bool(shortResponseName),
+		FeeRate:       feeRate,
 	})
 	if err != nil {
 		return fmt.Errorf("unable to finalize batch: %w", err)
@@ -496,6 +522,11 @@ var sendAssetsCommand = cli.Command{
 			Usage: "addr to send to; can be specified multiple " +
 				"times to send to multiple addresses at once",
 		},
+		cli.Uint64Flag{
+			Name: feeRateName,
+			Usage: "if set, the fee rate in sat/kw to use for the" +
+				"anchor transaction",
+		},
 		// TODO(roasbeef): add arg for file name to write sender proof
 		// blob
 	},
@@ -512,8 +543,14 @@ func sendAssets(ctx *cli.Context) error {
 	client, cleanUp := getClient(ctx)
 	defer cleanUp()
 
+	feeRate, err := parseFeeRate(ctx)
+	if err != nil {
+		return err
+	}
+
 	resp, err := client.SendAsset(ctxc, &taprpc.SendAssetRequest{
 		TapAddrs: addrs,
+		FeeRate:  feeRate,
 	})
 	if err != nil {
 		return fmt.Errorf("unable to send assets: %w", err)

rpcserver.go

@@ -42,6 +42,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/keychain"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/signal"
 	"google.golang.org/grpc"
 )
@@ -443,12 +444,39 @@ func (r *rpcServer) MintAsset(ctx context.Context,
 	}
 }
 
+// checkFeeRateSanity ensures that the provided fee rate is above the same
+// minimum fee used as a floor in the fee estimator.
+func checkFeeRateSanity(rpcFeeRate uint32) (*chainfee.SatPerKWeight, error) {
+	var feeRate *chainfee.SatPerKWeight
+	switch {
+	// No manual fee rate was set, which is the default.
+	case rpcFeeRate == 0:
+
+	// A manual fee was set but is below a reasonable floor.
+	case rpcFeeRate < uint32(chainfee.FeePerKwFloor):
+		return nil, fmt.Errorf("manual fee rate %d below floor of %d",
+			rpcFeeRate, uint32(chainfee.FeePerKwFloor))
+
+	default:
+		// Set the fee rate for this transaction.
+		manualFeeRate := chainfee.SatPerKWeight(rpcFeeRate)
+		feeRate = &manualFeeRate
+	}
+
+	return feeRate, nil
+}
+
 // FinalizeBatch attempts to finalize the current pending batch.
 func (r *rpcServer) FinalizeBatch(_ context.Context,
 	req *mintrpc.FinalizeBatchRequest) (*mintrpc.FinalizeBatchResponse,
 	error) {
 
-	batch, err := r.cfg.AssetMinter.FinalizeBatch()
+	feeRate, err := checkFeeRateSanity(req.FeeRate)
+	if err != nil {
+		return nil, err
+	}
+
+	batch, err := r.cfg.AssetMinter.FinalizeBatch(feeRate)
 	if err != nil {
 		return nil, fmt.Errorf("unable to finalize batch: %w", err)
 	}
@@ -1961,8 +1989,13 @@ func (r *rpcServer) SendAsset(_ context.Context,
 		}
 	}
 
+	feeRate, err := checkFeeRateSanity(req.FeeRate)
+	if err != nil {
+		return nil, err
+	}
+
 	resp, err := r.cfg.ChainPorter.RequestShipment(
-		tapfreighter.NewAddressParcel(tapAddrs...),
+		tapfreighter.NewAddressParcel(feeRate, tapAddrs...),
 	)
 	if err != nil {
 		return nil, err

tapfreighter/chain_porter.go

@@ -20,6 +20,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tappsbt"
 	"github.com/lightninglabs/taproot-assets/tapscript"
 	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 )
 
 // ChainPorterConfig is the main config for the chain porter.
@@ -880,14 +881,32 @@ func (p *ChainPorter) stateStep(currentPkg sendPackage) (*sendPackage, error) {
 		// Submit the template PSBT to the wallet for funding.
 		//
 		// TODO(roasbeef): unlock the input UTXOs of things fail
-		feeRate, err := p.cfg.ChainBridge.EstimateFee(
-			ctx, tapscript.SendConfTarget,
+		var (
+			feeRate chainfee.SatPerKWeight
+			err     error
 		)
-		if err != nil {
-			return nil, fmt.Errorf("unable to estimate fee: %w",
-				err)
+
+		// First, use a manual fee rate if specified by the parcel.
+		// TODO(jhb): Support PSBT flow / PreSignedParcels
+		addrParcel, ok := currentPkg.Parcel.(*AddressParcel)
+		switch {
+		case ok && addrParcel.transferFeeRate != nil:
+			feeRate = *addrParcel.transferFeeRate
+			log.Infof("sending with manual fee rate")
+
+		default:
+			feeRate, err = p.cfg.ChainBridge.EstimateFee(
+				ctx, tapscript.SendConfTarget,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("unable to estimate "+
+					"fee: %w", err)
+			}
 		}
 
+		readableFeeRate := feeRate.FeePerKVByte().String()
+		log.Infof("sending with fee rate: %v", readableFeeRate)
+
 		vPacket := currentPkg.VirtualPacket
 		firstRecipient, err := vPacket.FirstNonSplitRootOutput()
 		if err != nil {

tapfreighter/parcel.go

@@ -17,6 +17,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/tappsbt"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/keychain"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 )
 
 // SendState is an enum that describes the current state of a pending outbound
@@ -130,20 +131,27 @@ type AddressParcel struct {
 	// destAddrs is the list of address that should be used to satisfy the
 	// transfer.
 	destAddrs []*address.Tap
+
+	// transferFeeRate is an optional manually-set feerate specified when
+	// requesting an asset transfer.
+	transferFeeRate *chainfee.SatPerKWeight
 }
 
 // A compile-time assertion to ensure AddressParcel implements the parcel
 // interface.
 var _ Parcel = (*AddressParcel)(nil)
 
 // NewAddressParcel creates a new AddressParcel.
-func NewAddressParcel(destAddrs ...*address.Tap) *AddressParcel {
+func NewAddressParcel(feeRate *chainfee.SatPerKWeight,
+	destAddrs ...*address.Tap) *AddressParcel {
+
 	return &AddressParcel{
 		parcelKit: &parcelKit{
 			respChan: make(chan *OutboundParcel, 1),
 			errChan:  make(chan error, 1),
 		},
-		destAddrs: destAddrs,
+		destAddrs:       destAddrs,
+		transferFeeRate: feeRate,
 	}
 }
 

tapfreighter/wallet.go

@@ -1442,6 +1442,7 @@ func (f *AssetWallet) AnchorVirtualTransactions(ctx context.Context,
 		return nil, fmt.Errorf("unable to get on-chain fees for psbt: "+
 			"%w", err)
 	}
+	log.Infof("PSBT absolute fee: %d sats", chainFees)
 
 	err = psbt.MaybeFinalizeAll(signedPsbt)
 	if err != nil {

tapgarden/caretaker.go

@@ -21,22 +21,20 @@ import (
 	"github.com/lightninglabs/taproot-assets/commitment"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
+	"github.com/lightninglabs/taproot-assets/tapscript"
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"golang.org/x/exp/maps"
 	"golang.org/x/sync/errgroup"
 )
 
 var (
-	// GenesisDummyScript is a dummy script that we'll use to fund the
-	// initial PSBT packet that'll create initial set of assets. It's the
-	// same size as a encoded P2TR output.
-	GenesisDummyScript [34]byte
 
 	// DummyGenesisTxOut is the dummy TxOut we'll place in the PSBt funding
 	// request to make sure we leave enough room for change and fees.
 	DummyGenesisTxOut = wire.TxOut{
-		PkScript: GenesisDummyScript[:],
+		PkScript: tapscript.GenesisDummyScript[:],
 		Value:    int64(GenesisAmtSats),
 	}
 
@@ -72,6 +70,10 @@ type BatchCaretakerConfig struct {
 	// Batch is the minting batch that this caretaker is responsible for?
 	Batch *MintingBatch
 
+	// BatchFeeRate is an optional manually-set feerate specified when
+	// finalizing a batch.
+	BatchFeeRate *chainfee.SatPerKWeight
+
 	GardenKit
 
 	// BroadcastCompleteChan is used to signal back to the caller that the
@@ -386,13 +388,26 @@ func (b *BatchCaretaker) fundGenesisPsbt(ctx context.Context) (*FundedPsbt, erro
 	log.Infof("BatchCaretaker(%x): creating skeleton PSBT", b.batchKey[:])
 	log.Tracef("PSBT: %v", spew.Sdump(genesisPkt))
 
-	feeRate, err := b.cfg.ChainBridge.EstimateFee(
-		ctx, GenesisConfTarget,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("unable to estimate fee: %w", err)
+	// If a fee rate was manually assigned for this batch, use that instead
+	// of a fee rate estimate.
+	var feeRate chainfee.SatPerKWeight
+	switch {
+	case b.cfg.BatchFeeRate != nil:
+		feeRate = *b.cfg.BatchFeeRate
+		log.Infof("BatchCaretaker(%x): using manual fee rate")
+
+	default:
+		feeRate, err = b.cfg.ChainBridge.EstimateFee(
+			ctx, GenesisConfTarget,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to estimate fee: %w", err)
+		}
 	}
 
+	log.Infof("BatchCaretaker(%x): using fee rate: %v",
+		feeRate.FeePerKVByte().String())
+
 	fundedGenesisPkt, err := b.cfg.Wallet.FundPsbt(
 		ctx, genesisPkt, 1, feeRate,
 	)
@@ -723,6 +738,8 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 		}
 		b.cfg.Batch.GenesisPacket.ChainFees = chainFees
 
+		log.Infof("BatchCaretaker(%x): GenesisPacket absolute fee: "+
+			"%d sats", chainFees)
 		log.Infof("BatchCaretaker(%x): GenesisPacket finalized",
 			b.batchKey[:])
 		log.Tracef("GenesisPacket: %v", spew.Sdump(signedPkt))

tapgarden/interface.go

@@ -44,7 +44,7 @@ type Planter interface {
 
 	// FinalizeBatch signals that the asset minter should finalize
 	// the current batch, if one exists.
-	FinalizeBatch() (*MintingBatch, error)
+	FinalizeBatch(feeRate *chainfee.SatPerKWeight) (*MintingBatch, error)
 
 	// CancelBatch signals that the asset minter should cancel the
 	// current batch, if one exists.