accounts: add ReqIDToPaymentHashStore and implement

In preparation for implementing trace logging that makes it easy to link
state across requests and responses for more informative logs, we add a
new ReqIDToPaymentHashStore interface along with an in-memory
implementation. This can be expanded in future to contain other state
but for now let's just go with the payment hash since that is useful to
have and will provide the user useful information about the payment
corresponding to a log.

Author: ellemouton

accounts/checkers_test.go

@@ -42,13 +42,16 @@ type mockService struct {
 
 	trackedInvoices map[lntypes.Hash]AccountID
 	trackedPayments AccountPayments
+
+	*requestValuesStore
 }
 
 func newMockService() *mockService {
 	return &mockService{
-		acctBalanceMsat: 0,
-		trackedInvoices: make(map[lntypes.Hash]AccountID),
-		trackedPayments: make(AccountPayments),
+		acctBalanceMsat:    0,
+		trackedInvoices:    make(map[lntypes.Hash]AccountID),
+		trackedPayments:    make(AccountPayments),
+		requestValuesStore: newRequestValuesStore(),
 	}
 }
 

accounts/interface.go

@@ -252,4 +252,33 @@ type Service interface {
 	// restarted.
 	AssociatePayment(id AccountID, paymentHash lntypes.Hash,
 		fullAmt lnwire.MilliSatoshi) error
+
+	RequestValuesStore
+}
+
+// RequestValues holds various values associated with a specific request that
+// we may want access to when handling the response. At the moment this only
+// stores payment related data.
+type RequestValues struct {
+	// PaymentHash is the hash of the payment that this request is
+	// associated with.
+	PaymentHash lntypes.Hash
+
+	// PaymentAmount is the value of the payment being made.
+	PaymentAmount lnwire.MilliSatoshi
+}
+
+// RequestValuesStore is a store that can be used to keep track of the mapping
+// between a request ID and various values associated with that request which
+// we may want access to when handling the request response.
+type RequestValuesStore interface {
+	// RegisterValues stores values for the given request ID.
+	RegisterValues(reqID uint64, values *RequestValues) error
+
+	// GetValues returns the corresponding request values for the given
+	// request ID if they exist.
+	GetValues(reqID uint64) (*RequestValues, bool)
+
+	// DeleteValues deletes any values stored for the given request ID.
+	DeleteValues(reqID uint64)
 }

accounts/service.go

@@ -66,6 +66,8 @@ type InterceptorService struct {
 	invoiceToAccount map[lntypes.Hash]AccountID
 	pendingPayments  map[lntypes.Hash]*trackedPayment
 
+	*requestValuesStore
+
 	mainErrCallback func(error)
 	wg              sync.WaitGroup
 	quit            chan struct{}
@@ -86,14 +88,15 @@ func NewService(dir string,
 	mainCtx, contextCancel := context.WithCancel(context.Background())
 
 	return &InterceptorService{
-		store:            accountStore,
-		mainCtx:          mainCtx,
-		contextCancel:    contextCancel,
-		invoiceToAccount: make(map[lntypes.Hash]AccountID),
-		pendingPayments:  make(map[lntypes.Hash]*trackedPayment),
-		mainErrCallback:  errCallback,
-		quit:             make(chan struct{}),
-		isEnabled:        false,
+		store:              accountStore,
+		mainCtx:            mainCtx,
+		contextCancel:      contextCancel,
+		invoiceToAccount:   make(map[lntypes.Hash]AccountID),
+		pendingPayments:    make(map[lntypes.Hash]*trackedPayment),
+		requestValuesStore: newRequestValuesStore(),
+		mainErrCallback:    errCallback,
+		quit:               make(chan struct{}),
+		isEnabled:          false,
 	}, nil
 }
 
@@ -830,3 +833,59 @@ func (s *InterceptorService) removePayment(hash lntypes.Hash,
 func successState(status lnrpc.Payment_PaymentStatus) bool {
 	return status == lnrpc.Payment_SUCCEEDED
 }
+
+// requestValuesStore is an in-memory implementation of the
+// RequestValuesStore interface.
+type requestValuesStore struct {
+	m map[uint64]*RequestValues
+
+	mu sync.Mutex
+}
+
+// A compile-time check to ensure that requestValuesStore implements the
+// RequestValuesStore interface.
+var _ RequestValuesStore = (*requestValuesStore)(nil)
+
+// newRequestValuesStore constructs a new requestValuesStore which is an
+// implementation of the RequestValuesStore interface.
+func newRequestValuesStore() *requestValuesStore {
+	return &requestValuesStore{
+		m: make(map[uint64]*RequestValues),
+	}
+}
+
+// RegisterValues stores values for the given request ID.
+func (s *requestValuesStore) RegisterValues(reqID uint64,
+	values *RequestValues) error {
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if _, ok := s.m[reqID]; ok {
+		return fmt.Errorf("values for request ID %d have already "+
+			"been registered", reqID)
+	}
+
+	s.m[reqID] = values
+
+	return nil
+}
+
+// GetValues returns the corresponding request values for the given request ID
+// if they exist.
+func (s *requestValuesStore) GetValues(reqID uint64) (*RequestValues, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	values, ok := s.m[reqID]
+
+	return values, ok
+}
+
+// DeleteValues deletes any values stored for the given request ID.
+func (s *requestValuesStore) DeleteValues(reqID uint64) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	delete(s.m, reqID)
+}