Merge pull request #8452 from ProofOfKeags/refactor/contractcourt/naming-consistency

contractcourt: homogenize naming convention

contractcourt/breach_arbitrator.go

@@ -53,12 +53,12 @@ var (
 	// for the first and one for the second level).
 	taprootRetributionBucket = []byte("tap-retribution")
 
-	// errBrarShuttingDown is an error returned if the breacharbiter has
+	// errBrarShuttingDown is an error returned if the BreachArbitrator has
 	// been signalled to exit.
-	errBrarShuttingDown = errors.New("breacharbiter shutting down")
+	errBrarShuttingDown = errors.New("BreachArbitrator shutting down")
 )
 
-// ContractBreachEvent is an event the BreachArbiter will receive in case a
+// ContractBreachEvent is an event the BreachArbitrator will receive in case a
 // contract breach is observed on-chain. It contains the necessary information
 // to handle the breach, and a ProcessACK closure we will use to ACK the event
 // when we have safely stored all the necessary information.
@@ -71,7 +71,7 @@ type ContractBreachEvent struct {
 	// store. In case storing the information to the store fails, a non-nil
 	// error should be used. When this closure returns, it means that the
 	// contract court has marked the channel pending close in the DB, and
-	// it is safe for the BreachArbiter to carry on its duty.
+	// it is safe for the BreachArbitrator to carry on its duty.
 	ProcessACK func(error)
 
 	// BreachRetribution is the information needed to act on this contract
@@ -94,11 +94,12 @@ const (
 )
 
 // RetributionStorer provides an interface for managing a persistent map from
-// wire.OutPoint -> retributionInfo. Upon learning of a breach, a BreachArbiter
+// wire.OutPoint -> retributionInfo. Upon learning of a breach, a
-// should record the retributionInfo for the breached channel, which serves a
+// BreachArbitrator should record the retributionInfo for the breached channel,
-// checkpoint in the event that retribution needs to be resumed after failure.
+// which serves a checkpoint in the event that retribution needs to be resumed
-// A RetributionStore provides an interface for managing the persisted set, as
+// after failure. A RetributionStore provides an interface for managing the
-// well as mapping user defined functions over the entire on-disk contents.
+// persisted set, as well as mapping user defined functions over the entire
+// on-disk contents.
 //
 // Calls to RetributionStore may occur concurrently. A concrete instance of
 // RetributionStore should use appropriate synchronization primitives, or
@@ -125,7 +126,8 @@ type RetributionStorer interface {
 }
 
 // BreachConfig bundles the required subsystems used by the breach arbiter. An
-// instance of BreachConfig is passed to newBreachArbiter during instantiation.
+// instance of BreachConfig is passed to NewBreachArbitrator during
+// instantiation.
 type BreachConfig struct {
 	// CloseLink allows the breach arbiter to shutdown any channel links for
 	// which it detects a breach, ensuring now further activity will
@@ -154,9 +156,9 @@ type BreachConfig struct {
 	// transaction to the network.
 	PublishTransaction func(*wire.MsgTx, string) error
 
-	// ContractBreaches is a channel where the BreachArbiter will receive
+	// ContractBreaches is a channel where the BreachArbitrator will receive
 	// notifications in the event of a contract breach being observed. A
-	// ContractBreachEvent must be ACKed by the BreachArbiter, such that
+	// ContractBreachEvent must be ACKed by the BreachArbitrator, such that
 	// the sending subsystem knows that the event is properly handed off.
 	ContractBreaches <-chan *ContractBreachEvent
 
@@ -171,7 +173,7 @@ type BreachConfig struct {
 	Store RetributionStorer
 }
 
-// BreachArbiter is a special subsystem which is responsible for watching and
+// BreachArbitrator is a special subsystem which is responsible for watching and
 // acting on the detection of any attempted uncooperative channel breaches by
 // channel counterparties. This file essentially acts as deterrence code for
 // those attempting to launch attacks against the daemon. In practice it's
@@ -179,7 +181,7 @@ type BreachConfig struct {
 // important to have it in place just in case we encounter cheating channel
 // counterparties.
 // TODO(roasbeef): closures in config for subsystem pointers to decouple?
-type BreachArbiter struct {
+type BreachArbitrator struct {
 	started sync.Once
 	stopped sync.Once
 
@@ -192,19 +194,19 @@ type BreachArbiter struct {
 	sync.Mutex
 }
 
-// NewBreachArbiter creates a new instance of a BreachArbiter initialized with
+// NewBreachArbitrator creates a new instance of a BreachArbitrator initialized
-// its dependent objects.
+// with its dependent objects.
-func NewBreachArbiter(cfg *BreachConfig) *BreachArbiter {
+func NewBreachArbitrator(cfg *BreachConfig) *BreachArbitrator {
-	return &BreachArbiter{
+	return &BreachArbitrator{
 		cfg:           cfg,
 		subscriptions: make(map[wire.OutPoint]chan struct{}),
 		quit:          make(chan struct{}),
 	}
 }
 
-// Start is an idempotent method that officially starts the BreachArbiter along
+// Start is an idempotent method that officially starts the BreachArbitrator
-// with all other goroutines it needs to perform its functions.
+// along with all other goroutines it needs to perform its functions.
-func (b *BreachArbiter) Start() error {
+func (b *BreachArbitrator) Start() error {
 	var err error
 	b.started.Do(func() {
 		brarLog.Info("Breach arbiter starting")
@@ -213,7 +215,7 @@ func (b *BreachArbiter) Start() error {
 	return err
 }
 
-func (b *BreachArbiter) start() error {
+func (b *BreachArbitrator) start() error {
 	// Load all retributions currently persisted in the retribution store.
 	var breachRetInfos map[wire.OutPoint]retributionInfo
 	if err := b.cfg.Store.ForAll(func(ret *retributionInfo) error {
@@ -305,10 +307,10 @@ func (b *BreachArbiter) start() error {
 	return nil
 }
 
-// Stop is an idempotent method that signals the BreachArbiter to execute a
+// Stop is an idempotent method that signals the BreachArbitrator to execute a
 // graceful shutdown. This function will block until all goroutines spawned by
-// the BreachArbiter have gracefully exited.
+// the BreachArbitrator have gracefully exited.
-func (b *BreachArbiter) Stop() error {
+func (b *BreachArbitrator) Stop() error {
 	b.stopped.Do(func() {
 		brarLog.Infof("Breach arbiter shutting down...")
 		defer brarLog.Debug("Breach arbiter shutdown complete")
@@ -321,13 +323,13 @@ func (b *BreachArbiter) Stop() error {
 
 // IsBreached queries the breach arbiter's retribution store to see if it is
 // aware of any channel breaches for a particular channel point.
-func (b *BreachArbiter) IsBreached(chanPoint *wire.OutPoint) (bool, error) {
+func (b *BreachArbitrator) IsBreached(chanPoint *wire.OutPoint) (bool, error) {
 	return b.cfg.Store.IsBreached(chanPoint)
 }
 
 // SubscribeBreachComplete is used by outside subsystems to be notified of a
 // successful breach resolution.
-func (b *BreachArbiter) SubscribeBreachComplete(chanPoint *wire.OutPoint,
+func (b *BreachArbitrator) SubscribeBreachComplete(chanPoint *wire.OutPoint,
 	c chan struct{}) (bool, error) {
 
 	breached, err := b.cfg.Store.IsBreached(chanPoint)
@@ -353,9 +355,9 @@ func (b *BreachArbiter) SubscribeBreachComplete(chanPoint *wire.OutPoint,
 	return false, nil
 }
 
-// notifyBreachComplete is used by the BreachArbiter to notify outside
+// notifyBreachComplete is used by the BreachArbitrator to notify outside
 // subsystems that the breach resolution process is complete.
-func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
+func (b *BreachArbitrator) notifyBreachComplete(chanPoint *wire.OutPoint) {
 	b.Lock()
 	defer b.Unlock()
 	if c, ok := b.subscriptions[*chanPoint]; ok {
@@ -366,7 +368,7 @@ func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
 	delete(b.subscriptions, *chanPoint)
 }
 
-// contractObserver is the primary goroutine for the BreachArbiter. This
+// contractObserver is the primary goroutine for the BreachArbitrator. This
 // goroutine is responsible for handling breach events coming from the
 // contractcourt on the ContractBreaches channel. If a channel breach is
 // detected, then the contractObserver will execute the retribution logic
@@ -374,7 +376,7 @@ func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
 // wallet.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) contractObserver() {
+func (b *BreachArbitrator) contractObserver() {
 	defer b.wg.Done()
 
 	brarLog.Infof("Starting contract observer, watching for breaches.")
@@ -406,7 +408,7 @@ type spend struct {
 // returns the spend details for those outputs. The spendNtfns map is a cache
 // used to store registered spend subscriptions, in case we must call this
 // method multiple times.
-func (b *BreachArbiter) waitForSpendEvent(breachInfo *retributionInfo,
+func (b *BreachArbitrator) waitForSpendEvent(breachInfo *retributionInfo,
 	spendNtfns map[wire.OutPoint]*chainntnfs.SpendEvent) ([]spend, error) {
 
 	inputs := breachInfo.breachedOutputs
@@ -684,8 +686,10 @@ func updateBreachInfo(breachInfo *retributionInfo, spends []spend) (
 // the lingering funds within the channel into the daemon's wallet.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) exactRetribution(confChan *chainntnfs.ConfirmationEvent,
+//
-	breachInfo *retributionInfo) {
+//nolint:funlen
+func (b *BreachArbitrator) exactRetribution(
+	confChan *chainntnfs.ConfirmationEvent, breachInfo *retributionInfo) {
 
 	defer b.wg.Done()
 
@@ -916,7 +920,7 @@ Loop:
 
 // cleanupBreach marks the given channel point as fully resolved and removes the
 // retribution for that the channel from the retribution store.
-func (b *BreachArbiter) cleanupBreach(chanPoint *wire.OutPoint) error {
+func (b *BreachArbitrator) cleanupBreach(chanPoint *wire.OutPoint) error {
 	// With the channel closed, mark it in the database as such.
 	err := b.cfg.DB.MarkChanFullyClosed(chanPoint)
 	if err != nil {
@@ -943,15 +947,17 @@ func (b *BreachArbiter) cleanupBreach(chanPoint *wire.OutPoint) error {
 }
 
 // handleBreachHandoff handles a new breach event, by writing it to disk, then
-// notifies the BreachArbiter contract observer goroutine that a channel's
+// notifies the BreachArbitrator contract observer goroutine that a channel's
 // contract has been breached by the prior counterparty. Once notified the
-// BreachArbiter will attempt to sweep ALL funds within the channel using the
+// BreachArbitrator will attempt to sweep ALL funds within the channel using the
 // information provided within the BreachRetribution generated due to the
 // breach of channel contract. The funds will be swept only after the breaching
 // transaction receives a necessary number of confirmations.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) handleBreachHandoff(breachEvent *ContractBreachEvent) {
+func (b *BreachArbitrator) handleBreachHandoff(
+	breachEvent *ContractBreachEvent) {
+
 	defer b.wg.Done()
 
 	chanPoint := breachEvent.ChanPoint
@@ -1367,7 +1373,7 @@ type justiceTxVariants struct {
 // the funds within the channel which we are now entitled to due to a breach of
 // the channel's contract by the counterparty. This function returns a *fully*
 // signed transaction with the witness for each input fully in place.
-func (b *BreachArbiter) createJusticeTx(
+func (b *BreachArbitrator) createJusticeTx(
 	breachedOutputs []breachedOutput) (*justiceTxVariants, error) {
 
 	var (
@@ -1442,7 +1448,7 @@ func (b *BreachArbiter) createJusticeTx(
 }
 
 // createSweepTx creates a tx that sweeps the passed inputs back to our wallet.
-func (b *BreachArbiter) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
+func (b *BreachArbitrator) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
 	error) {
 
 	if len(inputs) == 0 {
@@ -1498,7 +1504,7 @@ func (b *BreachArbiter) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
 
 // sweepSpendableOutputsTxn creates a signed transaction from a sequence of
 // spendable outputs by sweeping the funds into a single p2wkh output.
-func (b *BreachArbiter) sweepSpendableOutputsTxn(txWeight int64,
+func (b *BreachArbitrator) sweepSpendableOutputsTxn(txWeight int64,
 	inputs ...input.Input) (*wire.MsgTx, error) {
 
 	// First, we obtain a new public key script from the wallet which we'll

contractcourt/breach_arbitrator_test.go

@@ -951,7 +951,7 @@ restartCheck:
 	}
 }
 
-func initBreachedState(t *testing.T) (*BreachArbiter,
+func initBreachedState(t *testing.T) (*BreachArbitrator,
 	*lnwallet.LightningChannel, *lnwallet.LightningChannel,
 	*lnwallet.LocalForceCloseSummary, chan *ContractBreachEvent) {
 
@@ -1338,7 +1338,7 @@ func getSpendTransactions(signer input.Signer, chanPoint *wire.OutPoint,
 		},
 	}
 
-	// In order for  the breacharbiter to detect that it is being spent
+	// In order for  the BreachArbitrator to detect that it is being spent
 	// using the revocation key, it will inspect the witness. Therefore
 	// sign and add the witness to the HTLC sweep.
 	retInfo := newRetributionInfo(chanPoint, retribution)
@@ -1684,7 +1684,7 @@ func testBreachSpends(t *testing.T, test breachTest) {
 	}
 
 	// We also keep a map of those remaining outputs we expect the
-	// breacharbiter to try and sweep.
+	// BreachArbitrator to try and sweep.
 	inputsToSweep := map[wire.OutPoint]struct{}{
 		htlcOutpoint:   {},
 		localOutpoint:  {},
@@ -1892,7 +1892,7 @@ func TestBreachDelayedJusticeConfirmation(t *testing.T) {
 	}
 
 	// Now mine another block without the justice tx confirming. This
-	// should lead to the breacharbiter publishing the split justice tx
+	// should lead to the BreachArbitrator publishing the split justice tx
 	// variants.
 	notifier.EpochChan <- &chainntnfs.BlockEpoch{
 		Height: blockHeight + 4,
@@ -1988,7 +1988,7 @@ func findInputIndex(t *testing.T, op wire.OutPoint, tx *wire.MsgTx) int {
 
 // assertArbiterBreach checks that the breach arbiter has persisted the breach
 // information for a particular channel.
-func assertArbiterBreach(t *testing.T, brar *BreachArbiter,
+func assertArbiterBreach(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint) {
 
 	t.Helper()
@@ -2008,7 +2008,7 @@ func assertArbiterBreach(t *testing.T, brar *BreachArbiter,
 
 // assertNoArbiterBreach checks that the breach arbiter has not persisted the
 // breach information for a particular channel.
-func assertNoArbiterBreach(t *testing.T, brar *BreachArbiter,
+func assertNoArbiterBreach(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint) {
 
 	t.Helper()
@@ -2027,7 +2027,7 @@ func assertNoArbiterBreach(t *testing.T, brar *BreachArbiter,
 
 // assertBrarCleanup blocks until the given channel point has been removed the
 // retribution store and the channel is fully closed in the database.
-func assertBrarCleanup(t *testing.T, brar *BreachArbiter,
+func assertBrarCleanup(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint, db *channeldb.ChannelStateDB) {
 
 	t.Helper()
@@ -2108,7 +2108,7 @@ func assertNotPendingClosed(t *testing.T, c *lnwallet.LightningChannel) {
 // createTestArbiter instantiates a breach arbiter with a failing retribution
 // store, so that controlled failures can be tested.
 func createTestArbiter(t *testing.T, contractBreaches chan *ContractBreachEvent,
-	db *channeldb.DB) (*BreachArbiter, error) {
+	db *channeldb.DB) (*BreachArbitrator, error) {
 
 	// Create a failing retribution store, that wraps a normal one.
 	store := newFailingRetributionStore(func() RetributionStorer {
@@ -2120,7 +2120,7 @@ func createTestArbiter(t *testing.T, contractBreaches chan *ContractBreachEvent,
 
 	// Assemble our test arbiter.
 	notifier := mock.MakeMockSpendNotifier()
-	ba := NewBreachArbiter(&BreachConfig{
+	ba := NewBreachArbitrator(&BreachConfig{
 		CloseLink:          func(_ *wire.OutPoint, _ ChannelCloseType) {},
 		DB:                 db.ChannelStateDB(),
 		Estimator:          chainfee.NewStaticEstimator(12500, 0),

contractcourt/breach_resolver.go

@@ -8,13 +8,14 @@ import (
 )
 
 // breachResolver is a resolver that will handle breached closes. In the
-// future, this will likely take over the duties the current breacharbiter has.
+// future, this will likely take over the duties the current BreachArbitrator
+// has.
 type breachResolver struct {
 	// resolved reflects if the contract has been fully resolved or not.
 	resolved bool
 
 	// subscribed denotes whether or not the breach resolver has subscribed
-	// to the breacharbiter for breach resolution.
+	// to the BreachArbitrator for breach resolution.
 	subscribed bool
 
 	// replyChan is closed when the breach arbiter has completed serving
@@ -42,8 +43,8 @@ func (b *breachResolver) ResolverKey() []byte {
 	return key[:]
 }
 
-// Resolve queries the breacharbiter to see if the justice transaction has been
+// Resolve queries the BreachArbitrator to see if the justice transaction has
-// broadcast.
+// been broadcast.
 func (b *breachResolver) Resolve() (ContractResolver, error) {
 	if !b.subscribed {
 		complete, err := b.SubscribeBreachComplete(

contractcourt/chain_arbitrator.go

@@ -100,10 +100,10 @@ type ChainArbitratorConfig struct {
 	MarkLinkInactive func(wire.OutPoint) error
 
 	// ContractBreach is a function closure that the ChainArbitrator will
-	// use to notify the breachArbiter about a contract breach. It should
+	// use to notify the BreachArbitrator about a contract breach. It should
-	// only return a non-nil error when the breachArbiter has preserved
+	// only return a non-nil error when the BreachArbitrator has preserved
 	// the necessary breach info for this channel point. Once the breach
-	// resolution is persisted in the channel arbitrator, it will be safe
+	// resolution is persisted in the ChannelArbitrator, it will be safe
 	// to mark the channel closed.
 	ContractBreach func(wire.OutPoint, *lnwallet.BreachRetribution) error
 

contractcourt/chain_watcher.go

@@ -175,7 +175,7 @@ type chainWatcherConfig struct {
 
 	// contractBreach is a method that will be called by the watcher if it
 	// detects that a contract breach transaction has been confirmed. It
-	// will only return a non-nil error when the breachArbiter has
+	// will only return a non-nil error when the BreachArbitrator has
 	// preserved the necessary breach info for this channel point.
 	contractBreach func(*lnwallet.BreachRetribution) error
 
@@ -1243,14 +1243,14 @@ func (c *chainWatcher) dispatchContractBreach(spendEvent *chainntnfs.SpendDetail
 		closeSummary.LastChanSyncMsg = chanSync
 	}
 
-	// Hand the retribution info over to the breach arbiter. This function
+	// Hand the retribution info over to the BreachArbitrator. This function
 	// will wait for a response from the breach arbiter and then proceed to
 	// send a BreachCloseInfo to the channel arbitrator. The channel arb
 	// will then mark the channel as closed after resolutions and the
 	// commit set are logged in the arbitrator log.
 	if err := c.cfg.contractBreach(retribution); err != nil {
 		log.Errorf("unable to hand breached contract off to "+
-			"breachArbiter: %v", err)
+			"BreachArbitrator: %v", err)
 		return err
 	}
 

contractcourt/channel_arbitrator.go

@@ -860,7 +860,7 @@ const (
 
 	// breachCloseTrigger is a transition trigger driven by a remote breach
 	// being confirmed. In this case the channel arbitrator will wait for
-	// the breacharbiter to finish and then clean up gracefully.
+	// the BreachArbitrator to finish and then clean up gracefully.
 	breachCloseTrigger
 )
 
@@ -2891,7 +2891,7 @@ func (c *ChannelArbitrator) channelAttendant(bestHeight int32) {
 			}
 
 		// The remote has breached the channel. As this is handled by
-		// the ChainWatcher and BreachArbiter, we don't have to do
+		// the ChainWatcher and BreachArbitrator, we don't have to do
 		// anything in particular, so just advance our state and
 		// gracefully exit.
 		case breachInfo := <-c.cfg.ChainEvents.ContractBreach:
@@ -2926,7 +2926,7 @@ func (c *ChannelArbitrator) channelAttendant(bestHeight int32) {
 			}
 
 			// The channel is finally marked pending closed here as
-			// the breacharbiter and channel arbitrator have
+			// the BreachArbitrator and channel arbitrator have
 			// persisted the relevant states.
 			closeSummary := &breachInfo.CloseSummary
 			err = c.cfg.MarkChannelClosed(

contractcourt/channel_arbitrator_test.go

@@ -1430,7 +1430,7 @@ func TestChannelArbitratorPersistence(t *testing.T) {
 // is breached by the remote node. In these cases we expect the
 // ChannelArbitrator to properly execute the breachResolver flow and then
 // gracefully exit once the breachResolver receives the signal from what would
-// normally be the breacharbiter.
+// normally be the BreachArbitrator.
 func TestChannelArbitratorForceCloseBreachedChannel(t *testing.T) {
 	log := &mockArbitratorLog{
 		state:     StateDefault,

lnrpc/walletrpc/walletkit_server.go

@@ -201,7 +201,7 @@ var (
 	// are numbered differently. The protobuf enum cannot be renumbered
 	// because this would break backwards compatibility with older clients,
 	// and the native enum cannot be renumbered because it is stored in the
-	// watchtower and breacharbiter databases.
+	// watchtower and BreachArbitrator databases.
 	//
 	//nolint:lll
 	allWitnessTypes = map[input.WitnessType]WitnessType{

server.go

@@ -262,7 +262,7 @@ type server struct {
 
 	witnessBeacon contractcourt.WitnessBeacon
 
-	breachArbiter *contractcourt.BreachArbiter
+	breachArbitrator *contractcourt.BreachArbitrator
 
 	missionControl *routing.MissionControl
 
@@ -1099,22 +1099,24 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 	}
 
 	// We will use the following channel to reliably hand off contract
-	// breach events from the ChannelArbitrator to the breachArbiter,
+	// breach events from the ChannelArbitrator to the BreachArbitrator,
 	contractBreaches := make(chan *contractcourt.ContractBreachEvent, 1)
 
-	s.breachArbiter = contractcourt.NewBreachArbiter(&contractcourt.BreachConfig{
+	s.breachArbitrator = contractcourt.NewBreachArbitrator(
-		CloseLink:          closeLink,
+		&contractcourt.BreachConfig{
-		DB:                 s.chanStateDB,
+			CloseLink:          closeLink,
-		Estimator:          s.cc.FeeEstimator,
+			DB:                 s.chanStateDB,
-		GenSweepScript:     newSweepPkScriptGen(cc.Wallet),
+			Estimator:          s.cc.FeeEstimator,
-		Notifier:           cc.ChainNotifier,
+			GenSweepScript:     newSweepPkScriptGen(cc.Wallet),
-		PublishTransaction: cc.Wallet.PublishTransaction,
+			Notifier:           cc.ChainNotifier,
-		ContractBreaches:   contractBreaches,
+			PublishTransaction: cc.Wallet.PublishTransaction,
-		Signer:             cc.Wallet.Cfg.Signer,
+			ContractBreaches:   contractBreaches,
-		Store: contractcourt.NewRetributionStore(
+			Signer:             cc.Wallet.Cfg.Signer,
-			dbs.ChanStateDB,
+			Store: contractcourt.NewRetributionStore(
-		),
+				dbs.ChanStateDB,
-	})
+			),
+		},
+	)
 
 	s.chainArb = contractcourt.NewChainArbitrator(contractcourt.ChainArbitratorConfig{
 		ChainHash:              *s.cfg.ActiveNetParams.GenesisHash,
@@ -1167,8 +1169,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 		ContractBreach: func(chanPoint wire.OutPoint,
 			breachRet *lnwallet.BreachRetribution) error {
 
-			// processACK will handle the breachArbiter ACKing the
+			// processACK will handle the BreachArbitrator ACKing
-			// event.
+			// the event.
 			finalErr := make(chan error, 1)
 			processACK := func(brarErr error) {
 				if brarErr != nil {
@@ -1176,7 +1178,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 					return
 				}
 
-				// If the breachArbiter successfully handled
+				// If the BreachArbitrator successfully handled
 				// the event, we can signal that the handoff
 				// was successful.
 				finalErr <- nil
@@ -1188,7 +1190,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 				BreachRetribution: breachRet,
 			}
 
-			// Send the contract breach event to the breachArbiter.
+			// Send the contract breach event to the
+			// BreachArbitrator.
 			select {
 			case contractBreaches <- event:
 			case <-s.quit:
@@ -1196,7 +1199,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 			}
 
 			// We'll wait for a final error to be available from
-			// the breachArbiter.
+			// the BreachArbitrator.
 			select {
 			case err := <-finalErr:
 				return err
@@ -1215,8 +1218,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 		PaymentsExpirationGracePeriod: cfg.PaymentsExpirationGracePeriod,
 		IsForwardedHTLC:               s.htlcSwitch.IsForwardedHTLC,
 		Clock:                         clock.NewDefaultClock(),
-		SubscribeBreachComplete:       s.breachArbiter.SubscribeBreachComplete,
+		SubscribeBreachComplete:       s.breachArbitrator.SubscribeBreachComplete, //nolint:lll
-		PutFinalHtlcOutcome:           s.chanStateDB.PutOnchainFinalHtlcOutcome, //nolint: lll
+		PutFinalHtlcOutcome:           s.chanStateDB.PutOnchainFinalHtlcOutcome,   //nolint: lll
 		HtlcNotifier:                  s.htlcNotifier,
 	}, dbs.ChanStateDB)
 
@@ -1936,11 +1939,11 @@ func (s *server) Start() error {
 		}
 		cleanup = cleanup.add(s.utxoNursery.Stop)
 
-		if err := s.breachArbiter.Start(); err != nil {
+		if err := s.breachArbitrator.Start(); err != nil {
 			startErr = err
 			return
 		}
-		cleanup = cleanup.add(s.breachArbiter.Stop)
+		cleanup = cleanup.add(s.breachArbitrator.Stop)
 
 		if err := s.fundingMgr.Start(); err != nil {
 			startErr = err
@@ -2244,8 +2247,9 @@ func (s *server) Stop() error {
 		if err := s.fundingMgr.Stop(); err != nil {
 			srvrLog.Warnf("failed to stop fundingMgr: %v", err)
 		}
-		if err := s.breachArbiter.Stop(); err != nil {
+		if err := s.breachArbitrator.Stop(); err != nil {
-			srvrLog.Warnf("failed to stop breachArbiter: %v", err)
+			srvrLog.Warnf("failed to stop breachArbitrator: %v",
+				err)
 		}
 		if err := s.utxoNursery.Stop(); err != nil {
 			srvrLog.Warnf("failed to stop utxoNursery: %v", err)