format: apply llformat baseline

Author: hieblmi

assets/client.go

@@ -50,6 +50,7 @@ type TapdConfig struct {
 // assets daemon.
 func DefaultTapdConfig() *TapdConfig {
 	defaultConf := tapcfg.DefaultConfig()
+
 	return &TapdConfig{
 		Activate:     false,
 		Host:         "localhost:10029",
@@ -83,14 +84,18 @@ func NewTapdClient(config *TapdConfig) (*TapdClient, error) {
 
 	// Create the TapdClient.
 	client := &TapdClient{
-		assetNameCache:             make(map[string]string),
-		cc:                         conn,
-		cfg:                        config,
-		TaprootAssetsClient:        taprpc.NewTaprootAssetsClient(conn),
-		TaprootAssetChannelsClient: tapchannelrpc.NewTaprootAssetChannelsClient(conn),
-		PriceOracleClient:          priceoraclerpc.NewPriceOracleClient(conn),
-		RfqClient:                  rfqrpc.NewRfqClient(conn),
-		UniverseClient:             universerpc.NewUniverseClient(conn),
+		assetNameCache:      make(map[string]string),
+		cc:                  conn,
+		cfg:                 config,
+		TaprootAssetsClient: taprpc.NewTaprootAssetsClient(conn),
+		TaprootAssetChannelsClient: tapchannelrpc.NewTaprootAssetChannelsClient(
+			conn,
+		),
+		PriceOracleClient: priceoraclerpc.NewPriceOracleClient(
+			conn,
+		),
+		RfqClient:      rfqrpc.NewRfqClient(conn),
+		UniverseClient: universerpc.NewUniverseClient(conn),
 	}
 
 	return client, nil
@@ -104,9 +109,8 @@ func (c *TapdClient) Close() {
 // GetRfqForAsset returns a RFQ for the given asset with the given amount and
 // to the given peer.
 func (c *TapdClient) GetRfqForAsset(ctx context.Context,
-	satAmount btcutil.Amount, assetId, peerPubkey []byte,
-	expiry int64, feeLimitMultiplier float64) (
-	*rfqrpc.PeerAcceptedSellQuote, error) {
+	satAmount btcutil.Amount, assetId, peerPubkey []byte, expiry int64,
+	feeLimitMultiplier float64) (*rfqrpc.PeerAcceptedSellQuote, error) {
 
 	// paymentMaxAmt is the maximum amount we are willing to pay for the
 	// payment.
@@ -149,8 +153,8 @@ func (c *TapdClient) GetRfqForAsset(ctx context.Context,
 }
 
 // GetAssetName returns the human-readable name of the asset.
-func (c *TapdClient) GetAssetName(ctx context.Context,
-	assetId []byte) (string, error) {
+func (c *TapdClient) GetAssetName(ctx context.Context, assetId []byte) (string,
+	error) {
 
 	c.assetNameMutex.Lock()
 	defer c.assetNameMutex.Unlock()
@@ -220,13 +224,15 @@ func (c *TapdClient) GetAssetPrice(ctx context.Context, assetID string,
 	}
 
 	if rfq.GetInvalidQuote() != nil {
-		return 0, fmt.Errorf("peer %v sent an invalid quote response %v for "+
-			"asset %v", peerPubkey, rfq.GetInvalidQuote(), assetID)
+		return 0, fmt.Errorf("peer %v sent an invalid quote response "+
+			"%v for asset %v", peerPubkey, rfq.GetInvalidQuote(),
+			assetID)
 	}
 
 	if rfq.GetRejectedQuote() != nil {
 		return 0, fmt.Errorf("peer %v rejected the quote request for "+
-			"asset %v, %v", peerPubkey, assetID, rfq.GetRejectedQuote())
+			"asset %v, %v", peerPubkey, assetID,
+			rfq.GetRejectedQuote())
 	}
 
 	acceptedRes := rfq.GetAcceptedQuote()
@@ -240,8 +246,8 @@ func (c *TapdClient) GetAssetPrice(ctx context.Context, assetID string,
 
 // getSatsFromAssetAmt returns the amount in satoshis for the given asset amount
 // and asset rate.
-func getSatsFromAssetAmt(assetAmt uint64, assetRate *rfqrpc.FixedPoint) (
-	btcutil.Amount, error) {
+func getSatsFromAssetAmt(assetAmt uint64,
+	assetRate *rfqrpc.FixedPoint) (btcutil.Amount, error) {
 
 	rateFP, err := rpcutils.UnmarshalRfqFixedPoint(assetRate)
 	if err != nil {
@@ -257,8 +263,8 @@ func getSatsFromAssetAmt(assetAmt uint64, assetRate *rfqrpc.FixedPoint) (
 
 // getPaymentMaxAmount returns the milisat amount we are willing to pay for the
 // payment.
-func getPaymentMaxAmount(satAmount btcutil.Amount, feeLimitMultiplier float64) (
-	lnwire.MilliSatoshi, error) {
+func getPaymentMaxAmount(satAmount btcutil.Amount,
+	feeLimitMultiplier float64) (lnwire.MilliSatoshi, error) {
 
 	if satAmount == 0 {
 		return 0, fmt.Errorf("satAmount cannot be zero")
@@ -273,7 +279,10 @@ func getPaymentMaxAmount(satAmount btcutil.Amount, feeLimitMultiplier float64) (
 	// The resulting maximum amount we're willing to pay is 300k sats.
 	// The response asset amount will be for those 300k sats.
 	return lnrpc.UnmarshallAmt(
-		int64(satAmount.MulF64(feeLimitMultiplier)), 0,
+		int64(
+			satAmount.MulF64(feeLimitMultiplier),
+		),
+		0,
 	)
 }
 

assets/client_test.go

@@ -76,27 +76,38 @@ func TestGetSatsFromAssetAmt(t *testing.T) {
 		expectError bool
 	}{
 		{
-			assetAmt:    1000,
-			assetRate:   &rfqrpc.FixedPoint{Coefficient: "100000", Scale: 0},
+			assetAmt: 1000,
+			assetRate: &rfqrpc.FixedPoint{
+				Coefficient: "100000",
+				Scale:       0,
+			},
 			expected:    btcutil.Amount(1000000),
 			expectError: false,
 		},
 		{
-			assetAmt:    500000,
-			assetRate:   &rfqrpc.FixedPoint{Coefficient: "200000000", Scale: 0},
+			assetAmt: 500000,
+			assetRate: &rfqrpc.FixedPoint{
+				Coefficient: "200000000",
+				Scale:       0,
+			},
 			expected:    btcutil.Amount(250000),
 			expectError: false,
 		},
 		{
-			assetAmt:    0,
-			assetRate:   &rfqrpc.FixedPoint{Coefficient: "100000000", Scale: 0},
+			assetAmt: 0,
+			assetRate: &rfqrpc.FixedPoint{
+				Coefficient: "100000000",
+				Scale:       0,
+			},
 			expected:    btcutil.Amount(0),
 			expectError: false,
 		},
 	}
 
 	for _, test := range tests {
-		result, err := getSatsFromAssetAmt(test.assetAmt, test.assetRate)
+		result, err := getSatsFromAssetAmt(
+			test.assetAmt, test.assetRate,
+		)
 		if test.expectError {
 			require.NotNil(t, err)
 		} else {

client.go

@@ -86,8 +86,8 @@ var (
 	// defaultRFQExpiry is the default expiry time for RFQs.
 	defaultRFQExpiry = 5 * time.Minute
 
-	// defaultRFQMaxLimitMultiplier is the default maximum fee multiplier for
-	// RFQs.
+	// defaultRFQMaxLimitMultiplier is the default maximum fee multiplier
+	// for RFQs.
 	defaultRFQMaxLimitMultiplier = 1.2
 )
 
@@ -179,8 +179,8 @@ type ClientConfig struct {
 
 // NewClient returns a new instance to initiate swaps with.
 func NewClient(dbDir string, loopDB loopdb.SwapStore,
-	sweeperDb sweepbatcher.BatcherStore, cfg *ClientConfig) (
-	*Client, func(), error) {
+	sweeperDb sweepbatcher.BatcherStore, cfg *ClientConfig) (*Client,
+	func(), error) {
 
 	l402Store, err := l402.NewFileStore(dbDir)
 	if err != nil {
@@ -209,7 +209,9 @@ func NewClient(dbDir string, loopDB loopdb.SwapStore,
 		Lnd: cfg.Lnd,
 	}
 
-	verifySchnorrSig := func(pubKey *btcec.PublicKey, hash, sig []byte) error {
+	verifySchnorrSig := func(pubKey *btcec.PublicKey, hash,
+		sig []byte) error {
+
 		schnorrSig, err := schnorr.ParseSignature(sig)
 		if err != nil {
 			return err
@@ -226,8 +228,9 @@ func NewClient(dbDir string, loopDB loopdb.SwapStore,
 		loopDB, cfg.Lnd.ChainParams,
 	)
 	if err != nil {
-		return nil, nil, fmt.Errorf("sweepbatcher."+
-			"NewSweepFetcherFromSwapStore failed: %w", err)
+		return nil, nil, fmt.Errorf(
+			"sweepbatcher.NewSweepFetcherFromSwapStore failed: %w",
+			err)
 	}
 
 	// There is circular dependency between executor and sweepbatcher, as
@@ -281,9 +284,11 @@ func NewClient(dbDir string, loopDB loopdb.SwapStore,
 			}
 			skippedTxns[*txid] = struct{}{}
 		}
-		batcherOpts = append(batcherOpts, sweepbatcher.WithSkippedTxns(
-			skippedTxns,
-		))
+		batcherOpts = append(
+			batcherOpts, sweepbatcher.WithSkippedTxns(
+				skippedTxns,
+			),
+		)
 	}
 
 	batcher := sweepbatcher.NewBatcher(
@@ -533,15 +538,14 @@ func (s *Client) resumeSwaps(ctx context.Context,
 // automatically after restarts.
 //
 // The return value is a hash that uniquely identifies the new swap.
-func (s *Client) LoopOut(globalCtx context.Context,
-	request *OutRequest) (*LoopOutSwapInfo, error) {
+func (s *Client) LoopOut(globalCtx context.Context, request *OutRequest) (
+	*LoopOutSwapInfo, error) {
 
 	if request.AssetId != nil {
 		if request.AssetPrepayRfqId == nil ||
 			request.AssetSwapRfqId == nil {
-
-			return nil, errors.New("asset prepay and swap rfq ids " +
-				"must be set when using an asset id")
+			return nil, errors.New("asset prepay and swap rfq " +
+				"ids must be set when using an asset id")
 		}
 
 		// Verify that if we have an asset id set, we have a valid asset
@@ -551,14 +555,11 @@ func (s *Client) LoopOut(globalCtx context.Context,
 				"when using an asset id")
 		}
 
-		log.Infof("LoopOut %v sats to %v with asset %x",
-			request.Amount, request.DestAddr, request.AssetId,
-		)
+		log.Infof("LoopOut %v sats to %v with asset %x", request.Amount,
+			request.DestAddr, request.AssetId)
 	} else {
-		log.Infof("LoopOut %v to %v (channels: %v)",
-			request.Amount, request.DestAddr,
-			request.OutgoingChanSet,
-		)
+		log.Infof("LoopOut %v to %v (channels: %v)", request.Amount,
+			request.DestAddr, request.OutgoingChanSet)
 	}
 
 	if err := s.waitForInitialized(globalCtx); err != nil {
@@ -750,13 +751,10 @@ func (s *Client) waitForInitialized(ctx context.Context) error {
 }
 
 // LoopIn initiates a loop in swap.
-func (s *Client) LoopIn(globalCtx context.Context,
-	request *LoopInRequest) (*LoopInSwapInfo, error) {
+func (s *Client) LoopIn(globalCtx context.Context, request *LoopInRequest) (
+	*LoopInSwapInfo, error) {
 
-	log.Infof("Loop in %v (last hop: %v)",
-		request.Amount,
-		request.LastHop,
-	)
+	log.Infof("Loop in %v (last hop: %v)", request.Amount, request.LastHop)
 
 	if err := s.waitForInitialized(globalCtx); err != nil {
 		return nil, err
@@ -802,8 +800,8 @@ func (s *Client) LoopIn(globalCtx context.Context,
 // LoopInQuote takes an amount and returns a breakdown of estimated costs for
 // the client. Both the swap server and the on-chain fee estimator are queried
 // to get to build the quote response.
-func (s *Client) LoopInQuote(ctx context.Context,
-	request *LoopInQuoteRequest) (*LoopInQuote, error) {
+func (s *Client) LoopInQuote(ctx context.Context, request *LoopInQuoteRequest) (
+	*LoopInQuote, error) {
 
 	// Retrieve current server terms to calculate swap fee.
 	terms, err := s.Server.GetLoopInTerms(ctx, request.Initiator)
@@ -945,8 +943,10 @@ func wrapGrpcError(message string, err error) error {
 	grpcStatus, _ := status.FromError(err)
 
 	return status.Error(
-		grpcStatus.Code(), fmt.Sprintf("%v: %v", message,
-			grpcStatus.Message()),
+		grpcStatus.Code(),
+		fmt.Sprintf(
+			"%v: %v", message, grpcStatus.Message(),
+		),
 	)
 }
 
@@ -976,6 +976,7 @@ func (s *Client) AbandonSwap(ctx context.Context,
 	case s.abandonChans[req.SwapHash] <- struct{}{}:
 	case <-ctx.Done():
 		return ctx.Err()
+
 	default:
 		// This is to avoid writing to a full channel.
 	}
@@ -988,8 +989,8 @@ func (s *Client) getAssetRfq(ctx context.Context, quote *LoopOutQuote,
 	request *LoopOutQuoteRequest) (*LoopOutRfq, error) {
 
 	if s.AssetClient == nil {
-		return nil, errors.New("asset client must be set " +
-			"when trying to loop out with an asset")
+		return nil, errors.New("asset client must be set when trying " +
+			"to loop out with an asset")
 	}
 	rfqReq := request.AssetRFQRequest
 	if rfqReq.Expiry == 0 {
@@ -1002,9 +1003,8 @@ func (s *Client) getAssetRfq(ctx context.Context, quote *LoopOutQuote,
 
 	// First we'll get the prepay rfq.
 	prepayRfq, err := s.AssetClient.GetRfqForAsset(
-		ctx, quote.PrepayAmount, rfqReq.AssetId,
-		rfqReq.AssetEdgeNode, rfqReq.Expiry,
-		rfqReq.MaxLimitMultiplier,
+		ctx, quote.PrepayAmount, rfqReq.AssetId, rfqReq.AssetEdgeNode,
+		rfqReq.Expiry, rfqReq.MaxLimitMultiplier,
 	)
 	if err != nil {
 		return nil, err
@@ -1023,9 +1023,8 @@ func (s *Client) getAssetRfq(ctx context.Context, quote *LoopOutQuote,
 		quote.PrepayAmount
 
 	swapRfq, err := s.AssetClient.GetRfqForAsset(
-		ctx, invoiceAmt, rfqReq.AssetId,
-		rfqReq.AssetEdgeNode, rfqReq.Expiry,
-		rfqReq.MaxLimitMultiplier,
+		ctx, invoiceAmt, rfqReq.AssetId, rfqReq.AssetEdgeNode,
+		rfqReq.Expiry, rfqReq.MaxLimitMultiplier,
 	)
 	if err != nil {
 		return nil, err

client_test.go

@@ -84,11 +84,13 @@ func TestLoopOutSuccess(t *testing.T) {
 	signalPrepaymentResult := ctx.AssertPaid(prepayInvoiceDesc)
 
 	// Expect client to register for conf.
-	confIntent := ctx.Context.AssertRegisterConf(false, req.HtlcConfirmations)
+	confIntent := ctx.Context.AssertRegisterConf(
+		false, req.HtlcConfirmations,
+	)
 
-	testLoopOutSuccess(ctx, testRequest.Amount, info.SwapHash,
-		signalPrepaymentResult, signalSwapPaymentResult, false,
-		confIntent, swap.HtlcV3,
+	testLoopOutSuccess(
+		ctx, testRequest.Amount, info.SwapHash, signalPrepaymentResult,
+		signalSwapPaymentResult, false, confIntent, swap.HtlcV3,
 	)
 }
 
@@ -267,8 +269,10 @@ func testLoopOutResume(t *testing.T, confs uint32, expired, preimageRevealed,
 			},
 		},
 		Loop: loopdb.Loop{
-			Events: []*loopdb.LoopEvent{&update},
-			Hash:   hash,
+			Events: []*loopdb.LoopEvent{
+				&update,
+			},
+			Hash: hash,
 		},
 	}
 
@@ -310,16 +314,17 @@ func testLoopOutResume(t *testing.T, confs uint32, expired, preimageRevealed,
 		ctx.assertStatus(loopdb.StateFailTimeout)
 		ctx.assertStoreFinished(loopdb.StateFailTimeout)
 		ctx.finish()
+
 		return
 	}
 
 	// Because there is no reliable payment yet, an invoice is assumed to be
 	// paid after resume.
-	testLoopOutSuccess(ctx, amt, hash,
-		func(r error) {},
+	testLoopOutSuccess(
+		ctx, amt, hash,
 		func(r error) {},
-		preimageRevealed,
-		confIntent, utils.GetHtlcScriptVersion(protocolVersion),
+		func(r error) {}, preimageRevealed, confIntent,
+		utils.GetHtlcScriptVersion(protocolVersion),
 	)
 }