accounts+itest: fix linter and code style issues

Author: guggero

accounts/checkers.go

@@ -525,7 +525,7 @@ func checkSend(ctx context.Context, chainParams *chaincfg.Params,
 	if len(invoice) > 0 {
 		payReq, err := zpay32.Decode(invoice, chainParams)
 		if err != nil {
-			return fmt.Errorf("error decoding pay req: %v", err)
+			return fmt.Errorf("error decoding pay req: %w", err)
 		}
 
 		if payReq.MilliSat != nil && *payReq.MilliSat > sendAmt {
@@ -546,7 +546,7 @@ func checkSend(ctx context.Context, chainParams *chaincfg.Params,
 
 	err = service.CheckBalance(acct.ID, sendAmt)
 	if err != nil {
-		return fmt.Errorf("error validating account balance: %v", err)
+		return fmt.Errorf("error validating account balance: %w", err)
 	}
 
 	return nil
@@ -609,7 +609,7 @@ func checkSendToRoute(ctx context.Context, service Service,
 
 	err = service.CheckBalance(acct.ID, sendAmt)
 	if err != nil {
-		return fmt.Errorf("error validating account balance: %v", err)
+		return fmt.Errorf("error validating account balance: %w", err)
 	}
 
 	return nil

accounts/checkers_test.go

@@ -41,14 +41,14 @@ type mockService struct {
 	acctBalanceMsat lnwire.MilliSatoshi
 
 	trackedInvoices map[lntypes.Hash]AccountID
-	trackedPayments map[lntypes.Hash]*PaymentEntry
+	trackedPayments AccountPayments
 }
 
 func newMockService() *mockService {
 	return &mockService{
 		acctBalanceMsat: 0,
 		trackedInvoices: make(map[lntypes.Hash]AccountID),
-		trackedPayments: make(map[lntypes.Hash]*PaymentEntry),
+		trackedPayments: make(AccountPayments),
 	}
 }
 
@@ -68,7 +68,7 @@ func (m *mockService) AssociateInvoice(id AccountID, hash lntypes.Hash) error {
 	return nil
 }
 
-func (m *mockService) TrackPayment(id AccountID, hash lntypes.Hash,
+func (m *mockService) TrackPayment(_ AccountID, hash lntypes.Hash,
 	amt lnwire.MilliSatoshi) error {
 
 	m.trackedPayments[hash] = &PaymentEntry{
@@ -403,8 +403,8 @@ func TestAccountCheckers(t *testing.T) {
 			acct := &OffChainBalanceAccount{
 				ID:       testID,
 				Type:     TypeInitialBalance,
-				Invoices: make(map[lntypes.Hash]struct{}),
-				Payments: make(map[lntypes.Hash]*PaymentEntry),
+				Invoices: make(AccountInvoices),
+				Payments: make(AccountPayments),
 			}
 			ctx := AddToContext(
 				context.Background(), KeyAccount, acct,

accounts/interceptor.go

@@ -153,7 +153,7 @@ func parseRPCMessage(msg *lnrpc.RPCMessage) (proto.Message, error) {
 	// No, it's a normal message.
 	parsedMsg, err := mid.ParseProtobuf(msg.TypeName, msg.Serialized)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing proto of type %v: %v",
+		return nil, fmt.Errorf("error parsing proto of type %v: %w",
 			msg.TypeName, err)
 	}
 

accounts/interface.go

@@ -44,7 +44,7 @@ func ParseAccountID(idStr string) (*AccountID, error) {
 
 	idBytes, err := hex.DecodeString(idStr)
 	if err != nil {
-		return nil, fmt.Errorf("error decoding account ID: %v", err)
+		return nil, fmt.Errorf("error decoding account ID: %w", err)
 	}
 
 	var id AccountID
@@ -67,6 +67,12 @@ type PaymentEntry struct {
 	FullAmount lnwire.MilliSatoshi
 }
 
+// AccountInvoices is the set of invoices that are associated with an account.
+type AccountInvoices map[lntypes.Hash]struct{}
+
+// AccountPayments is the set of payments that are associated with an account.
+type AccountPayments map[lntypes.Hash]*PaymentEntry
+
 // OffChainBalanceAccount holds all information that is needed to keep track of
 // a user's off-chain account balance. This balance can only be spent by paying
 // invoices.
@@ -99,11 +105,11 @@ type OffChainBalanceAccount struct {
 
 	// Invoices is a list of all invoices that are associated with the
 	// account.
-	Invoices map[lntypes.Hash]struct{}
+	Invoices AccountInvoices
 
 	// Payments is a list of all payments that are associated with the
 	// account and the last status we were aware of.
-	Payments map[lntypes.Hash]*PaymentEntry
+	Payments AccountPayments
 
 	// Label is an optional label that can be set for the account. If it is
 	// not empty then it must be unique.

accounts/rpcserver.go

@@ -74,7 +74,7 @@ func (s *RPCServer) CreateAccount(ctx context.Context,
 		balanceMsat, expirationDate, req.Label,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("unable to create account: %v", err)
+		return nil, fmt.Errorf("unable to create account: %w", err)
 	}
 
 	var rootKeyIdSuffix [4]byte
@@ -93,12 +93,12 @@ func (s *RPCServer) CreateAccount(ctx context.Context,
 		}},
 	})
 	if err != nil {
-		return nil, fmt.Errorf("error baking account macaroon: %v", err)
+		return nil, fmt.Errorf("error baking account macaroon: %w", err)
 	}
 
 	macBytes, err := hex.DecodeString(macHex)
 	if err != nil {
-		return nil, fmt.Errorf("error decoding account macaroon: %v",
+		return nil, fmt.Errorf("error decoding account macaroon: %w",
 			err)
 	}
 
@@ -141,7 +141,7 @@ func (s *RPCServer) ListAccounts(context.Context,
 	// Retrieve all accounts from the macaroon account store.
 	accts, err := s.service.Accounts()
 	if err != nil {
-		return nil, fmt.Errorf("unable to list accounts: %v", err)
+		return nil, fmt.Errorf("unable to list accounts: %w", err)
 	}
 
 	// Map the response into the proper response type and return it.
@@ -191,7 +191,7 @@ func (s *RPCServer) RemoveAccount(_ context.Context,
 	// Now remove the account.
 	err = s.service.RemoveAccount(accountID)
 	if err != nil {
-		return nil, fmt.Errorf("error removing account: %v", err)
+		return nil, fmt.Errorf("error removing account: %w", err)
 	}
 
 	return &litrpc.RemoveAccountResponse{}, nil
@@ -211,7 +211,7 @@ func (s *RPCServer) findAccount(id string, label string) (AccountID, error) {
 		decoded, err := hex.DecodeString(id)
 		if err != nil {
 			return AccountID{}, fmt.Errorf("error decoding "+
-				"account ID: %v", err)
+				"account ID: %w", err)
 		}
 		copy(accountID[:], decoded)
 

accounts/service.go

@@ -96,7 +96,7 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 	// also track payments that aren't in a final state yet.
 	existingAccounts, err := s.store.Accounts()
 	if err != nil {
-		return fmt.Errorf("error querying existing accounts: %v", err)
+		return fmt.Errorf("error querying existing accounts: %w", err)
 	}
 	for _, acct := range existingAccounts {
 		acct := acct
@@ -109,15 +109,13 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 		// state of being in-flight.
 		for hash, entry := range acct.Payments {
 			entry := entry
-			if entry.Status == lnrpc.Payment_IN_FLIGHT ||
-				entry.Status == lnrpc.Payment_UNKNOWN {
-
+			if !successState(entry.Status) {
 				err := s.TrackPayment(
 					acct.ID, hash, entry.FullAmount,
 				)
 				if err != nil {
 					return fmt.Errorf("error tracking "+
-						"payment: %v", err)
+						"payment: %w", err)
 				}
 			}
 		}
@@ -146,7 +144,7 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 		s.currentSettleIndex = 0
 
 	default:
-		return fmt.Errorf("error determining last invoice indexes: %v",
+		return fmt.Errorf("error determining last invoice indexes: %w",
 			err)
 	}
 
@@ -157,7 +155,7 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("error subscribing invoices: %v", err)
+		return fmt.Errorf("error subscribing invoices: %w", err)
 	}
 
 	s.wg.Add(1)
@@ -209,6 +207,16 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 	return nil
 }
 
+// Stop shuts down the account service.
+func (s *InterceptorService) Stop() error {
+	s.contextCancel()
+	close(s.quit)
+
+	s.wg.Wait()
+
+	return s.store.Close()
+}
+
 // NewAccount creates a new OffChainBalanceAccount with the given balance and a
 // randomly chosen ID.
 func (s *InterceptorService) NewAccount(balance lnwire.MilliSatoshi,
@@ -231,7 +239,7 @@ func (s *InterceptorService) UpdateAccount(accountID AccountID, accountBalance,
 
 	account, err := s.store.Account(accountID)
 	if err != nil {
-		return nil, fmt.Errorf("error fetching account: %v", err)
+		return nil, fmt.Errorf("error fetching account: %w", err)
 	}
 
 	// If the expiration date was set, parse it as a unix time stamp. A
@@ -255,7 +263,7 @@ func (s *InterceptorService) UpdateAccount(accountID AccountID, accountBalance,
 	// Create the actual account in the macaroon account store.
 	err = s.store.UpdateAccount(account)
 	if err != nil {
-		return nil, fmt.Errorf("unable to update account: %v", err)
+		return nil, fmt.Errorf("unable to update account: %w", err)
 	}
 
 	return account, nil
@@ -395,15 +403,15 @@ func (s *InterceptorService) invoiceUpdate(invoice *lndclient.Invoice) error {
 
 	account, err := s.store.Account(acctID)
 	if err != nil {
-		return fmt.Errorf("error fetching account: %v", err)
+		return fmt.Errorf("error fetching account: %w", err)
 	}
 
 	// If we get here, the current account has the invoice associated with
 	// it that was just paid. Credit the amount to the account and update it
 	// in the DB.
 	account.CurrentBalance += int64(invoice.AmountPaid)
 	if err := s.store.UpdateAccount(account); err != nil {
-		return fmt.Errorf("error updating account: %v", err)
+		return fmt.Errorf("error updating account: %w", err)
 	}
 
 	// We've now fully processed the invoice and don't need to keep it
@@ -431,15 +439,13 @@ func (s *InterceptorService) TrackPayment(id AccountID, hash lntypes.Hash,
 	// is a reference in the account with the given state.
 	account, err := s.store.Account(id)
 	if err != nil {
-		return fmt.Errorf("error fetching account: %v", err)
+		return fmt.Errorf("error fetching account: %w", err)
 	}
 
 	// If the account already stored a terminal state, we also don't need to
 	// track the payment again.
 	entry, ok := account.Payments[hash]
-	if ok && (entry.Status == lnrpc.Payment_SUCCEEDED ||
-		entry.Status == lnrpc.Payment_FAILED) {
-
+	if ok && successState(entry.Status) {
 		return nil
 	}
 
@@ -450,7 +456,7 @@ func (s *InterceptorService) TrackPayment(id AccountID, hash lntypes.Hash,
 		FullAmount: fullAmt,
 	}
 	if err := s.store.UpdateAccount(account); err != nil {
-		return fmt.Errorf("error updating account: %v", err)
+		return fmt.Errorf("error updating account: %w", err)
 	}
 
 	// And start the long-running TrackPayment RPC.
@@ -566,7 +572,7 @@ func (s *InterceptorService) paymentUpdate(hash lntypes.Hash,
 		FullAmount: fullAmount,
 	}
 	if err := s.store.UpdateAccount(account); err != nil {
-		return terminalState, fmt.Errorf("error updating account: %v",
+		return terminalState, fmt.Errorf("error updating account: %w",
 			err)
 	}
 
@@ -618,12 +624,7 @@ func (s *InterceptorService) removePayment(hash lntypes.Hash,
 	return s.store.UpdateAccount(account)
 }
 
-// Stop shuts down the account service.
-func (s *InterceptorService) Stop() error {
-	s.contextCancel()
-	close(s.quit)
-
-	s.wg.Wait()
-
-	return s.store.Close()
+// successState returns true if a payment was completed successfully.
+func successState(status lnrpc.Payment_PaymentStatus) bool {
+	return status == lnrpc.Payment_SUCCEEDED
 }

accounts/service_test.go

@@ -186,10 +186,10 @@ func TestAccountService(t *testing.T) {
 				ID:             testID,
 				Type:           TypeInitialBalance,
 				CurrentBalance: 1234,
-				Invoices: map[lntypes.Hash]struct{}{
+				Invoices: AccountInvoices{
 					testHash: {},
 				},
-				Payments: make(map[lntypes.Hash]*PaymentEntry),
+				Payments: make(AccountPayments),
 			}
 
 			err := s.store.UpdateAccount(acct)
@@ -213,7 +213,7 @@ func TestAccountService(t *testing.T) {
 
 			acct.Invoices[testHash] = struct{}{}
 			acct.Payments[testHash] = &PaymentEntry{
-				Status:     lnrpc.Payment_FAILED,
+				Status:     lnrpc.Payment_SUCCEEDED,
 				FullAmount: 1234,
 			}
 
@@ -235,10 +235,10 @@ func TestAccountService(t *testing.T) {
 				ID:             testID,
 				Type:           TypeInitialBalance,
 				CurrentBalance: 1234,
-				Invoices: map[lntypes.Hash]struct{}{
+				Invoices: AccountInvoices{
 					testHash: {},
 				},
-				Payments: map[lntypes.Hash]*PaymentEntry{
+				Payments: AccountPayments{
 					testHash: {
 						Status:     lnrpc.Payment_IN_FLIGHT,
 						FullAmount: 1234,
@@ -362,10 +362,10 @@ func TestAccountService(t *testing.T) {
 				ID:             testID,
 				Type:           TypeInitialBalance,
 				CurrentBalance: 1234,
-				Invoices: map[lntypes.Hash]struct{}{
+				Invoices: AccountInvoices{
 					testHash: {},
 				},
-				Payments: make(map[lntypes.Hash]*PaymentEntry),
+				Payments: make(AccountPayments),
 			}
 
 			err := s.store.UpdateAccount(acct)
@@ -400,10 +400,10 @@ func TestAccountService(t *testing.T) {
 				ID:             testID,
 				Type:           TypeInitialBalance,
 				CurrentBalance: 5000,
-				Invoices: map[lntypes.Hash]struct{}{
+				Invoices: AccountInvoices{
 					testHash: {},
 				},
-				Payments: map[lntypes.Hash]*PaymentEntry{
+				Payments: AccountPayments{
 					testHash: {
 						Status:     lnrpc.Payment_IN_FLIGHT,
 						FullAmount: 2000,

accounts/store.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/btcsuite/btcwallet/walletdb"
 	"github.com/lightningnetwork/lnd/kvdb"
-	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"go.etcd.io/bbolt"
 )
@@ -146,8 +145,8 @@ func (s *BoltStore) NewAccount(balance lnwire.MilliSatoshi,
 		CurrentBalance: int64(balance),
 		ExpirationDate: expirationDate,
 		LastUpdate:     time.Now(),
-		Invoices:       make(map[lntypes.Hash]struct{}),
-		Payments:       make(map[lntypes.Hash]*PaymentEntry),
+		Invoices:       make(AccountInvoices),
+		Payments:       make(AccountPayments),
 		Label:          label,
 	}