multi: create channeldb/models package

Add a new subpackage to `lnd/channeldb` to hold some of the types that
are used in the package itself and in other packages that should not
depend on `channeldb`.

invoices/invoiceregistry.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -81,7 +82,7 @@ type htlcReleaseEvent struct {
 	invoiceRef channeldb.InvoiceRef
 
 	// key is the circuit key of the htlc to release.
-	key channeldb.CircuitKey
+	key models.CircuitKey
 
 	// releaseTime is the time at which to release the htlc.
 	releaseTime time.Time
@@ -131,11 +132,11 @@ type InvoiceRegistry struct {
 	hodlSubscriptionsMux sync.RWMutex
 	// subscriptions is a map from a circuit key to a list of subscribers.
 	// It is used for efficient notification of links.
-	hodlSubscriptions map[channeldb.CircuitKey]map[chan<- interface{}]struct{}
+	hodlSubscriptions map[models.CircuitKey]map[chan<- interface{}]struct{}
 
 	// reverseSubscriptions tracks circuit keys subscribed to per
 	// subscriber. This is used to unsubscribe from all hashes efficiently.
-	hodlReverseSubscriptions map[chan<- interface{}]map[channeldb.CircuitKey]struct{}
+	hodlReverseSubscriptions map[chan<- interface{}]map[models.CircuitKey]struct{}
 
 	// htlcAutoReleaseChan contains the new htlcs that need to be
 	// auto-released.
@@ -159,12 +160,16 @@ func NewRegistry(cdb *channeldb.DB, expiryWatcher *InvoiceExpiryWatcher,
 		notificationClients:       make(map[uint32]*InvoiceSubscription),
 		singleNotificationClients: make(map[uint32]*SingleInvoiceSubscription),
 		invoiceEvents:             make(chan *invoiceEvent, 100),
-		hodlSubscriptions:         make(map[channeldb.CircuitKey]map[chan<- interface{}]struct{}),
-		hodlReverseSubscriptions:  make(map[chan<- interface{}]map[channeldb.CircuitKey]struct{}),
-		cfg:                       cfg,
-		htlcAutoReleaseChan:       make(chan *htlcReleaseEvent),
-		expiryWatcher:             expiryWatcher,
-		quit:                      make(chan struct{}),
+		hodlSubscriptions: make(
+			map[models.CircuitKey]map[chan<- interface{}]struct{},
+		),
+		hodlReverseSubscriptions: make(
+			map[chan<- interface{}]map[models.CircuitKey]struct{},
+		),
+		cfg:                 cfg,
+		htlcAutoReleaseChan: make(chan *htlcReleaseEvent),
+		expiryWatcher:       expiryWatcher,
+		quit:                make(chan struct{}),
 	}
 }
 
@@ -622,7 +627,7 @@ func (i *InvoiceRegistry) LookupInvoiceByRef(
 // startHtlcTimer starts a new timer via the invoice registry main loop that
 // cancels a single htlc on an invoice when the htlc hold duration has passed.
 func (i *InvoiceRegistry) startHtlcTimer(invoiceRef channeldb.InvoiceRef,
-	key channeldb.CircuitKey, acceptTime time.Time) error {
+	key models.CircuitKey, acceptTime time.Time) error {
 
 	releaseTime := acceptTime.Add(i.cfg.HtlcHoldDuration)
 	event := &htlcReleaseEvent{
@@ -644,7 +649,7 @@ func (i *InvoiceRegistry) startHtlcTimer(invoiceRef channeldb.InvoiceRef,
 // a resolution result which will be used to notify subscribed links and
 // resolvers of the details of the htlc cancellation.
 func (i *InvoiceRegistry) cancelSingleHtlc(invoiceRef channeldb.InvoiceRef,
-	key channeldb.CircuitKey, result FailResolutionResult) error {
+	key models.CircuitKey, result FailResolutionResult) error {
 
 	updateInvoice := func(invoice *channeldb.Invoice) (
 		*channeldb.InvoiceUpdateDesc, error) {
@@ -702,7 +707,7 @@ func (i *InvoiceRegistry) cancelSingleHtlc(invoiceRef channeldb.InvoiceRef,
 
 		// Return an update descriptor that cancels htlc and keeps
 		// invoice open.
-		canceledHtlcs := map[channeldb.CircuitKey]struct{}{
+		canceledHtlcs := map[models.CircuitKey]struct{}{
 			key: {},
 		}
 
@@ -910,7 +915,7 @@ func (i *InvoiceRegistry) processAMP(ctx invoiceUpdateCtx) error {
 // held htlc.
 func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash,
 	amtPaid lnwire.MilliSatoshi, expiry uint32, currentHeight int32,
-	circuitKey channeldb.CircuitKey, hodlChan chan<- interface{},
+	circuitKey models.CircuitKey, hodlChan chan<- interface{},
 	payload Payload) (HtlcResolution, error) {
 
 	// Create the update context containing the relevant details of the
@@ -1715,7 +1720,7 @@ func (i *InvoiceRegistry) notifyHodlSubscribers(htlcResolution HtlcResolution) {
 
 // hodlSubscribe adds a new invoice subscription.
 func (i *InvoiceRegistry) hodlSubscribe(subscriber chan<- interface{},
-	circuitKey channeldb.CircuitKey) {
+	circuitKey models.CircuitKey) {
 
 	i.hodlSubscriptionsMux.Lock()
 	defer i.hodlSubscriptionsMux.Unlock()
@@ -1731,7 +1736,7 @@ func (i *InvoiceRegistry) hodlSubscribe(subscriber chan<- interface{},
 
 	reverseSubscriptions, ok := i.hodlReverseSubscriptions[subscriber]
 	if !ok {
-		reverseSubscriptions = make(map[channeldb.CircuitKey]struct{})
+		reverseSubscriptions = make(map[models.CircuitKey]struct{})
 		i.hodlReverseSubscriptions[subscriber] = reverseSubscriptions
 	}
 	reverseSubscriptions[circuitKey] = struct{}{}

invoices/resolution.go

@@ -3,7 +3,7 @@ package invoices
 import (
 	"time"
 
-	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/lntypes"
 )
 
@@ -11,14 +11,14 @@ import (
 type HtlcResolution interface {
 	// CircuitKey returns the circuit key for the htlc that we have a
 	// resolution for.
-	CircuitKey() channeldb.CircuitKey
+	CircuitKey() models.CircuitKey
 }
 
 // HtlcFailResolution is an implementation of the HtlcResolution interface
 // which is returned when a htlc is failed.
 type HtlcFailResolution struct {
 	// circuitKey is the key of the htlc for which we have a resolution.
-	circuitKey channeldb.CircuitKey
+	circuitKey models.CircuitKey
 
 	// AcceptHeight is the original height at which the htlc was accepted.
 	AcceptHeight int32
@@ -28,8 +28,8 @@ type HtlcFailResolution struct {
 }
 
 // NewFailResolution returns a htlc failure resolution.
-func NewFailResolution(key channeldb.CircuitKey,
-	acceptHeight int32, outcome FailResolutionResult) *HtlcFailResolution {
+func NewFailResolution(key models.CircuitKey, acceptHeight int32,
+	outcome FailResolutionResult) *HtlcFailResolution {
 
 	return &HtlcFailResolution{
 		circuitKey:   key,
@@ -42,7 +42,7 @@ func NewFailResolution(key channeldb.CircuitKey,
 // resolution for.
 //
 // Note: it is part of the HtlcResolution interface.
-func (f *HtlcFailResolution) CircuitKey() channeldb.CircuitKey {
+func (f *HtlcFailResolution) CircuitKey() models.CircuitKey {
 	return f.circuitKey
 }
 
@@ -53,7 +53,7 @@ type HtlcSettleResolution struct {
 	Preimage lntypes.Preimage
 
 	// circuitKey is the key of the htlc for which we have a resolution.
-	circuitKey channeldb.CircuitKey
+	circuitKey models.CircuitKey
 
 	// acceptHeight is the original height at which the htlc was accepted.
 	AcceptHeight int32
@@ -65,7 +65,7 @@ type HtlcSettleResolution struct {
 // NewSettleResolution returns a htlc resolution which is associated with a
 // settle.
 func NewSettleResolution(preimage lntypes.Preimage,
-	key channeldb.CircuitKey, acceptHeight int32,
+	key models.CircuitKey, acceptHeight int32,
 	outcome SettleResolutionResult) *HtlcSettleResolution {
 
 	return &HtlcSettleResolution{
@@ -80,7 +80,7 @@ func NewSettleResolution(preimage lntypes.Preimage,
 // resolution for.
 //
 // Note: it is part of the HtlcResolution interface.
-func (s *HtlcSettleResolution) CircuitKey() channeldb.CircuitKey {
+func (s *HtlcSettleResolution) CircuitKey() models.CircuitKey {
 	return s.circuitKey
 }
 
@@ -92,7 +92,7 @@ func (s *HtlcSettleResolution) CircuitKey() channeldb.CircuitKey {
 // acceptResolution, a nil resolution should be surfaced.
 type htlcAcceptResolution struct {
 	// circuitKey is the key of the htlc for which we have a resolution.
-	circuitKey channeldb.CircuitKey
+	circuitKey models.CircuitKey
 
 	// autoRelease signals that the htlc should be automatically released
 	// after a timeout.
@@ -107,7 +107,7 @@ type htlcAcceptResolution struct {
 
 // newAcceptResolution returns a htlc resolution which is associated with a
 // htlc accept.
-func newAcceptResolution(key channeldb.CircuitKey,
+func newAcceptResolution(key models.CircuitKey,
 	outcome acceptResolutionResult) *htlcAcceptResolution {
 
 	return &htlcAcceptResolution{
@@ -120,6 +120,6 @@ func newAcceptResolution(key channeldb.CircuitKey,
 // resolution for.
 //
 // Note: it is part of the HtlcResolution interface.
-func (a *htlcAcceptResolution) CircuitKey() channeldb.CircuitKey {
+func (a *htlcAcceptResolution) CircuitKey() models.CircuitKey {
 	return a.circuitKey
 }

invoices/test_utils_test.go

@@ -17,6 +17,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -227,8 +228,8 @@ func newTestContext(t *testing.T) *testContext {
 	return &ctx
 }
 
-func getCircuitKey(htlcID uint64) channeldb.CircuitKey {
-	return channeldb.CircuitKey{
+func getCircuitKey(htlcID uint64) models.CircuitKey {
+	return models.CircuitKey{
 		ChanID: lnwire.ShortChannelID{
 			BlockHeight: 1, TxIndex: 2, TxPosition: 3,
 		},
@@ -453,11 +454,11 @@ func setupHodlExpiry(t *testing.T, creationDate time.Time,
 	invoice := newTestInvoice(t, preimage, creationDate, expiry)
 	invoice.State = startState
 	invoice.HodlInvoice = true
-	invoice.Htlcs = make(map[channeldb.CircuitKey]*channeldb.InvoiceHTLC)
+	invoice.Htlcs = make(map[models.CircuitKey]*channeldb.InvoiceHTLC)
 
 	// If we have any htlcs, add them with unique circult keys.
 	for i, htlc := range startHtlcs {
-		key := channeldb.CircuitKey{
+		key := models.CircuitKey{
 			HtlcID: uint64(i),
 		}
 

invoices/update.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/lightningnetwork/lnd/amp"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/record"
@@ -15,7 +16,7 @@ import (
 // update to be carried out.
 type invoiceUpdateCtx struct {
 	hash                 lntypes.Hash
-	circuitKey           channeldb.CircuitKey
+	circuitKey           models.CircuitKey
 	amtPaid              lnwire.MilliSatoshi
 	expiry               uint32
 	currentHeight        int32
@@ -233,7 +234,7 @@ func updateMpp(ctx *invoiceUpdateCtx,
 	}
 
 	// Record HTLC in the invoice database.
-	newHtlcs := map[channeldb.CircuitKey]*channeldb.HtlcAcceptDesc{
+	newHtlcs := map[models.CircuitKey]*channeldb.HtlcAcceptDesc{
 		ctx.circuitKey: acceptDesc,
 	}
 
@@ -258,7 +259,7 @@ func updateMpp(ctx *invoiceUpdateCtx,
 	}
 
 	var (
-		htlcPreimages map[channeldb.CircuitKey]lntypes.Preimage
+		htlcPreimages map[models.CircuitKey]lntypes.Preimage
 		htlcPreimage  lntypes.Preimage
 	)
 	if ctx.amp != nil {
@@ -290,10 +291,10 @@ func updateMpp(ctx *invoiceUpdateCtx,
 }
 
 // HTLCSet is a map of CircuitKey to InvoiceHTLC.
-type HTLCSet = map[channeldb.CircuitKey]*channeldb.InvoiceHTLC
+type HTLCSet = map[models.CircuitKey]*channeldb.InvoiceHTLC
 
 // HTLCPreimages is a map of CircuitKey to preimage.
-type HTLCPreimages = map[channeldb.CircuitKey]lntypes.Preimage
+type HTLCPreimages = map[models.CircuitKey]lntypes.Preimage
 
 // reconstructAMPPreimages reconstructs the root seed for an AMP HTLC set and
 // verifies that all derived child hashes match the payment hashes of the HTLCs
@@ -316,7 +317,7 @@ func reconstructAMPPreimages(ctx *invoiceUpdateCtx,
 
 	// Next, construct an index mapping the position in childDescs to a
 	// circuit key for all preexisting HTLCs.
-	indexToCircuitKey := make(map[int]channeldb.CircuitKey)
+	indexToCircuitKey := make(map[int]models.CircuitKey)
 
 	// Add the child descriptor for each HTLC in the HTLC set, recording
 	// it's position within the slice.
@@ -350,7 +351,7 @@ func reconstructAMPPreimages(ctx *invoiceUpdateCtx,
 	// Finally, construct the map of learned preimages indexed by circuit
 	// key, so that they can be persisted along with each HTLC when updating
 	// the invoice.
-	htlcPreimages := make(map[channeldb.CircuitKey]lntypes.Preimage)
+	htlcPreimages := make(map[models.CircuitKey]lntypes.Preimage)
 	htlcPreimages[ctx.circuitKey] = children[0].Preimage
 	for idx, child := range children[1:] {
 		circuitKey := indexToCircuitKey[idx]
@@ -417,7 +418,7 @@ func updateLegacy(ctx *invoiceUpdateCtx,
 	}
 
 	// Record HTLC in the invoice database.
-	newHtlcs := map[channeldb.CircuitKey]*channeldb.HtlcAcceptDesc{
+	newHtlcs := map[models.CircuitKey]*channeldb.HtlcAcceptDesc{
 		ctx.circuitKey: {
 			Amt:           ctx.amtPaid,
 			Expiry:        ctx.expiry,