multi: fix staticcheck flags

assets/client.go

@@ -306,7 +306,7 @@ func getClientConn(config *TapdConfig) (*grpc.ClientConn, error) {
 	}
 
 	// Dial the gRPC server.
-	conn, err := grpc.Dial(config.Host, opts...)
+	conn, err := grpc.NewClient(config.Host, opts...)
 	if err != nil {
 		return nil, err
 	}

loopd/daemon.go

@@ -892,7 +892,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 			defer infof("Static address manager stopped")
 
 			err := staticAddressManager.Run(d.mainCtx, initChan)
-			if err != nil && !errors.Is(context.Canceled, err) {
+			if err != nil && !errors.Is(err, context.Canceled) {
 				d.internalErrChan <- err
 			}
 		}()
@@ -924,7 +924,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 			defer infof("Static address deposit manager stopped")
 
 			err := depositManager.Run(d.mainCtx, initChan)
-			if err != nil && !errors.Is(context.Canceled, err) {
+			if err != nil && !errors.Is(err, context.Canceled) {
 				d.internalErrChan <- err
 			}
 		}()
@@ -956,7 +956,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 			defer infof("Static address withdrawal manager stopped")
 
 			err := withdrawalManager.Run(d.mainCtx, initChan)
-			if err != nil && !errors.Is(context.Canceled, err) {
+			if err != nil && !errors.Is(err, context.Canceled) {
 				d.internalErrChan <- err
 			}
 		}()
@@ -992,7 +992,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 			infof("Starting static address loop-in manager...")
 			defer infof("Static address loop-in manager stopped")
 			err := staticLoopInManager.Run(d.mainCtx, initChan)
-			if err != nil && !errors.Is(context.Canceled, err) {
+			if err != nil && !errors.Is(err, context.Canceled) {
 				d.internalErrChan <- err
 			}
 		}()

loopdb/store.go

@@ -194,7 +194,7 @@ func NewBoltSwapStore(dbPath string, chainParams *chaincfg.Params) (
 	bdb, err := bbolt.Open(path, 0600, &bbolt.Options{
 		Timeout: DefaultLoopDBTimeout,
 	})
-	if err == bbolt.ErrTimeout {
+	if errors.Is(err, bbolt.ErrTimeout) {
 		return nil, fmt.Errorf("%w: couldn't obtain exclusive lock on "+
 			"%s, timed out after %v", bbolt.ErrTimeout, path,
 			DefaultLoopDBTimeout)

loopin_test.go

@@ -594,12 +594,12 @@
 	height := int32(600)
 
 	cfg, err, inSwap := startNewLoopIn(t, ctx, height)
 	require.NoError(t, err)
 
 	advanceToPublishedHtlc(t, ctx)
 
 	// The client requests to abandon the published htlc state.
 	inSwap.abandonChan <- struct{}{}
 
 	// Ensure that the swap is now in the StateFailAbandoned state.
 	ctx.assertState(loopdb.StateFailAbandoned)
@@ -609,28 +609,28 @@
 	ctx.store.AssertLoopInState(loopdb.StateFailAbandoned)
 
 	// Ensure that the swap was abandoned and the execution stopped.
 	err = <-ctx.errChan
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "swap hash abandoned by client")
 
 	// We re-instantiate the swap and ensure that it does not progress.
 	pendSwap := &loopdb.LoopIn{
 		Contract: &inSwap.LoopInContract,
 		Loop: loopdb.Loop{
 			Events: []*loopdb.LoopEvent{
 				{
 					SwapStateData: loopdb.SwapStateData{
 						State: inSwap.state,
 					},
 				},
 			},
 			Hash: testPreimage.Hash(),
 		},
 	}
 	resumedSwap, err := resumeLoopInSwap(
 		context.Background(), cfg, pendSwap,
 	)
 	require.NoError(t, err)
 
 	// Execute the abandoned swap.
 	go func() {
@@ -648,7 +648,7 @@
 	require.Equal(t, loopdb.StateFailAbandoned, swapInfo.State)
 
 	// Ensure that the execution flagged the abandoned swap as finalized.
 	err = <-ctx.errChan
 	require.Error(t, err)
 	require.Equal(t, ErrSwapFinalized, err)
 }
@@ -760,7 +760,7 @@
 }
 
 func startNewLoopIn(t *testing.T, ctx *loopInTestContext, height int32) (
-	*swapConfig, error, *loopInSwap) {
+	*swapConfig, *loopInSwap, error) {
 
 	cfg := newSwapConfig(&ctx.lnd.LndServices, ctx.store, ctx.server, nil)
 
@@ -783,5 +783,5 @@
 		}
 		ctx.errChan <- err
 	}()
