cnct: instantiate quit channels inside resolvers

Removes a bug-prone construction that existed previously where the quit
channel was replaced just-in-time.

contractcourt/briefcase.go

@@ -440,7 +440,7 @@ func (b *boltArbitratorLog) CommitState(s ArbitratorState) error {
 //
 // NOTE: Part of the ContractResolver interface.
 func (b *boltArbitratorLog) FetchUnresolvedContracts() ([]ContractResolver, error) {
-	resKit := ResolverKit{
+	resolverCfg := ResolverConfig{
 		ChannelArbitratorConfig: b.cfg,
 		Checkpoint:              b.checkpointContract,
 	}
@@ -516,8 +516,7 @@ func (b *boltArbitratorLog) FetchUnresolvedContracts() ([]ContractResolver, erro
 				return fmt.Errorf("unknown resolver type: %v", resType)
 			}
 
-			resKit.quit = make(chan struct{})
+			res.AttachConfig(resolverCfg)
-			res.AttachResolverKit(resKit)
 			contracts = append(contracts, res)
 			return nil
 		})

contractcourt/channel_arbitrator.go

@@ -1685,7 +1685,7 @@ func (c *ChannelArbitrator) prepContractResolutions(
 
 	// We'll create the resolver kit that we'll be cloning for each
 	// resolver so they each can do their duty.
-	resKit := ResolverKit{
+	resolverCfg := ResolverConfig{
 		ChannelArbitratorConfig: c.cfg,
 		Checkpoint: func(res ContractResolver) error {
 			return c.log.InsertUnresolvedContracts(res)
@@ -1733,13 +1733,13 @@ func (c *ChannelArbitrator) prepContractResolutions(
 					continue
 				}
 
-				resKit.quit = make(chan struct{})
+				resKit := newContractResolverKit(resolverCfg)
 				resolver := &htlcSuccessResolver{
 					htlcResolution:      resolution,
 					broadcastHeight:     height,
 					payHash:             htlc.RHash,
 					htlcAmt:             htlc.Amt,
-					ResolverKit:     resKit,
+					contractResolverKit: *resKit,
 				}
 				htlcResolvers = append(htlcResolvers, resolver)
 			}
@@ -1761,13 +1761,13 @@ func (c *ChannelArbitrator) prepContractResolutions(
 					continue
 				}
 
-				resKit.quit = make(chan struct{})
+				resKit := newContractResolverKit(resolverCfg)
 				resolver := &htlcTimeoutResolver{
 					htlcResolution:      resolution,
 					broadcastHeight:     height,
 					htlcIndex:           htlc.HtlcIndex,
 					htlcAmt:             htlc.Amt,
-					ResolverKit:     resKit,
+					contractResolverKit: *resKit,
 				}
 				htlcResolvers = append(htlcResolvers, resolver)
 			}
@@ -1798,7 +1798,7 @@ func (c *ChannelArbitrator) prepContractResolutions(
 					ChanID: c.cfg.ShortChanID,
 				}
 
-				resKit.quit = make(chan struct{})
+				resKit := newContractResolverKit(resolverCfg)
 				resolver := &htlcIncomingContestResolver{
 					htlcExpiry: htlc.RefundTimeout,
 					circuitKey: circuitKey,
@@ -1807,7 +1807,7 @@ func (c *ChannelArbitrator) prepContractResolutions(
 						broadcastHeight:     height,
 						payHash:             htlc.RHash,
 						htlcAmt:             htlc.Amt,
-						ResolverKit:     resKit,
+						contractResolverKit: *resKit,
 					},
 				}
 				htlcResolvers = append(htlcResolvers, resolver)
@@ -1831,14 +1831,14 @@ func (c *ChannelArbitrator) prepContractResolutions(
 					continue
 				}
 
-				resKit.quit = make(chan struct{})
+				resKit := newContractResolverKit(resolverCfg)
 				resolver := &htlcOutgoingContestResolver{
 					htlcTimeoutResolver: htlcTimeoutResolver{
 						htlcResolution:      resolution,
 						broadcastHeight:     height,
 						htlcIndex:           htlc.HtlcIndex,
 						htlcAmt:             htlc.Amt,
-						ResolverKit:     resKit,
+						contractResolverKit: *resKit,
 					},
 				}
 				htlcResolvers = append(htlcResolvers, resolver)
@@ -1850,12 +1850,12 @@ func (c *ChannelArbitrator) prepContractResolutions(
 	// a resolver to sweep our commitment output (but only if it wasn't
 	// trimmed).
 	if contractResolutions.CommitResolution != nil {
-		resKit.quit = make(chan struct{})
+		resKit := newContractResolverKit(resolverCfg)
 		resolver := &commitSweepResolver{
 			commitResolution:    *contractResolutions.CommitResolution,
 			broadcastHeight:     height,
 			chanPoint:           c.cfg.ChanPoint,
-			ResolverKit:      resKit,
+			contractResolverKit: *resKit,
 		}
 
 		htlcResolvers = append(htlcResolvers, resolver)

contractcourt/commit_sweep_resolver.go

@@ -36,7 +36,7 @@ type commitSweepResolver struct {
 	// chanPoint is the channel point of the original contract.
 	chanPoint wire.OutPoint
 
-	ResolverKit
+	contractResolverKit
 }
 
 // ResolverKey returns an identifier which should be globally unique for this
@@ -293,13 +293,13 @@ func (c *commitSweepResolver) Decode(r io.Reader) error {
 	return nil
 }
 
-// AttachResolverKit should be called once a resolved is successfully decoded
+// AttachConfig should be called once a resolved is successfully decoded from
-// from its stored format. This struct delivers a generic tool kit that
+// its stored format. This struct delivers the configuration items that
 // resolvers need to complete their duty.
 //
 // NOTE: Part of the ContractResolver interface.
-func (c *commitSweepResolver) AttachResolverKit(r ResolverKit) {
+func (c *commitSweepResolver) AttachConfig(r ResolverConfig) {
-	c.ResolverKit = r
+	c.contractResolverKit = *newContractResolverKit(r)
 }
 
 // A compile time assertion to ensure commitSweepResolver meets the

contractcourt/contract_resolvers.go

@@ -46,10 +46,10 @@ type ContractResolver interface {
 	// passed Writer.
 	Encode(w io.Writer) error
 
-	// AttachResolverKit should be called once a resolved is successfully
+	// AttachConfig should be called once a resolved is successfully decoded
-	// decoded from its stored format. This struct delivers a generic tool
+	// from its stored format. This struct delivers the configuration items
-	// kit that resolvers need to complete their duty.
+	// that resolvers need to complete their duty.
-	AttachResolverKit(ResolverKit)
+	AttachConfig(ResolverConfig)
 
 	// Stop signals the resolver to cancel any current resolution
 	// processes, and suspend.
@@ -64,10 +64,9 @@ type reportingContractResolver interface {
 	report() *ContractReport
 }
 
-// ResolverKit is meant to be used as a mix-in struct to be embedded within a
+// ResolverConfig contains the externally supplied configuration items that are
-// given ContractResolver implementation. It contains all the items that a
+// required by a ContractResolver implementation.
-// resolver requires to carry out its duties.
+type ResolverConfig struct {
-type ResolverKit struct {
 	// ChannelArbitratorConfig contains all the interfaces and closures
 	// required for the resolver to interact with outside sub-systems.
 	ChannelArbitratorConfig
@@ -76,10 +75,25 @@ type ResolverKit struct {
 	// should write the state of the resolver to persistent storage, and
 	// return a non-nil error upon success.
 	Checkpoint func(ContractResolver) error
+}
+
+// contractResolverKit is meant to be used as a mix-in struct to be embedded within a
+// given ContractResolver implementation. It contains all the common items that
+// a resolver requires to carry out its duties.
+type contractResolverKit struct {
+	ResolverConfig
 
 	quit chan struct{}
 }
 
+// newContractResolverKit instantiates the mix-in struct.
+func newContractResolverKit(cfg ResolverConfig) *contractResolverKit {
+	return &contractResolverKit{
+		ResolverConfig: cfg,
+		quit:           make(chan struct{}),
+	}
+}
+
 var (
 	// errResolverShuttingDown is returned when the resolver stops
 	// progressing because it received the quit signal.

contractcourt/htlc_incoming_contest_resolver.go

@@ -310,13 +310,13 @@ func (h *htlcIncomingContestResolver) Decode(r io.Reader) error {
 	return h.htlcSuccessResolver.Decode(r)
 }
 
-// AttachResolverKit should be called once a resolved is successfully decoded
+// AttachConfig should be called once a resolved is successfully decoded from
-// from its stored format. This struct delivers a generic tool kit that
+// its stored format. This struct delivers the configuration items that
 // resolvers need to complete their duty.
 //
 // NOTE: Part of the ContractResolver interface.
-func (h *htlcIncomingContestResolver) AttachResolverKit(r ResolverKit) {
+func (h *htlcIncomingContestResolver) AttachConfig(r ResolverConfig) {
-	h.ResolverKit = r
+	h.htlcSuccessResolver.AttachConfig(r)
 }
 
 // A compile time assertion to ensure htlcIncomingContestResolver meets the

contractcourt/htlc_incoming_resolver_test.go

@@ -199,15 +199,16 @@ func newIncomingResolverTestContext(t *testing.T) *incomingResolverTestContext {
 		},
 	}
 
-	resolver := &htlcIncomingContestResolver{
+	cfg := ResolverConfig{
-		htlcSuccessResolver: htlcSuccessResolver{
-			ResolverKit: ResolverKit{
 		ChannelArbitratorConfig: chainCfg,
 		Checkpoint: func(_ ContractResolver) error {
 			checkPointChan <- struct{}{}
 			return nil
 		},
-			},
+	}
+	resolver := &htlcIncomingContestResolver{
+		htlcSuccessResolver: htlcSuccessResolver{
+			contractResolverKit: *newContractResolverKit(cfg),
 			htlcResolution:      lnwallet.IncomingHtlcResolution{},
 			payHash:             testResHash,
 		},

contractcourt/htlc_outgoing_contest_resolver.go

@@ -189,13 +189,13 @@ func (h *htlcOutgoingContestResolver) Decode(r io.Reader) error {
 	return h.htlcTimeoutResolver.Decode(r)
 }
 
-// AttachResolverKit should be called once a resolved is successfully decoded
+// AttachConfig should be called once a resolved is successfully decoded from
-// from its stored format. This struct delivers a generic tool kit that
+// its stored format. This struct delivers the configuration items that
 // resolvers need to complete their duty.
 //
 // NOTE: Part of the ContractResolver interface.
-func (h *htlcOutgoingContestResolver) AttachResolverKit(r ResolverKit) {
+func (h *htlcOutgoingContestResolver) AttachConfig(r ResolverConfig) {
-	h.ResolverKit = r
+	h.htlcTimeoutResolver.AttachConfig(r)
 }
 
 // A compile time assertion to ensure htlcOutgoingContestResolver meets the

contractcourt/htlc_outgoing_contest_resolver_test.go

@@ -122,15 +122,17 @@ func newOutgoingResolverTestContext(t *testing.T) *outgoingResolverTestContext {
 		},
 	}
 
-	resolver := &htlcOutgoingContestResolver{
+	cfg := ResolverConfig{
-		htlcTimeoutResolver: htlcTimeoutResolver{
-			ResolverKit: ResolverKit{
 		ChannelArbitratorConfig: chainCfg,
 		Checkpoint: func(_ ContractResolver) error {
 			checkPointChan <- struct{}{}
 			return nil
 		},
-			},
+	}
+
+	resolver := &htlcOutgoingContestResolver{
+		htlcTimeoutResolver: htlcTimeoutResolver{
+			contractResolverKit: *newContractResolverKit(cfg),
 			htlcResolution:      outgoingRes,
 		},
 	}

contractcourt/htlc_success_resolver.go

@@ -52,7 +52,7 @@ type htlcSuccessResolver struct {
 	// account any fees that may have to be paid if it goes on chain.
 	htlcAmt lnwire.MilliSatoshi
 
-	ResolverKit
+	contractResolverKit
 }
 
 // ResolverKey returns an identifier which should be globally unique for this
@@ -318,13 +318,13 @@ func (h *htlcSuccessResolver) Decode(r io.Reader) error {
 	return nil
 }
 
-// AttachResolverKit should be called once a resolved is successfully decoded
+// AttachConfig should be called once a resolved is successfully decoded from
-// from its stored format. This struct delivers a generic tool kit that
+// its stored format. This struct delivers the configuration items that
 // resolvers need to complete their duty.
 //
 // NOTE: Part of the ContractResolver interface.
-func (h *htlcSuccessResolver) AttachResolverKit(r ResolverKit) {
+func (h *htlcSuccessResolver) AttachConfig(r ResolverConfig) {
-	h.ResolverKit = r
+	h.contractResolverKit = *newContractResolverKit(r)
 }
 
 // A compile time assertion to ensure htlcSuccessResolver meets the

contractcourt/htlc_timeout_resolver.go

@@ -48,7 +48,7 @@ type htlcTimeoutResolver struct {
 	// account any fees that may have to be paid if it goes on chain.
 	htlcAmt lnwire.MilliSatoshi
 
-	ResolverKit
+	contractResolverKit
 }
 
 // ResolverKey returns an identifier which should be globally unique for this
@@ -436,13 +436,13 @@ func (h *htlcTimeoutResolver) Decode(r io.Reader) error {
 	return nil
 }
 
-// AttachResolverKit should be called once a resolved is successfully decoded
+// AttachConfig should be called once a resolved is successfully decoded from
-// from its stored format. This struct delivers a generic tool kit that
+// its stored format. This struct delivers the configuration items that
 // resolvers need to complete their duty.
 //
 // NOTE: Part of the ContractResolver interface.
-func (h *htlcTimeoutResolver) AttachResolverKit(r ResolverKit) {
+func (h *htlcTimeoutResolver) AttachConfig(r ResolverConfig) {
-	h.ResolverKit = r
+	h.contractResolverKit = *newContractResolverKit(r)
 }
 
 // A compile time assertion to ensure htlcTimeoutResolver meets the

contractcourt/htlc_timeout_resolver_test.go

@@ -237,14 +237,17 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 			},
 		}
 
-		resolver := &htlcTimeoutResolver{
+		cfg := ResolverConfig{
-			ResolverKit: ResolverKit{
 			ChannelArbitratorConfig: chainCfg,
 			Checkpoint: func(_ ContractResolver) error {
 				checkPointChan <- struct{}{}
 				return nil
 			},
-			},
+		}
+		resolver := &htlcTimeoutResolver{
+			contractResolverKit: *newContractResolverKit(
+				cfg,
+			),
 		}
 		resolver.htlcResolution.SweepSignDesc = *fakeSignDesc