-	return cfg, err, inSwap
+	return cfg, inSwap, err
 }

swap_server_client.go

@@ -26,6 +26,7 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/status"
 )
 
@@ -896,7 +897,7 @@ func rpcRouteCancel(details *outCancelDetails) (
 // getSwapServerConn returns a connection to the swap server. A non-empty
 // proxyAddr indicates that a SOCKS proxy found at the address should be used to
 // establish the connection.
-func getSwapServerConn(address, proxyAddress string, insecure bool,
+func getSwapServerConn(address, proxyAddress string, insec bool,
 	tlsPath string, interceptor *l402.ClientInterceptor) (*grpc.ClientConn,
 	error) {
 
@@ -914,8 +915,11 @@ func getSwapServerConn(address, proxyAddress string, insecure bool,
 	// using a self-signed certificate or with a certificate signed by a
 	// public CA.
 	switch {
-	case insecure:
-		opts = append(opts, grpc.WithInsecure())
+	case insec:
+		opts = append(opts, grpc.WithTransportCredentials(
+			insecure.NewCredentials(),
+		),
+		)
 
 	case tlsPath != "":
 		// Load the specified TLS certificate and build
@@ -945,7 +949,7 @@ func getSwapServerConn(address, proxyAddress string, insecure bool,
 		opts = append(opts, grpc.WithContextDialer(torDialer))
 	}
 
-	conn, err := grpc.Dial(address, opts...)
+	conn, err := grpc.NewClient(address, opts...)
 	if err != nil {
 		return nil, fmt.Errorf("unable to connect to RPC server: %v",
 			err)

sweepbatcher/sweep_batcher_test.go

@@ -638,15 +638,15 @@ type testTransactionPublisher struct {
 	attempts int
 }
 
-var testPublishError = errors.New("test publish error")
+var errTestPublish = errors.New("test publish error")
 
 // PublishTransaction publishes the transaction or fails it's the first attempt.
 func (p *testTransactionPublisher) PublishTransaction(ctx context.Context,
 	tx *wire.MsgTx, label string) error {
 
 	p.attempts++
 	if p.attempts == 1 {
-		return testPublishError
+		return errTestPublish
 	}
 
 	return p.WalletKitClient.PublishTransaction(ctx, tx, label)
@@ -733,7 +733,7 @@ func testPublishErrorHandler(t *testing.T, store testStore,
 	}, test.Timeout, eventuallyCheckFrequency)
 
 	// The first attempt to publish the batch tx is expected to fail.
-	require.ErrorIs(t, <-publishErrorChan, testPublishError)
+	require.ErrorIs(t, <-publishErrorChan, errTestPublish)
 
 	// Mine a block to trigger another publishing attempt.
 	err = lnd.NotifyHeight(601)
@@ -4072,8 +4072,8 @@ func testSweepBatcherHandleSweepRace(t *testing.T, store testStore,
 	<-batcher.initDone
 
 	const (
-		sweepValue btcutil.Amount = 1_000_000
-		confHeight                = 605
+		sweepValue = btcutil.Amount(1_000_000)
+		confHeight = 605
 	)
 
 	sweepOutpoint := wire.OutPoint{
@@ -4534,8 +4534,8 @@ func TestSweepBatcherConfirmedBatchIncompleteSweeps(t *testing.T) {
 	swapStore := newLoopdbStore(t, sqlDB)
 
 	const (
-		sweepValue btcutil.Amount = 1_000_000
-		confHeight                = 777
+		sweepValue = btcutil.Amount(1_000_000)
+		confHeight = 777
 	)
 
 	ctx := context.Background()