Repository: lightningnetwork/lnd
Pull request #7359 (2023-01-25 17:33:11)

build: fix Makefile ldflags for mac and mobile, bump gomobile deps, enable gomodules
## Change Description
PR [6963](https://github.com/lightningnetwork/lnd/pull/6963) refactored the Makefile to have a more streamlined approach to ldflags. However, in the process it also introduced two subtle but critical errors.
1. The `-ldflags` parameter is missing.
2. The ldflags themselves are not wrapped in a string.

The result is that the arguments are mangled, and gomobile complains about `-s` not being a parameter.

Before 6963:
```GO111MODULE=off /home/synthlock/go/bin/gomobile bind -target=android -tags="mobile dev autopilotrpc chainrpc invoicesrpc neutrinorpc peersrpc routerrpc signrpc verrpc walletrpc watchtowerrpc wtclientrpc" -ldflags " -s -w -X github.com/lightningnetwork/lnd/build.Commit=v0.15.5-beta -X github.com/lightningnetwork/lnd/build.CommitHash=c0a09209782b1c62c3393fcea0844e095c25046b -X github.com/lightningnetwork/lnd/build.GoVersion=go1.18.10 -X github.com/lightningnetwork/lnd/build.RawTags=" -v -o /home/synthlock/go/src/github.com/lightningnetwork/lnd/mobile/build/android/Lndmobile.aar github.com/lightningnetwork/lnd/mobile```
After 6963:
```GO111MODULE=off /home/synthlock/go/bin/gomobile bind -target=android -tags="mobile dev autopilotrpc chainrpc invoicesrpc neutrinorpc peersrpc routerrpc signrpc verrpc walletrpc watchtowerrpc wtclientrpc"  -s -w -buildid= -X github.com/lightningnetwork/lnd/build.Commit=kvdb/v1.4.1-6-g9187d4679 -v -o /home/synthlock/go/src/github.com/lightningnetwork/lnd/mobile/build/android/Lndmobile.aar github.com/lightningnetwork/lnd/mobile```

This PR adds in the correct behavior for ldflag passing. `-ldflags` is explicitly set in each affected stanza, and the ldflags are wrapped in a string.


## Steps to Test
`make android` on v0.15.5 release versus master.

## Pull Request Checklist
### Testing
- [ ] Your PR passes all CI checks.
- [ ] Tests covering the positive and negative (error paths) are included.
- [ ] Bug fixes contain tests triggering the bug to prevent regressions.

### Code Style and Documentation
- [x] The change obeys the [Code Documentation and Commenting](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md#CodeDocumentation) guidelines, and lines wrap at 80.
- [x] Commits follow the [Ideal Git Commit Structure](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md#IdealGitCommitStructure).
- [x] Any new logging statements use an appropriate subsystem and logging level.
- [x]  [There is a change description in the release notes](https://github.com/lightningnetwork/lnd/tree/master/docs/release-notes), or `[skip ci]` in the commit message for small changes.

📝 Please see our  [Contribution Guidelines](https://github.com/lightningnetwork/lnd/blob/master/docs/code_contribution_guidelines.md) for further guidance.

djkazic: @guggero Interesting. Does this not build for you? I can apply the patch, but it seems like the main changes there are bumping the gomobile and bind deps.
djkazic: Commit messages edited and signed.
lightninglabs-deploy: @djkazic, remember to re-request review from reviewers when ready
hsjoberg: @guggero I can confirm iOS and macOS targets build and work with this PR.
djkazic: @guggero should I rebase this one too?

Patch:
diff --git a/Makefile b/Makefile
index 1c1e074b2..d563b3dd9 100644
--- a/Makefile
+++ b/Makefile
@@ -10,7 +10,7 @@ GOIMPORTS_PKG := github.com/rinchsan/gosimports/cmd/gosimports
 GO_BIN := ${GOPATH}/bin
 BTCD_BIN := $(GO_BIN)/btcd
 GOIMPORTS_BIN := $(GO_BIN)/gosimports
-GOMOBILE_BIN := GO111MODULE=off $(GO_BIN)/gomobile
+GOMOBILE_BIN := $(GO_BIN)/gomobile
 GOACC_BIN := $(GO_BIN)/go-acc
 
 MOBILE_BUILD_DIR :=${GOPATH}/src/$(MOBILE_PKG)/build
@@ -274,25 +274,25 @@ vendor:
 	@$(call print, "Re-creating vendor directory.")
 	rm -r vendor/; go mod vendor
 
-apple: vendor mobile-rpc
+apple: mobile-rpc
 	@$(call print, "Building iOS and macOS cxframework ($(IOS_BUILD)).")
 	mkdir -p $(IOS_BUILD_DIR)
-	$(GOMOBILE_BIN) bind -target=ios,iossimulator,macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" $(RELEASE_LDFLAGS) -v -o $(IOS_BUILD) $(MOBILE_PKG)
+	$(GOMOBILE_BIN) bind -target=ios,iossimulator,macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
 
-ios: vendor mobile-rpc
+ios: mobile-rpc
 	@$(call print, "Building iOS cxframework ($(IOS_BUILD)).")
 	mkdir -p $(IOS_BUILD_DIR)
-	$(GOMOBILE_BIN) bind -target=ios,iossimulator -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" $(RELEASE_LDFLAGS) -v -o $(IOS_BUILD) $(MOBILE_PKG)
+	$(GOMOBILE_BIN) bind -target=ios,iossimulator -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
 
-macos: vendor mobile-rpc
+macos: mobile-rpc
 	@$(call print, "Building macOS cxframework ($(IOS_BUILD)).")
 	mkdir -p $(IOS_BUILD_DIR)
-	$(GOMOBILE_BIN) bind -target=macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" $(RELEASE_LDFLAGS) -v -o $(IOS_BUILD) $(MOBILE_PKG)
+	$(GOMOBILE_BIN) bind -target=macos -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(IOS_BUILD) $(MOBILE_PKG)
 
-android: vendor mobile-rpc
+android: mobile-rpc
 	@$(call print, "Building Android library ($(ANDROID_BUILD)).")
 	mkdir -p $(ANDROID_BUILD_DIR)
-	$(GOMOBILE_BIN) bind -target=android -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" $(RELEASE_LDFLAGS) -v -o $(ANDROID_BUILD) $(MOBILE_PKG)
+	$(GOMOBILE_BIN) bind -target=android -androidapi 21 -tags="mobile $(DEV_TAGS) $(RPC_TAGS)" -ldflags "$(RELEASE_LDFLAGS)" -v -o $(ANDROID_BUILD) $(MOBILE_PKG)
 
 mobile: ios android
 
diff --git a/aliasmgr/aliasmgr.go b/aliasmgr/aliasmgr.go
index f33eb391e..381476a73 100644
--- a/aliasmgr/aliasmgr.go
+++ b/aliasmgr/aliasmgr.go
@@ -38,7 +38,7 @@ var (
 	lastAliasKey = []byte("last-alias-key")
 
 	// invoiceAliasBucket is a root-level bucket that stores the alias
-	// SCIDs that our peers send us in the channel_ready TLV. The keys are
+	// SCIDs that our peers send us in the funding_locked TLV. The keys are
 	// the ChannelID generated from the FundingOutpoint and the values are
 	// the remote peer's alias SCID.
 	invoiceAliasBucket = []byte("invoice-alias-bucket")
@@ -88,7 +88,7 @@ type Manager struct {
 	aliasToBase map[lnwire.ShortChannelID]lnwire.ShortChannelID
 
 	// peerAlias is a cache for the alias SCIDs that our peers send us in
-	// the channel_ready TLV. The keys are the ChannelID generated from
+	// the funding_locked TLV. The keys are the ChannelID generated from
 	// the FundingOutpoint and the values are the remote peer's alias SCID.
 	// The values should match the ones stored in the "invoice-alias-bucket"
 	// bucket.
@@ -341,7 +341,7 @@ func (m *Manager) DeleteSixConfs(baseScid lnwire.ShortChannelID) error {
 }
 
 // PutPeerAlias stores the peer's alias SCID once we learn of it in the
-// channel_ready message.
+// funding_locked message.
 func (m *Manager) PutPeerAlias(chanID lnwire.ChannelID,
 	alias lnwire.ShortChannelID) error {
 
diff --git a/channeldb/channel.go b/channeldb/channel.go
index b731028ee..d71f17047 100644
--- a/channeldb/channel.go
+++ b/channeldb/channel.go
@@ -1345,7 +1345,7 @@ func (c *OpenChannel) MarkBorked() error {
 }
 
 // SecondCommitmentPoint returns the second per-commitment-point for use in the
-// channel_ready message.
+// funding_locked message.
 func (c *OpenChannel) SecondCommitmentPoint() (*btcec.PublicKey, error) {
 	c.RLock()
 	defer c.RUnlock()
@@ -3770,7 +3770,7 @@ func putChanRevocationState(chanBucket kvdb.RwBucket, channel *OpenChannel) erro
 	// TODO(roasbeef): don't keep producer on disk
 
 	// If the next revocation is present, which is only the case after the
-	// ChannelReady message has been sent, then we'll write it to disk.
+	// FundingLocked message has been sent, then we'll write it to disk.
 	if channel.RemoteNextRevocation != nil {
 		err = WriteElements(&b, channel.RemoteNextRevocation)
 		if err != nil {
diff --git a/docs/release-notes/release-notes-0.16.1.md b/docs/release-notes/release-notes-0.16.1.md
index 3cd4890d5..dbac5088a 100644
--- a/docs/release-notes/release-notes-0.16.1.md
+++ b/docs/release-notes/release-notes-0.16.1.md
@@ -14,8 +14,6 @@
 
 ## Watchtowers
 
-* [Fix Address iterator 
-  panic](https://github.com/lightningnetwork/lnd/pull/7556)
 * [Allow caller to filter sessions at the time of reading them from 
   disk](https://github.com/lightningnetwork/lnd/pull/7059)
 * [Clean up sessions once all channels for which they have updates for are
@@ -25,8 +23,10 @@
   needed](https://github.com/lightningnetwork/lnd/pull/7405). Also add a new
   `exclude_exhausted_sessions` boolean flag to the relevant lncli wtclient
   commands.
-* [Recover from StateUpdateCodeClientBehind 
-  error](https://github.com/lightningnetwork/lnd/pull/7541) after data loss. 
+
+## Build
+* [ldflags were being incorrectly passed](
+https://github.com/lightningnetwork/lnd/pull/7359)
 
 ## Misc
 
@@ -40,22 +40,10 @@
 
 ## RPC
 
-* A [debug log](https://github.com/lightningnetwork/lnd/pull/7514) has been
+- A [debug log](https://github.com/lightningnetwork/lnd/pull/7514) has been
   added to `lnrpc` so the node operator can know whether a certain request has
   happened or not.
 
-* Message `funding_locked` [has been
-  renamed](https://github.com/lightningnetwork/lnd/pull/7517) to
-  `channel_ready` internally to match the specs update. This should not change
-  anything for the users since the message type(36) stays unchanged, except in
-  the logging all the appearance of `funding_locked` replated experssion is
-  replaced with `channel_ready`.
-## Bug Fixes
-
-* [Fix a bug where lnd crashes when psbt data is not fully 
-available](https://github.com/lightningnetwork/lnd/pull/7529).
-
-
 # Contributors (Alphabetical Order)
 
 * ardevd
@@ -63,4 +51,3 @@ available](https://github.com/lightningnetwork/lnd/pull/7529).
 * Oliver Gugger
 * Tommy Volk
 * Yong Yu
-* ziggie1984
\ No newline at end of file
diff --git a/funding/config_integration.go b/funding/config_integration.go
index f032a3338..06bb6e173 100644
--- a/funding/config_integration.go
+++ b/funding/config_integration.go
@@ -7,5 +7,5 @@ import "time"
 func init() {
 	// For itest, we will use a much shorter checking interval here as
 	// local communications are very fast.
-	checkPeerChannelReadyInterval = 10 * time.Millisecond
+	checkPeerFundingLockInterval = 10 * time.Millisecond
 }
diff --git a/funding/interfaces.go b/funding/interfaces.go
index b87705424..09270d149 100644
--- a/funding/interfaces.go
+++ b/funding/interfaces.go
@@ -23,15 +23,15 @@ type Controller interface {
 // aliasHandler is an interface that abstracts the managing of aliases.
 type aliasHandler interface {
 	// RequestAlias lets the funding manager request a unique SCID alias to
-	// use in the channel_ready message.
+	// use in the funding_locked message.
 	RequestAlias() (lnwire.ShortChannelID, error)
 
 	// PutPeerAlias lets the funding manager store the received alias SCID
-	// in the channel_ready message.
+	// in the funding_locked message.
 	PutPeerAlias(lnwire.ChannelID, lnwire.ShortChannelID) error
 
 	// GetPeerAlias lets the funding manager lookup the received alias SCID
-	// from the channel_ready message. This is not the same as GetAliases
+	// from the funding_locked message. This is not the same as GetAliases
 	// which retrieves OUR aliases for a given channel.
 	GetPeerAlias(lnwire.ChannelID) (lnwire.ShortChannelID, error)
 
diff --git a/funding/manager.go b/funding/manager.go
index 83c9a1d21..2d702ba48 100644
--- a/funding/manager.go
+++ b/funding/manager.go
@@ -40,12 +40,12 @@ var (
 	// buffers.
 	byteOrder = binary.BigEndian
 
-	// checkPeerChannelReadyInterval is used when we are waiting for the
-	// peer to send us ChannelReady. We will check every 1 second to see
+	// checkPeerFundingLockInterval is used when we are waiting for the
+	// peer to send us FundingLocked. We will check every 1 second to see
 	// if the message is received.
 	//
 	// NOTE: for itest, this value is changed to 10ms.
-	checkPeerChannelReadyInterval = 1 * time.Second
+	checkPeerFundingLockInterval = 1 * time.Second
 )
 
 // WriteOutpoint writes an outpoint to an io.Writer. This is not the same as
@@ -377,7 +377,7 @@ type Config struct {
 
 	// NotifyWhenOnline allows the FundingManager to register with a
 	// subsystem that will notify it when the peer comes online. This is
-	// used when sending the channelReady message, since it MUST be
+	// used when sending the fundingLocked message, since it MUST be
 	// delivered after the funding transaction is confirmed.
 	//
 	// NOTE: The peerChan channel must be buffered.
@@ -570,8 +570,8 @@ type Manager struct {
 	localDiscoveryMtx     sync.Mutex
 	localDiscoverySignals map[lnwire.ChannelID]chan struct{}
 
-	handleChannelReadyMtx      sync.RWMutex
-	handleChannelReadyBarriers map[lnwire.ChannelID]struct{}
+	handleFundingLockedMtx      sync.RWMutex
+	handleFundingLockedBarriers map[lnwire.ChannelID]struct{}
 
 	quit chan struct{}
 	wg   sync.WaitGroup
@@ -584,18 +584,18 @@ type channelOpeningState uint8
 
 const (
 	// markedOpen is the opening state of a channel if the funding
-	// transaction is confirmed on-chain, but channelReady is not yet
+	// transaction is confirmed on-chain, but fundingLocked is not yet
 	// successfully sent to the other peer.
 	markedOpen channelOpeningState = iota
 
-	// channelReadySent is the opening state of a channel if the
-	// channelReady message has successfully been sent to the other peer,
+	// fundingLockedSent is the opening state of a channel if the
+	// fundingLocked message has successfully been sent to the other peer,
 	// but we still haven't announced the channel to the network.
-	channelReadySent
+	fundingLockedSent
 
 	// addedToRouterGraph is the opening state of a channel if the
 	// channel has been successfully added to the router graph
-	// immediately after the channelReady message has been sent, but
+	// immediately after the fundingLocked message has been sent, but
 	// we still haven't announced the channel to the network.
 	addedToRouterGraph
 )
@@ -604,8 +604,8 @@ func (c channelOpeningState) String() string {
 	switch c {
 	case markedOpen:
 		return "markedOpen"
-	case channelReadySent:
-		return "channelReady"
+	case fundingLockedSent:
+		return "fundingLocked"
 	case addedToRouterGraph:
 		return "addedToRouterGraph"
 	default:
@@ -617,30 +617,16 @@ func (c channelOpeningState) String() string {
 // fundingManager.
 func NewFundingManager(cfg Config) (*Manager, error) {
 	return &Manager{
-		cfg:       &cfg,
-		chanIDKey: cfg.TempChanIDSeed,
-		activeReservations: make(
-			map[serializedPubKey]pendingChannels,
-		),
-		signedReservations: make(
-			map[lnwire.ChannelID][32]byte,
-		),
-		newChanBarriers: make(
-			map[lnwire.ChannelID]chan struct{},
-		),
-		fundingMsgs: make(
-			chan *fundingMsg, msgBufferSize,
-		),
-		fundingRequests: make(
-			chan *InitFundingMsg, msgBufferSize,
-		),
-		localDiscoverySignals: make(
-			map[lnwire.ChannelID]chan struct{},
-		),
-		handleChannelReadyBarriers: make(
-			map[lnwire.ChannelID]struct{},
-		),
-		quit: make(chan struct{}),
+		cfg:                         &cfg,
+		chanIDKey:                   cfg.TempChanIDSeed,
+		activeReservations:          make(map[serializedPubKey]pendingChannels),
+		signedReservations:          make(map[lnwire.ChannelID][32]byte),
+		newChanBarriers:             make(map[lnwire.ChannelID]chan struct{}),
+		fundingMsgs:                 make(chan *fundingMsg, msgBufferSize),
+		fundingRequests:             make(chan *InitFundingMsg, msgBufferSize),
+		localDiscoverySignals:       make(map[lnwire.ChannelID]chan struct{}),
+		handleFundingLockedBarriers: make(map[lnwire.ChannelID]struct{}),
+		quit:                        make(chan struct{}),
 	}, nil
 }
 
@@ -903,9 +889,9 @@ func (f *Manager) reservationCoordinator() {
 			case *lnwire.FundingSigned:
 				f.handleFundingSigned(fmsg.peer, msg)
 
-			case *lnwire.ChannelReady:
+			case *lnwire.FundingLocked:
 				f.wg.Add(1)
-				go f.handleChannelReady(fmsg.peer, msg)
+				go f.handleFundingLocked(fmsg.peer, msg)
 
 			case *lnwire.Warning:
 				f.handleWarningMsg(fmsg.peer, msg)
@@ -1014,38 +1000,38 @@ func (f *Manager) stateStep(channel *channeldb.OpenChannel,
 
 	switch channelState {
 	// The funding transaction was confirmed, but we did not successfully
-	// send the channelReady message to the peer, so let's do that now.
+	// send the fundingLocked message to the peer, so let's do that now.
 	case markedOpen:
-		err := f.sendChannelReady(channel, lnChannel)
+		err := f.sendFundingLocked(channel, lnChannel)
 		if err != nil {
-			return fmt.Errorf("failed sending channelReady: %v",
+			return fmt.Errorf("failed sending fundingLocked: %v",
 				err)
 		}
 
-		// As the channelReady message is now sent to the peer, the
+		// As the fundingLocked message is now sent to the peer, the
 		// channel is moved to the next state of the state machine. It
 		// will be moved to the last state (actually deleted from the
 		// database) after the channel is finally announced.
 		err = f.saveChannelOpeningState(
-			&channel.FundingOutpoint, channelReadySent,
+			&channel.FundingOutpoint, fundingLockedSent,
 			shortChanID,
 		)
 		if err != nil {
 			return fmt.Errorf("error setting channel state to"+
-				" channelReadySent: %v", err)
+				" fundingLockedSent: %v", err)
 		}
 
 		log.Debugf("Channel(%v) with ShortChanID %v: successfully "+
-			"sent ChannelReady", chanID, shortChanID)
+			"sent FundingLocked", chanID, shortChanID)
 
 		return nil
 
-	// channelReady was sent to peer, but the channel was not added to the
+	// fundingLocked was sent to peer, but the channel was not added to the
 	// router graph and the channel announcement was not sent.
-	case channelReadySent:
+	case fundingLockedSent:
 		// We must wait until we've received the peer's funding locked
 		// before sending a channel_update according to BOLT#07.
-		received, err := f.receivedChannelReady(
+		received, err := f.receivedFundingLocked(
 			channel.IdentityPub, chanID,
 		)
 		if err != nil {
@@ -1054,11 +1040,11 @@ func (f *Manager) stateStep(channel *channeldb.OpenChannel,
 		}
 
 		if !received {
-			// We haven't received ChannelReady, so we'll continue
+			// We haven't received FundingLocked, so we'll continue
 			// to the next iteration of the loop after sleeping for
-			// checkPeerChannelReadyInterval.
+			// checkPeerFundingLockInterval.
 			select {
-			case <-time.After(checkPeerChannelReadyInterval):
+			case <-time.After(checkPeerFundingLockInterval):
 			case <-f.quit:
 				return ErrFundingManagerShuttingDown
 			}
@@ -1068,7 +1054,7 @@ func (f *Manager) stateStep(channel *channeldb.OpenChannel,
 
 		var peerAlias *lnwire.ShortChannelID
 		if channel.IsZeroConf() {
-			// We'll need to wait until channel_ready has been
+			// We'll need to wait until funding_locked has been
 			// received and the peer lets us know the alias they
 			// want to use for the channel. With this information,
 			// we can then construct a ChannelUpdate for them.
@@ -1227,7 +1213,7 @@ func (f *Manager) advancePendingChannelState(
 		f.cfg.NotifyOpenChannelEvent(channel.FundingOutpoint)
 
 		// Find and close the discoverySignal for this channel such
-		// that ChannelReady messages will be processed.
+		// that FundingLocked messages will be processed.
 		chanID := lnwire.NewChanIDFromOutPoint(
 			&channel.FundingOutpoint,
 		)
@@ -2904,10 +2890,10 @@ func (f *Manager) handleFundingConfirmation(
 	return nil
 }
 
-// sendChannelReady creates and sends the channelReady message.
+// sendFundingLocked creates and sends the fundingLocked message.
 // This should be called after the funding transaction has been confirmed,
 // and the channelState is 'markedOpen'.
-func (f *Manager) sendChannelReady(completeChan *channeldb.OpenChannel,
+func (f *Manager) sendFundingLocked(completeChan *channeldb.OpenChannel,
 	channel *lnwallet.LightningChannel) error {
 
 	chanID := lnwire.NewChanIDFromOutPoint(&completeChan.FundingOutpoint)
@@ -2923,7 +2909,7 @@ func (f *Manager) sendChannelReady(completeChan *channeldb.OpenChannel,
 	if err != nil {
 		return fmt.Errorf("unable to create next revocation: %v", err)
 	}
-	channelReadyMsg := lnwire.NewChannelReady(chanID, nextRevocation)
+	fundingLockedMsg := lnwire.NewFundingLocked(chanID, nextRevocation)
 
 	// If the channel negotiated the option-scid-alias feature bit, we'll
 	// send a TLV segment that includes an alias the peer can use in their
@@ -2940,19 +2926,19 @@ func (f *Manager) sendChannelReady(completeChan *channeldb.OpenChannel,
 
 		// We can use a pointer to aliases since GetAliases returns a
 		// copy of the alias slice.
-		channelReadyMsg.AliasScid = &aliases[0]
+		fundingLockedMsg.AliasScid = &aliases[0]
 	}
 
 	// If the peer has disconnected before we reach this point, we will need
-	// to wait for him to come back online before sending the channelReady
-	// message. This is special for channelReady, since failing to send any
+	// to wait for him to come back online before sending the fundingLocked
+	// message. This is special for fundingLocked, since failing to send any
 	// of the previous messages in the funding flow just cancels the flow.
 	// But now the funding transaction is confirmed, the channel is open
-	// and we have to make sure the peer gets the channelReady message when
+	// and we have to make sure the peer gets the fundingLocked message when
 	// it comes back online. This is also crucial during restart of lnd,
-	// where we might try to resend the channelReady message before the
+	// where we might try to resend the fundingLocked message before the
 	// server has had the time to connect to the peer. We keep trying to
-	// send channelReady until we succeed, or the fundingManager is shut
+	// send fundingLocked until we succeed, or the fundingManager is shut
 	// down.
 	for {
 		peer, err := f.waitForPeerOnline(completeChan.IdentityPub)
@@ -2970,14 +2956,14 @@ func (f *Manager) sendChannelReady(completeChan *channeldb.OpenChannel,
 		// We could also refresh the channel state instead of checking
 		// whether the feature was negotiated, but this saves us a
 		// database read.
-		if channelReadyMsg.AliasScid == nil && localAlias &&
+		if fundingLockedMsg.AliasScid == nil && localAlias &&
 			remoteAlias {
 
 			// If an alias was not assigned above and the scid
 			// alias feature was negotiated, check if we already
-			// have an alias stored in case handleChannelReady was
+			// have an alias stored in case handleFundingLocked was
 			// called before this. If an alias exists, use that in
-			// channel_ready. Otherwise, request and store an
+			// funding_locked. Otherwise, request and store an
 			// alias and use that.
 			aliases := f.cfg.AliasManager.GetAliases(
 				completeChan.ShortChannelID,
@@ -2997,31 +2983,31 @@ func (f *Manager) sendChannelReady(completeChan *channeldb.OpenChannel,
 					return err
 				}
 
-				channelReadyMsg.AliasScid = &alias
+				fundingLockedMsg.AliasScid = &alias
 			} else {
-				channelReadyMsg.AliasScid = &aliases[0]
+				fundingLockedMsg.AliasScid = &aliases[0]
 			}
 		}
 
-		log.Infof("Peer(%x) is online, sending ChannelReady "+
+		log.Infof("Peer(%x) is online, sending FundingLocked "+
 			"for ChannelID(%v)", peerKey, chanID)
 
-		if err := peer.SendMessage(true, channelReadyMsg); err == nil {
+		if err := peer.SendMessage(true, fundingLockedMsg); err == nil {
 			// Sending succeeded, we can break out and continue the
 			// funding flow.
 			break
 		}
 
-		log.Warnf("Unable to send channelReady to peer %x: %v. "+
+		log.Warnf("Unable to send fundingLocked to peer %x: %v. "+
 			"Will retry when online", peerKey, err)
 	}
 
 	return nil
 }
 
-// receivedChannelReady checks whether or not we've received a ChannelReady
+// receivedFundingLocked checks whether or not we've received a FundingLocked
 // from the remote peer. If we have, RemoteNextRevocation will be set.
-func (f *Manager) receivedChannelReady(node *btcec.PublicKey,
+func (f *Manager) receivedFundingLocked(node *btcec.PublicKey,
 	chanID lnwire.ChannelID) (bool, error) {
 
 	// If the funding manager has exited, return an error to stop looping.
@@ -3042,7 +3028,7 @@ func (f *Manager) receivedChannelReady(node *btcec.PublicKey,
 	channel, err := f.cfg.FindChannel(node, chanID)
 	if err != nil {
 		log.Errorf("Unable to locate ChannelID(%v) to determine if "+
-			"ChannelReady was received", chanID)
+			"FundingLocked was received", chanID)
 		return false, err
 	}
 
@@ -3154,7 +3140,7 @@ func (f *Manager) addToRouterGraph(completeChan *channeldb.OpenChannel,
 }
 
 // annAfterSixConfs broadcasts the necessary channel announcement messages to
-// the network after 6 confs. Should be called after the channelReady message
+// the network after 6 confs. Should be called after the fundingLocked message
 // is sent and the channel is added to the router graph (channelState is
 // 'addedToRouterGraph') and the channel is ready to be used. This is the last
 // step in the channel opening process, and the opening state will be deleted
@@ -3405,36 +3391,36 @@ func (f *Manager) waitForZeroConfChannel(c *channeldb.OpenChannel,
 	return nil
 }
 
-// handleChannelReady finalizes the channel funding process and enables the
+// handleFundingLocked finalizes the channel funding process and enables the
 // channel to enter normal operating mode.
-func (f *Manager) handleChannelReady(peer lnpeer.Peer,
-	msg *lnwire.ChannelReady) {
+func (f *Manager) handleFundingLocked(peer lnpeer.Peer,
+	msg *lnwire.FundingLocked) {
 
 	defer f.wg.Done()
-	log.Debugf("Received ChannelReady for ChannelID(%v) from "+
+	log.Debugf("Received FundingLocked for ChannelID(%v) from "+
 		"peer %x", msg.ChanID,
 		peer.IdentityKey().SerializeCompressed())
 
 	// If we are currently in the process of handling a funding locked
 	// message for this channel, ignore.
-	f.handleChannelReadyMtx.Lock()
-	_, ok := f.handleChannelReadyBarriers[msg.ChanID]
+	f.handleFundingLockedMtx.Lock()
+	_, ok := f.handleFundingLockedBarriers[msg.ChanID]
 	if ok {
-		log.Infof("Already handling channelReady for "+
+		log.Infof("Already handling fundingLocked for "+
 			"ChannelID(%v), ignoring.", msg.ChanID)
-		f.handleChannelReadyMtx.Unlock()
+		f.handleFundingLockedMtx.Unlock()
 		return
 	}
 
-	// If not already handling channelReady for this channel, set up
+	// If not already handling fundingLocked for this channel, set up
 	// barrier, and move on.
-	f.handleChannelReadyBarriers[msg.ChanID] = struct{}{}
-	f.handleChannelReadyMtx.Unlock()
+	f.handleFundingLockedBarriers[msg.ChanID] = struct{}{}
+	f.handleFundingLockedMtx.Unlock()
 
 	defer func() {
-		f.handleChannelReadyMtx.Lock()
-		delete(f.handleChannelReadyBarriers, msg.ChanID)
-		f.handleChannelReadyMtx.Unlock()
+		f.handleFundingLockedMtx.Lock()
+		delete(f.handleFundingLockedBarriers, msg.ChanID)
+		f.handleFundingLockedMtx.Unlock()
 	}()
 
 	f.localDiscoveryMtx.Lock()
@@ -3478,7 +3464,7 @@ func (f *Manager) handleChannelReady(peer lnpeer.Peer,
 	// during invoice creation. In the zero-conf case, it is also used to
 	// provide a ChannelUpdate to the remote peer. This is done before the
 	// call to InsertNextRevocation in case the call to PutPeerAlias fails.
-	// If it were to fail on the first call to handleChannelReady, we
+	// If it were to fail on the first call to handleFundingLocked, we
 	// wouldn't want the channel to be usable yet.
 	if channel.NegotiatedAliasFeature() {
 		// If the AliasScid field is nil, we must fail out. We will
@@ -3501,14 +3487,14 @@ func (f *Manager) handleChannelReady(peer lnpeer.Peer,
 		// If we do not have an alias stored, we'll create one now.
 		// This is only used in the upgrade case where a user toggles
 		// the option-scid-alias feature-bit to on. We'll also send the
-		// channel_ready message here in case the link is created
-		// before sendChannelReady is called.
+		// funding_locked message here in case the link is created
+		// before sendFundingLocked is called.
 		aliases := f.cfg.AliasManager.GetAliases(
 			channel.ShortChannelID,
 		)
 		if len(aliases) == 0 {
 			// No aliases were found so we'll request and store an
-			// alias and use it in the channel_ready message.
+			// alias and use it in the funding_locked message.
 			alias, err := f.cfg.AliasManager.RequestAlias()
 			if err != nil {
 				log.Errorf("unable to request alias: %v", err)
@@ -3531,12 +3517,12 @@ func (f *Manager) handleChannelReady(peer lnpeer.Peer,
 				return
 			}
 
-			channelReadyMsg := lnwire.NewChannelReady(
+			fundingLockedMsg := lnwire.NewFundingLocked(
 				chanID, secondPoint,
 			)
-			channelReadyMsg.AliasScid = &alias
+			fundingLockedMsg.AliasScid = &alias
 
-			err = peer.SendMessage(true, channelReadyMsg)
+			err = peer.SendMessage(true, fundingLockedMsg)
 			if err != nil {
 				log.Errorf("unable to send funding locked: %v",
 					err)
@@ -3546,16 +3532,16 @@ func (f *Manager) handleChannelReady(peer lnpeer.Peer,
 	}
 
 	// If the RemoteNextRevocation is non-nil, it means that we have
-	// already processed channelReady for this channel, so ignore. This
+	// already processed fundingLocked for this channel, so ignore. This
 	// check is after the alias logic so we store the peer's most recent
 	// alias. The spec requires us to validate that subsequent
-	// channel_ready messages use the same per commitment point (the
+	// funding_locked messages use the same per commitment point (the
 	// second), but it is not actually necessary since we'll just end up
 	// ignoring it. We are, however, required to *send* the same per
 	// commitment point, since another pedantic implementation might
 	// verify it.
 	if channel.RemoteNextRevocation != nil {
-		log.Infof("Received duplicate channelReady for "+
+		log.Infof("Received duplicate fundingLocked for "+
 			"ChannelID(%v), ignoring.", chanID)
 		return
 	}
diff --git a/go.mod b/go.mod
index 23369d21e..e3b587250 100644
--- a/go.mod
+++ b/go.mod
@@ -6,10 +6,10 @@ require (
 	github.com/btcsuite/btcd v0.23.5-0.20230125025938-be056b0a0b2f
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2
 	github.com/btcsuite/btcd/btcutil v1.1.3
-	github.com/btcsuite/btcd/btcutil/psbt v1.1.8
+	github.com/btcsuite/btcd/btcutil/psbt v1.1.5
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2
 	github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f
-	github.com/btcsuite/btcwallet v0.16.8-0.20230324081040-520f650ce045
+	github.com/btcsuite/btcwallet v0.16.7
 	github.com/btcsuite/btcwallet/wallet/txauthor v1.3.2
 	github.com/btcsuite/btcwallet/wallet/txrules v1.2.0
 	github.com/btcsuite/btcwallet/walletdb v1.4.0
@@ -52,8 +52,9 @@ require (
 	go.etcd.io/etcd/client/v3 v3.5.7
 	golang.org/x/crypto v0.1.0
 	golang.org/x/exp v0.0.0-20221111094246-ab4555d3164f
+	golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028
 	golang.org/x/net v0.4.0
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde
 	golang.org/x/term v0.3.0
 	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba
 	google.golang.org/grpc v1.41.0
diff --git a/go.sum b/go.sum
index e26b250c1..4d8c21e8d 100644
--- a/go.sum
+++ b/go.sum
@@ -80,8 +80,8 @@ github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUB
 github.com/btcsuite/btcd/btcutil v1.1.1/go.mod h1:nbKlBMNm9FGsdvKvu0essceubPiAcI57pYBNnsLAa34=
 github.com/btcsuite/btcd/btcutil v1.1.3 h1:xfbtw8lwpp0G6NwSHb+UE67ryTFHJAiNuipusjXSohQ=
 github.com/btcsuite/btcd/btcutil v1.1.3/go.mod h1:UR7dsSJzJUfMmFiiLlIrMq1lS9jh9EdCV7FStZSnpi0=
-github.com/btcsuite/btcd/btcutil/psbt v1.1.8 h1:4voqtT8UppT7nmKQkXV+T9K8UyQjKOn2z/ycpmJK8wg=
-github.com/btcsuite/btcd/btcutil/psbt v1.1.8/go.mod h1:kA6FLH/JfUx++j9pYU0pyu+Z8XGBQuuTmuKYUf6q7/U=
+github.com/btcsuite/btcd/btcutil/psbt v1.1.5 h1:x0ZRrYY8j75ThV6xBz86CkYAG82F5bzay4H5D1c8b/U=
+github.com/btcsuite/btcd/btcutil/psbt v1.1.5/go.mod h1:kA6FLH/JfUx++j9pYU0pyu+Z8XGBQuuTmuKYUf6q7/U=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM=
@@ -89,8 +89,8 @@ github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtyd
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
-github.com/btcsuite/btcwallet v0.16.8-0.20230324081040-520f650ce045 h1:302lmdYbONzrLACkm9IlCobMYuYOjF8to+tUhaQsTzc=
-github.com/btcsuite/btcwallet v0.16.8-0.20230324081040-520f650ce045/go.mod h1:WBcb0CNEgzjF2EdatcERzG7cd/lhHXtNJ4VjIePOdXM=
+github.com/btcsuite/btcwallet v0.16.7 h1:J6nBMMMc90n77/4QIfzRFn5XB1hPvMDfcgX5U6Ls0kI=
+github.com/btcsuite/btcwallet v0.16.7/go.mod h1:J/q3/JxytAcuqR+zSTCRZ5K+0LtMuhxtCjLVXKDHBu0=
 github.com/btcsuite/btcwallet/wallet/txauthor v1.3.2 h1:etuLgGEojecsDOYTII8rYiGHjGyV5xTqsXi+ZQ715UU=
 github.com/btcsuite/btcwallet/wallet/txauthor v1.3.2/go.mod h1:Zpk/LOb2sKqwP2lmHjaZT9AdaKsHPSbNLm2Uql5IQ/0=
 github.com/btcsuite/btcwallet/wallet/txrules v1.2.0 h1:BtEN5Empw62/RVnZ0VcJaVtVlBijnLlJY+dwjAye2Bg=
@@ -654,6 +654,7 @@ golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPI
 golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028 h1:4+4C/Iv2U4fMZBiMCc98MG1In4gJY5YRhtpDNeDeHWs=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
@@ -721,8 +722,9 @@ golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde h1:ejfdSekXMDxDLbRrJMwUk6KnSLZ2McaUCVcIKM+N6jc=
+golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180816055513-1c9583448a9c/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
diff --git a/htlcswitch/link.go b/htlcswitch/link.go
index d2dfc20ab..335ec351f 100644
--- a/htlcswitch/link.go
+++ b/htlcswitch/link.go
@@ -724,12 +724,12 @@ func (l *channelLink) syncChanStates() error {
 		// done any state updates yet, then we'll retransmit the
 		// funding locked message first. We do this, as at this point
 		// we can't be sure if they've really received the
-		// ChannelReady message.
+		// FundingLocked message.
 		if remoteChanSyncMsg.NextLocalCommitHeight == 1 &&
 			localChanSyncMsg.NextLocalCommitHeight == 1 &&
 			!l.channel.IsPending() {
 
-			l.log.Infof("resending ChannelReady message to peer")
+			l.log.Infof("resending FundingLocked message to peer")
 
 			nextRevocation, err := l.channel.NextRevocationKey()
 			if err != nil {
@@ -737,13 +737,13 @@ func (l *channelLink) syncChanStates() error {
 					"revocation: %v", err)
 			}
 
-			channelReadyMsg := lnwire.NewChannelReady(
+			fundingLockedMsg := lnwire.NewFundingLocked(
 				l.ChanID(), nextRevocation,
 			)
 
 			// For channels that negotiated the option-scid-alias
 			// feature bit, ensure that we send over the alias in
-			// the channel_ready message. We'll send the first
+			// the funding_locked message. We'll send the first
 			// alias we find for the channel since it does not
 			// matter which alias we send. We'll error out if no
 			// aliases are found.
@@ -759,13 +759,13 @@ func (l *channelLink) syncChanStates() error {
 				// getAliases returns a copy of the alias slice
 				// so it is ok to use a pointer to the first
 				// entry.
-				channelReadyMsg.AliasScid = &aliases[0]
+				fundingLockedMsg.AliasScid = &aliases[0]
 			}
 
-			err = l.cfg.Peer.SendMessage(false, channelReadyMsg)
+			err = l.cfg.Peer.SendMessage(false, fundingLockedMsg)
 			if err != nil {
 				return fmt.Errorf("unable to re-send "+
-					"ChannelReady: %v", err)
+					"FundingLocked: %v", err)
 			}
 		}
 
diff --git a/htlcswitch/mock.go b/htlcswitch/mock.go
index cec170a35..866e7d36f 100644
--- a/htlcswitch/mock.go
+++ b/htlcswitch/mock.go
@@ -627,7 +627,7 @@ func (s *mockServer) readHandler(message lnwire.Message) error {
 		targetChan = msg.ChanID
 	case *lnwire.CommitSig:
 		targetChan = msg.ChanID
-	case *lnwire.ChannelReady:
+	case *lnwire.FundingLocked:
 		// Ignore
 		return nil
 	case *lnwire.ChannelReestablish:
diff --git a/lnwallet/btcwallet/psbt.go b/lnwallet/btcwallet/psbt.go
index 395c5667c..7dbe12c2b 100644
--- a/lnwallet/btcwallet/psbt.go
+++ b/lnwallet/btcwallet/psbt.go
@@ -135,9 +135,8 @@ func (b *BtcWallet) SignPsbt(packet *psbt.Packet) ([]uint32, error) {
 	var signedInputs []uint32
 
 	// Let's check that this is actually something we can and want to sign.
-	// We need at least one input and one output. In addition each
-	// input needs nonWitness Utxo or witness Utxo data specified.
-	err := psbt.InputsReadyToSign(packet)
+	// We need at least one input and one output.
+	err := psbt.VerifyInputOutputLen(packet, true, true)
 	if err != nil {
 		return nil, err
 	}
diff --git a/lnwallet/channel.go b/lnwallet/channel.go
index d715d5ed6..97b7ac44d 100644
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@@ -4063,7 +4063,7 @@ func (lc *LightningChannel) ProcessChanSyncMsg(
 
 			// If we get a failure due to not knowing their next
 			// point, then this is fine as they'll either send
-			// ChannelReady, or revoke their next state to allow
+			// FundingLocked, or revoke their next state to allow
 			// us to continue forwards.
 			case err == ErrNoWindow:
 
@@ -7220,7 +7220,7 @@ func (lc *LightningChannel) generateRevocation(height uint64) (*lnwire.RevokeAnd
 	// Along with this revocation, we'll also send the _next_ commitment
 	// point that the remote party should use to create our next commitment
 	// transaction. We use a +2 here as we already gave them a look ahead
-	// of size one after the ChannelReady message was sent:
+	// of size one after the FundingLocked message was sent:
 	//
 	// 0: current revocation, 1: their "next" revocation, 2: this revocation
 	//
diff --git a/lnwallet/rpcwallet/rpcwallet.go b/lnwallet/rpcwallet/rpcwallet.go
index 536ce6260..38f345c14 100644
--- a/lnwallet/rpcwallet/rpcwallet.go
+++ b/lnwallet/rpcwallet/rpcwallet.go
@@ -255,9 +255,8 @@ func (r *RPCKeyRing) SignPsbt(packet *psbt.Packet) ([]uint32, error) {
 // parameter in FinalizePsbt so we can get rid of this code duplication.
 func (r *RPCKeyRing) FinalizePsbt(packet *psbt.Packet, _ string) error {
 	// Let's check that this is actually something we can and want to sign.
-	// We need at least one input and one output. In addition each
-	// input needs nonWitness Utxo or witness Utxo data specified.
-	err := psbt.InputsReadyToSign(packet)
+	// We need at least one input and one output.
+	err := psbt.VerifyInputOutputLen(packet, true, true)
 	if err != nil {
 		return err
 	}
diff --git a/lnwire/features.go b/lnwire/features.go
index 76dab3b05..c386fd37b 100644
--- a/lnwire/features.go
+++ b/lnwire/features.go
@@ -169,12 +169,12 @@ const (
 
 	// ScidAliasRequired is a required feature bit that signals that the
 	// node requires understanding of ShortChannelID aliases in the TLV
-	// segment of the channel_ready message.
+	// segment of the funding_locked message.
 	ScidAliasRequired FeatureBit = 46
 
 	// ScidAliasOptional is an optional feature bit that signals that the
 	// node understands ShortChannelID aliases in the TLV segment of the
-	// channel_ready message.
+	// funding_locked message.
 	ScidAliasOptional FeatureBit = 47
 
 	// PaymentMetadataRequired is a required bit that denotes that if an
diff --git a/lnwire/channel_ready.go b/lnwire/funding_locked.go
similarity index 73%
rename from lnwire/channel_ready.go
rename to lnwire/funding_locked.go
index 9027997de..fb47356ba 100644
--- a/lnwire/channel_ready.go
+++ b/lnwire/funding_locked.go
@@ -8,12 +8,12 @@ import (
 	"github.com/lightningnetwork/lnd/tlv"
 )
 
-// ChannelReady is the message that both parties to a new channel creation
+// FundingLocked is the message that both parties to a new channel creation
 // send once they have observed the funding transaction being confirmed on the
-// blockchain. ChannelReady contains the signatures necessary for the channel
+// blockchain. FundingLocked contains the signatures necessary for the channel
 // participants to advertise the existence of the channel to the rest of the
 // network.
-type ChannelReady struct {
+type FundingLocked struct {
 	// ChanID is the outpoint of the channel's funding transaction. This
 	// can be used to query for the channel in the database.
 	ChanID ChannelID
@@ -33,26 +33,26 @@ type ChannelReady struct {
 	ExtraData ExtraOpaqueData
 }
 
-// NewChannelReady creates a new ChannelReady message, populating it with the
+// NewFundingLocked creates a new FundingLocked message, populating it with the
 // necessary IDs and revocation secret.
-func NewChannelReady(cid ChannelID, npcp *btcec.PublicKey) *ChannelReady {
-	return &ChannelReady{
+func NewFundingLocked(cid ChannelID, npcp *btcec.PublicKey) *FundingLocked {
+	return &FundingLocked{
 		ChanID:                 cid,
 		NextPerCommitmentPoint: npcp,
 		ExtraData:              make([]byte, 0),
 	}
 }
 
-// A compile time check to ensure ChannelReady implements the lnwire.Message
+// A compile time check to ensure FundingLocked implements the lnwire.Message
 // interface.
-var _ Message = (*ChannelReady)(nil)
+var _ Message = (*FundingLocked)(nil)
 
-// Decode deserializes the serialized ChannelReady message stored in the
-// passed io.Reader into the target ChannelReady using the deserialization
+// Decode deserializes the serialized FundingLocked message stored in the
+// passed io.Reader into the target FundingLocked using the deserialization
 // rules defined by the passed protocol version.
 //
 // This is part of the lnwire.Message interface.
-func (c *ChannelReady) Decode(r io.Reader, pver uint32) error {
+func (c *FundingLocked) Decode(r io.Reader, pver uint32) error {
 	// Read all the mandatory fields in the message.
 	err := ReadElements(r,
 		&c.ChanID,
@@ -80,12 +80,12 @@ func (c *ChannelReady) Decode(r io.Reader, pver uint32) error {
 	return nil
 }
 
-// Encode serializes the target ChannelReady message into the passed io.Writer
+// Encode serializes the target FundingLocked message into the passed io.Writer
 // implementation. Serialization will observe the rules defined by the passed
 // protocol version.
 //
 // This is part of the lnwire.Message interface.
-func (c *ChannelReady) Encode(w *bytes.Buffer, pver uint32) error {
+func (c *FundingLocked) Encode(w *bytes.Buffer, pver uint32) error {
 	if err := WriteChannelID(w, c.ChanID); err != nil {
 		return err
 	}
@@ -107,9 +107,9 @@ func (c *ChannelReady) Encode(w *bytes.Buffer, pver uint32) error {
 }
 
 // MsgType returns the uint32 code which uniquely identifies this message as a
-// ChannelReady message on the wire.
+// FundingLocked message on the wire.
 //
 // This is part of the lnwire.Message interface.
-func (c *ChannelReady) MsgType() MessageType {
-	return MsgChannelReady
+func (c *FundingLocked) MsgType() MessageType {
+	return MsgFundingLocked
 }
diff --git a/lnwire/message.go b/lnwire/message.go
index 02447b806..2e71173e5 100644
--- a/lnwire/message.go
+++ b/lnwire/message.go
@@ -31,7 +31,7 @@ const (
 	MsgAcceptChannel                       = 33
 	MsgFundingCreated                      = 34
 	MsgFundingSigned                       = 35
-	MsgChannelReady                        = 36
+	MsgFundingLocked                       = 36
 	MsgShutdown                            = 38
 	MsgClosingSigned                       = 39
 	MsgUpdateAddHTLC                       = 128
@@ -88,8 +88,8 @@ func (t MessageType) String() string {
 		return "MsgFundingCreated"
 	case MsgFundingSigned:
 		return "MsgFundingSigned"
-	case MsgChannelReady:
-		return "ChannelReady"
+	case MsgFundingLocked:
+		return "FundingLocked"
 	case MsgShutdown:
 		return "Shutdown"
 	case MsgClosingSigned:
@@ -190,8 +190,8 @@ func makeEmptyMessage(msgType MessageType) (Message, error) {
 		msg = &FundingCreated{}
 	case MsgFundingSigned:
 		msg = &FundingSigned{}
-	case MsgChannelReady:
-		msg = &ChannelReady{}
+	case MsgFundingLocked:
+		msg = &FundingLocked{}
 	case MsgShutdown:
 		msg = &Shutdown{}
 	case MsgClosingSigned:
diff --git a/mobile/README.md b/mobile/README.md
index d30bfa9d6..4aa0d7e9d 100644
--- a/mobile/README.md
+++ b/mobile/README.md
@@ -13,16 +13,8 @@ To build for Android, you need either
 
 ### Go and Go mobile
 
-First, follow the instructions to [install Go](https://github.com/lightningnetwork/lnd/blob/master/docs/INSTALL.md#building-a-development-version-from-source).
-
-Then, install [Go mobile](https://github.com/golang/go/wiki/Mobile) and 
-initialize it:
-
-```shell
-go install golang.org/x/mobile/cmd/gomobile@latest
-go mod download golang.org/x/mobile
-gomobile init
-```
+First, follow the instructions to [install
+Go](https://github.com/lightningnetwork/lnd/blob/master/docs/INSTALL.md#building-a-development-version-from-source).
 
 ### Docker
 
@@ -42,14 +34,8 @@ Note that `gomobile` only supports building projects from `$GOPATH` at this
 point. However, with the introduction of Go modules, the source code files are 
 no longer installed there by default.
 
-To be able to do so, we must turn off module and using the now deprecated 
-`go get` command before turning modules back on again.
-
 ```shell
-go env -w GO111MODULE="off"
-go get github.com/lightningnetwork/lnd
-go get golang.org/x/mobile/bind
-go env -w GO111MODULE="on"
+git clone https://github.com/lightningnetwork/lnd.git $GOPATH/src/github.com/lightningnetwork/lnd
 ```
 
 Finally, let’s change directory to the newly created lnd folder inside `$GOPATH`:
@@ -58,13 +44,21 @@ Finally, let’s change directory to the newly created lnd folder inside `$GOPAT
 cd $GOPATH/src/github.com/lightningnetwork/lnd
 ```
 
-It is not recommended building from the master branch for mainnet. To checkout
+It is not recommended building from the master branch for mainnet. To check out
 the latest tagged release of lnd, run
 
 ```shell
 git checkout $(git describe --match "v[0-9]*" --abbrev=0)
 ```
 
+Then, install [Go mobile](https://github.com/golang/go/wiki/Mobile) and
+initialize it:
+
+```shell
+go install golang.org/x/mobile/cmd/gomobile
+gomobile init
+```
+
 ### iOS
 
 ```shell
diff --git a/mobile/bindings.go b/mobile/bindings.go
index eff63f718..e5fe5f71f 100644
--- a/mobile/bindings.go
+++ b/mobile/bindings.go
@@ -13,6 +13,7 @@ import (
 	flags "github.com/jessevdk/go-flags"
 	"github.com/lightningnetwork/lnd"
 	"github.com/lightningnetwork/lnd/signal"
+	_ "golang.org/x/mobile/bind"
 	"google.golang.org/grpc"
 )
 
diff --git a/netann/chan_status_manager.go b/netann/chan_status_manager.go
index 8340c202c..8f29888e5 100644
--- a/netann/chan_status_manager.go
+++ b/netann/chan_status_manager.go
@@ -54,7 +54,7 @@ type ChanStatusConfig struct {
 	// IsChannelActive checks whether the channel identified by the provided
 	// ChannelID is considered active. This should only return true if the
 	// channel has been sufficiently confirmed, the channel has received
-	// ChannelReady, and the remote peer is online.
+	// FundingLocked, and the remote peer is online.
 	IsChannelActive func(lnwire.ChannelID) bool
 
 	// ApplyChannelUpdate processes new ChannelUpdates signed by our node by
diff --git a/peer/brontide.go b/peer/brontide.go
index edc6c6b51..09f016851 100644
--- a/peer/brontide.go
+++ b/peer/brontide.go
@@ -717,11 +717,11 @@ func (p *Brontide) loadActiveChannels(chans []*channeldb.OpenChannel) (
 			// manager are not aware of each other's states and if
 			// we did not do this, we would accept alias channel
 			// updates after 6 confirmations, which would be buggy.
-			// We'll queue a channel_ready message with the new
+			// We'll queue a funding_locked message with the new
 			// alias. This should technically be done *after* the
 			// reestablish, but this behavior is pre-existing since
 			// the funding manager may already queue a
-			// channel_ready before the channel_reestablish.
+			// funding_locked before the channel_reestablish.
 			if !dbChan.IsPending {
 				aliasScid, err := p.cfg.RequestAlias()
 				if err != nil {
@@ -740,18 +740,18 @@ func (p *Brontide) loadActiveChannels(chans []*channeldb.OpenChannel) (
 				)
 
 				// Fetch the second commitment point to send in
-				// the channel_ready message.
+				// the funding_locked message.
 				second, err := dbChan.SecondCommitmentPoint()
 				if err != nil {
 					return nil, err
 				}
 
-				channelReadyMsg := lnwire.NewChannelReady(
+				fundingLockedMsg := lnwire.NewFundingLocked(
 					chanID, second,
 				)
-				channelReadyMsg.AliasScid = &aliasScid
+				fundingLockedMsg.AliasScid = &aliasScid
 
-				msgs = append(msgs, channelReadyMsg)
+				msgs = append(msgs, fundingLockedMsg)
 			}
 
 			// If we've negotiated the option-scid-alias feature
@@ -1549,7 +1549,7 @@ out:
 			*lnwire.AcceptChannel,
 			*lnwire.FundingCreated,
 			*lnwire.FundingSigned,
-			*lnwire.ChannelReady:
+			*lnwire.FundingLocked:
 
 			p.cfg.FundingManager.ProcessFundingMsg(msg, p)
 
@@ -1798,7 +1798,7 @@ func messageSummary(msg lnwire.Message) string {
 	case *lnwire.FundingSigned:
 		return fmt.Sprintf("chan_id=%v", msg.ChanID)
 
-	case *lnwire.ChannelReady:
+	case *lnwire.FundingLocked:
 		return fmt.Sprintf("chan_id=%v, next_point=%x",
 			msg.ChanID, msg.NextPerCommitmentPoint.SerializeCompressed())
 
@@ -2376,7 +2376,7 @@ out:
 				}
 
 				p.log.Infof("Processing retransmitted "+
-					"ChannelReady for ChannelPoint(%v)",
+					"FundingLocked for ChannelPoint(%v)",
 					chanPoint)
 
 				nextRevoke := newChan.RemoteNextRevocation
diff --git a/watchtower/wtclient/addr_iterator.go b/watchtower/wtclient/addr_iterator.go
index 5ada7d5de..cb16d335a 100644
--- a/watchtower/wtclient/addr_iterator.go
+++ b/watchtower/wtclient/addr_iterator.go
@@ -162,15 +162,7 @@ func (a *addressIterator) next(lock bool) (net.Addr, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 
-	// In-case currentTopAddr is nil (meaning that Reset has not yet been
-	// called), return an error indicating this.
-	if a.currentTopAddr == nil {
-		return nil, ErrAddressesExhausted
-	}
-
-	// Set the next candidate to the subsequent element. If we are at the
-	// end of the address list, this could mean setting currentTopAddr to
-	// nil.
+	// Set the next candidate to the subsequent element.
 	a.currentTopAddr = a.currentTopAddr.Next()
 
 	for a.currentTopAddr != nil {
@@ -180,26 +172,9 @@ func (a *addressIterator) next(lock bool) (net.Addr, error) {
 		// Check whether this address is still considered a candidate.
 		// If it's not, we'll proceed to the next.
 		candidate, ok := a.candidates[addrID]
-
-		// If the address cannot be found in the candidate set, then
-		// this must mean that the Remove method was called for the
-		// address. The Remove method would have checked that the
-		// address is not the last one in the iterator and that it has
-		// no locks on it. It is therefor safe to remove.
 		if !ok {
-			// Grab the next address candidate. This might be nil
-			// if the iterator is on the last item in the list.
 			nextCandidate := a.currentTopAddr.Next()
-
-			// Remove the address from the list that is no longer
-			// in the candidate set.
 			a.addrList.Remove(a.currentTopAddr)
-
-			// Set the current top to the next candidate. This might
-			// mean setting it to nil if the iterator is on its last
-			// item in which case the loop will be exited and an
-			// ErrAddressesExhausted exhausted error will be
-			// returned.
 			a.currentTopAddr = nextCandidate
 			continue
 		}
@@ -255,25 +230,9 @@ func (a *addressIterator) peek(lock bool) net.Addr {
 
 		addrID := a.currentTopAddr.Value.(string)
 		candidate, ok := a.candidates[addrID]
-
-		// If the address cannot be found in the candidate set, then
-		// this must mean that the Remove method was called for the
-		// address. The Remove method would have checked that the
-		// address is not the last one in the iterator and that it has
-		// no locks on it. It is therefor safe to remove.
 		if !ok {
-			// Grab the next address candidate. This might be nil
-			// if the iterator is on the last item in the list.
 			nextCandidate := a.currentTopAddr.Next()
-
-			// Remove the address from the list that is no longer
-			// in the candidate set.
 			a.addrList.Remove(a.currentTopAddr)
-
-			// Set the current top to the next candidate. This might
-			// mean setting it to nil if the iterator is on its last
-			// item but this will be reset at the top of the for
-			// loop.
 			a.currentTopAddr = nextCandidate
 			continue
 		}
diff --git a/watchtower/wtclient/candidate_iterator.go b/watchtower/wtclient/candidate_iterator.go
index 29c4719f0..10ef86465 100644
--- a/watchtower/wtclient/candidate_iterator.go
+++ b/watchtower/wtclient/candidate_iterator.go
@@ -145,7 +145,6 @@ func (t *towerListIterator) AddCandidate(candidate *Tower) {
 		for {
 			next, err := candidate.Addresses.Next()
 			if err != nil {
-				candidate.Addresses.Reset()
 				break
 			}
 
diff --git a/watchtower/wtclient/errors.go b/watchtower/wtclient/errors.go
index 2cb070ac4..c6884bb35 100644
--- a/watchtower/wtclient/errors.go
+++ b/watchtower/wtclient/errors.go
@@ -34,9 +34,4 @@ var (
 	// revoked state because the channel had not been previously registered
 	// with the client.
 	ErrUnregisteredChannel = errors.New("channel is not registered")
-
-	// ErrSessionKeyAlreadyUsed indicates that the client attempted to
-	// create a new session with a tower with a session key that has already
-	// been used in the past.
-	ErrSessionKeyAlreadyUsed = errors.New("session key already used")
 )
diff --git a/watchtower/wtclient/interface.go b/watchtower/wtclient/interface.go
index 06126ae21..8a6d9b320 100644
--- a/watchtower/wtclient/interface.go
+++ b/watchtower/wtclient/interface.go
@@ -49,8 +49,8 @@ type DB interface {
 	// (tower, blob type) pair until CreateClientSession is invoked for that
 	// tower and index, at which point a new index for that tower can be
 	// reserved. Multiple calls to this method before CreateClientSession is
-	// invoked should return the same index unless forceNext is true.
-	NextSessionKeyIndex(wtdb.TowerID, blob.Type, bool) (uint32, error)
+	// invoked should return the same index.
+	NextSessionKeyIndex(wtdb.TowerID, blob.Type) (uint32, error)
 
 	// CreateClientSession saves a newly negotiated client session to the
 	// client's database. This enables the session to be used across
diff --git a/watchtower/wtclient/session_negotiator.go b/watchtower/wtclient/session_negotiator.go
index d137d45e1..db0f543a1 100644
--- a/watchtower/wtclient/session_negotiator.go
+++ b/watchtower/wtclient/session_negotiator.go
@@ -1,7 +1,6 @@
 package wtclient
 
 import (
-	"errors"
 	"fmt"
 	"sync"
 	"time"
@@ -273,7 +272,6 @@ retryWithBackoff:
 		}
 	}
 
-tryNextCandidate:
 	for {
 		select {
 		case <-n.quit:
@@ -304,39 +302,28 @@ tryNextCandidate:
 		n.log.Debugf("Attempting session negotiation with tower=%x",
 			towerPub)
 
-		var forceNextKey bool
-		for {
-			// Before proceeding, we will reserve a session key
-			// index to use with this specific tower. If one is
-			// already reserved, the existing index will be
-			// returned.
-			keyIndex, err := n.cfg.DB.NextSessionKeyIndex(
-				tower.ID, n.cfg.Policy.BlobType, forceNextKey,
-			)
-			if err != nil {
-				n.log.Debugf("Unable to reserve session key "+
-					"index for tower=%x: %v", towerPub, err)
-
-				goto tryNextCandidate
-			}
-
-			// We'll now attempt the CreateSession dance with the
-			// tower to get a new session, trying all addresses if
-			// necessary.
-			err = n.createSession(tower, keyIndex)
-			if err == nil {
-				return
-			} else if errors.Is(err, ErrSessionKeyAlreadyUsed) {
-				forceNextKey = true
-				continue
-			}
+		// Before proceeding, we will reserve a session key index to use
+		// with this specific tower. If one is already reserved, the
+		// existing index will be returned.
+		keyIndex, err := n.cfg.DB.NextSessionKeyIndex(
+			tower.ID, n.cfg.Policy.BlobType,
+		)
+		if err != nil {
+			n.log.Debugf("Unable to reserve session key index "+
+				"for tower=%x: %v", towerPub, err)
+			continue
+		}
 
-			// An unexpected error occurred, update our backoff.
+		// We'll now attempt the CreateSession dance with the tower to
+		// get a new session, trying all addresses if necessary.
+		err = n.createSession(tower, keyIndex)
+		if err != nil {
+			// An unexpected error occurred, updpate our backoff.
 			updateBackoff()
 
 			n.log.Debugf("Session negotiation with tower=%x "+
-				"failed, trying again -- reason: %v", towerPub,
-				err)
+				"failed, trying again -- reason: %v",
+				tower.IdentityKey.SerializeCompressed(), err)
 
 			goto retryWithBackoff
 		}
@@ -373,10 +360,7 @@ func (n *sessionNegotiator) createSession(tower *Tower, keyIndex uint32) error {
 		err = n.tryAddress(sessionKey, keyIndex, tower, lnAddr)
 		tower.Addresses.ReleaseLock(addr)
 		switch {
-		case errors.Is(err, ErrSessionKeyAlreadyUsed):
-			return err
-
-		case errors.Is(err, ErrPermanentTowerFailure):
+		case err == ErrPermanentTowerFailure:
 			// TODO(conner): report to iterator? can then be reset
 			// with restart
 			fallthrough
@@ -470,7 +454,12 @@ func (n *sessionNegotiator) tryAddress(sessionKey keychain.SingleKeyECDH,
 	}
 
 	switch createSessionReply.Code {
-	case wtwire.CodeOK:
+	case wtwire.CodeOK, wtwire.CreateSessionCodeAlreadyExists:
+
+		// TODO(conner): add last-applied to create session reply to
+		// handle case where we lose state, session already exists, and
+		// we want to possibly resume using the session
+
 		// TODO(conner): validate reward address
 		rewardPkScript := createSessionReply.Data
 
@@ -511,16 +500,6 @@ func (n *sessionNegotiator) tryAddress(sessionKey keychain.SingleKeyECDH,
 			return ErrNegotiatorExiting
 		}
 
-	case wtwire.CreateSessionCodeAlreadyExists:
-		// TODO(conner): use the last-applied in the create session
-		//  reply to handle case where we lose state, session already
-		//  exists, and we want to possibly resume using the session.
-		//  NOTE that this should not be done until the server code
-		//  has been adapted to first check that the CreateSession
-		//  request is for the same blob-type as the initial session.
-
-		return ErrSessionKeyAlreadyUsed
-
 	// TODO(conner): handle error codes properly
 	case wtwire.CreateSessionCodeRejectBlobType:
 		return fmt.Errorf("tower rejected blob type: %v",
diff --git a/watchtower/wtdb/client_db.go b/watchtower/wtdb/client_db.go
index a949021d1..5a18095b8 100644
--- a/watchtower/wtdb/client_db.go
+++ b/watchtower/wtdb/client_db.go
@@ -643,10 +643,9 @@ func (c *ClientDB) ListTowers() ([]*Tower, error) {
 // particular tower id. The index is reserved for that tower until
 // CreateClientSession is invoked for that tower and index, at which point a new
 // index for that tower can be reserved. Multiple calls to this method before
-// CreateClientSession is invoked should return the same index unless forceNext
-// is true.
+// CreateClientSession is invoked should return the same index.
 func (c *ClientDB) NextSessionKeyIndex(towerID TowerID,
-	blobType blob.Type, forceNext bool) (uint32, error) {
+	blobType blob.Type) (uint32, error) {
 
 	var index uint32
 	err := kvdb.Update(c.db, func(tx kvdb.RwTx) error {
@@ -655,48 +654,33 @@ func (c *ClientDB) NextSessionKeyIndex(towerID TowerID,
 			return ErrUninitializedDB
 		}
 
+		// Check the session key index to see if a key has already been
+		// reserved for this tower. If so, we'll deserialize and return
+		// the index directly.
 		var err error
-		if !forceNext {
-			// Check the session key index to see if a key has
-			// already been reserved for this tower. If so, we'll
-			// deserialize and return the index directly.
-			index, err = getSessionKeyIndex(
-				keyIndex, towerID, blobType,
-			)
-			if err == nil {
-				return nil
-			}
-		}
-
-		// By default, we use the next available bucket sequence as the
-		// key index. But if forceNext is true, then it is assumed that
-		// some data loss occurred and so the sequence is incremented a
-		// by a jump of 1000 so that we can arrive at a brand new key
-		// index quicker.
-		currentSequence := keyIndex.Sequence()
-		nextIndex := currentSequence + 1
-		if forceNext {
-			nextIndex = currentSequence + 1000
+		index, err = getSessionKeyIndex(keyIndex, towerID, blobType)
+		if err == nil {
+			return nil
 		}
 
-		if err = keyIndex.SetSequence(nextIndex); err != nil {
-			return fmt.Errorf("could not set next bucket "+
-				"sequence: %w", err)
-		}
+		// Otherwise, generate a new session key index since the node
+		// doesn't already have reserved index. The error is ignored
+		// since NextSequence can't fail inside Update.
+		index64, _ := keyIndex.NextSequence()
 
 		// As a sanity check, assert that the index is still in the
 		// valid range of unhardened pubkeys. In the future, we should
 		// move to only using hardened keys, and this will prevent any
 		// overlap from occurring until then. This also prevents us from
 		// overflowing uint32s.
-		if nextIndex > math.MaxInt32 {
+		if index64 > math.MaxInt32 {
 			return fmt.Errorf("exhausted session key indexes")
 		}
 
 		// Create the key that will used to be store the reserved index.
 		keyBytes := createSessionKeyIndexKey(towerID, blobType)
 
-		index = uint32(nextIndex)
+		index = uint32(index64)
 
 		var indexBuf [4]byte
 		byteOrder.PutUint32(indexBuf[:], index)
diff --git a/watchtower/wtmock/client_db.go b/watchtower/wtmock/client_db.go
index 5b77da744..8d43a0e45 100644
--- a/watchtower/wtmock/client_db.go
+++ b/watchtower/wtmock/client_db.go
@@ -401,10 +401,9 @@ func (m *ClientDB) CreateClientSession(session *wtdb.ClientSession) error {
 // particular tower id. The index is reserved for that tower until
 // CreateClientSession is invoked for that tower and index, at which point a new
 // index for that tower can be reserved. Multiple calls to this method before
-// CreateClientSession is invoked should return the same index unless forceNext
-// is set to true.
-func (m *ClientDB) NextSessionKeyIndex(towerID wtdb.TowerID, blobType blob.Type,
-	forceNext bool) (uint32, error) {
+// CreateClientSession is invoked should return the same index.
+func (m *ClientDB) NextSessionKeyIndex(towerID wtdb.TowerID,
+	blobType blob.Type) (uint32, error) {
 
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -414,24 +413,15 @@ func (m *ClientDB) NextSessionKeyIndex(towerID wtdb.TowerID, blobType blob.Type,
 		blobType: blobType,
 	}
 
-	if !forceNext {
-		if index, err := m.getSessionKeyIndex(key); err == nil {
-			return index, nil
-		}
+	if index, err := m.getSessionKeyIndex(key); err == nil {
+		return index, nil
 	}
 
-	// By default, we use the next available bucket sequence as the key
-	// index. But if forceNext is true, then it is assumed that some data
-	// loss occurred and so the sequence is incremented a by a jump of 1000
-	// so that we can arrive at a brand new key index quicker.
-	nextIndex := m.nextIndex + 1
-	if forceNext {
-		nextIndex = m.nextIndex + 1000
-	}
-	m.nextIndex = nextIndex
-	m.indexes[key] = nextIndex
+	m.nextIndex++
+	index := m.nextIndex
+	m.indexes[key] = index
 
-	return nextIndex, nil
+	return index, nil
 }
 
 func (m *ClientDB) getSessionKeyIndex(key keyIndexKey) (uint32, error) {


Test patch:
diff --git a/funding/manager_test.go b/funding/manager_test.go
index dc40c4d8f..f386e3de5 100644
--- a/funding/manager_test.go
+++ b/funding/manager_test.go
@@ -900,8 +900,8 @@ func assertFundingMsgSent(t *testing.T, msgChan chan lnwire.Message,
 		sentMsg, ok = msg.(*lnwire.FundingCreated)
 	case "FundingSigned":
 		sentMsg, ok = msg.(*lnwire.FundingSigned)
-	case "ChannelReady":
-		sentMsg, ok = msg.(*lnwire.ChannelReady)
+	case "FundingLocked":
+		sentMsg, ok = msg.(*lnwire.FundingLocked)
 	case "Error":
 		sentMsg, ok = msg.(*lnwire.Error)
 	default:
@@ -1050,13 +1050,13 @@ func assertMarkedOpen(t *testing.T, alice, bob *testNode,
 	assertDatabaseState(t, bob, fundingOutPoint, markedOpen)
 }
 
-func assertChannelReadySent(t *testing.T, alice, bob *testNode,
+func assertFundingLockedSent(t *testing.T, alice, bob *testNode,
 	fundingOutPoint *wire.OutPoint) {
 
 	t.Helper()
 
-	assertDatabaseState(t, alice, fundingOutPoint, channelReadySent)
-	assertDatabaseState(t, bob, fundingOutPoint, channelReadySent)
+	assertDatabaseState(t, alice, fundingOutPoint, fundingLockedSent)
+	assertDatabaseState(t, bob, fundingOutPoint, fundingLockedSent)
 }
 
 func assertAddedToRouterGraph(t *testing.T, alice, bob *testNode,
@@ -1082,7 +1082,7 @@ func assertChannelAnnouncements(t *testing.T, alice, bob *testNode,
 
 	t.Helper()
 
-	// After the ChannelReady message is sent, Alice and Bob will each send
+	// After the FundingLocked message is sent, Alice and Bob will each send
 	// the following messages to their gossiper:
 	//	1) ChannelAnnouncement
 	//	2) ChannelUpdate
@@ -1222,7 +1222,7 @@ func assertChannelAnnouncements(t *testing.T, alice, bob *testNode,
 func assertAnnouncementSignatures(t *testing.T, alice, bob *testNode) {
 	t.Helper()
 
-	// After the ChannelReady message is sent and six confirmations have
+	// After the FundingLocked message is sent and six confirmations have
 	// been reached, the channel will be announced to the greater network
 	// by having the nodes exchange announcement signatures.
 	// Two distinct messages will be sent:
@@ -1347,7 +1347,7 @@ func assertInitialFwdingPolicyNotFound(t *testing.T, node *testNode,
 		fwdingPolicy)
 }
 
-func assertHandleChannelReady(t *testing.T, alice, bob *testNode) {
+func assertHandleFundingLocked(t *testing.T, alice, bob *testNode) {
 	t.Helper()
 
 	// They should both send the new channel state to their peer.
@@ -1405,28 +1405,26 @@ func TestFundingManagerNormalWorkflow(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -1637,7 +1635,7 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 	)
 
 	// After the funding transaction gets mined, both nodes will send the
-	// channelReady message to the other peer. If the funding node fails
+	// fundingLocked message to the other peer. If the funding node fails
 	// before this message has been successfully sent, it should retry
 	// sending it on restart. We mimic this behavior by letting the
 	// SendToPeer method return an error, as if the message was not
@@ -1668,7 +1666,7 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction was mined, Bob should have successfully
-	// sent the channelReady message, while Alice failed sending it. In
+	// sent the fundingLocked message, while Alice failed sending it. In
 	// Alice's case this means that there should be no messages for Bob, and
 	// the channel should still be in state 'markedOpen'
 	select {
@@ -1679,19 +1677,18 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 	}
 
 	// Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Alice should still be markedOpen
 	assertDatabaseState(t, alice, fundingOutPoint, markedOpen)
 
-	// While Bob successfully sent channelReady.
-	assertDatabaseState(t, bob, fundingOutPoint, channelReadySent)
+	// While Bob successfully sent fundingLocked.
+	assertDatabaseState(t, bob, fundingOutPoint, fundingLockedSent)
 
 	// We now recreate Alice's fundingManager with the correct sendMessage
-	// implementation, and expect it to retry sending the channelReady
+	// implementation, and expect it to retry sending the fundingLocked
 	// message. We'll explicitly shut down Alice's funding manager to
 	// prevent a race when overriding the sendMessage implementation.
 	if err := alice.fundingMgr.Stop(); err != nil {
@@ -1709,13 +1706,12 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 		return errChan
 	}
 
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
-	// The state should now be channelReadySent
-	assertDatabaseState(t, alice, fundingOutPoint, channelReadySent)
+	// The state should now be fundingLockedSent
+	assertDatabaseState(t, alice, fundingOutPoint, fundingLockedSent)
 
 	// Check that the channel announcements were never sent
 	select {
@@ -1726,13 +1722,13 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 		// Expected
 	}
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Next up, we check that Alice rebroadcasts the announcement
 	// messages on restart. Bob should as expected send announcements.
@@ -1775,7 +1771,7 @@ func TestFundingManagerRestartBehavior(t *testing.T) {
 
 // TestFundingManagerOfflinePeer checks that the fundingManager waits for the
 // server to notify when the peer comes online, in case sending the
-// channelReady message fails the first time.
+// fundingLocked message fails the first time.
 func TestFundingManagerOfflinePeer(t *testing.T) {
 	t.Parallel()
 
@@ -1795,8 +1791,8 @@ func TestFundingManagerOfflinePeer(t *testing.T) {
 	)
 
 	// After the funding transaction gets mined, both nodes will send the
-	// channelReady message to the other peer. If the funding node fails
-	// to send the channelReady message to the peer, it should wait for
+	// fundingLocked message to the other peer. If the funding node fails
+	// to send the fundingLocked message to the peer, it should wait for
 	// the server to notify it that the peer is back online, and try again.
 	// We'll save the current implementation of sendMessage to restore the
 	// original behavior later on.
@@ -1827,7 +1823,7 @@ func TestFundingManagerOfflinePeer(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction was mined, Bob should have successfully
-	// sent the channelReady message, while Alice failed sending it. In
+	// sent the fundingLocked message, while Alice failed sending it. In
 	// Alice's case this means that there should be no messages for Bob, and
 	// the channel should still be in state 'markedOpen'
 	select {
@@ -1838,16 +1834,15 @@ func TestFundingManagerOfflinePeer(t *testing.T) {
 	}
 
 	// Bob will send funding locked to Alice
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Alice should still be markedOpen
 	assertDatabaseState(t, alice, fundingOutPoint, markedOpen)
 
-	// While Bob successfully sent channelReady.
-	assertDatabaseState(t, bob, fundingOutPoint, channelReadySent)
+	// While Bob successfully sent fundingLocked.
+	assertDatabaseState(t, bob, fundingOutPoint, fundingLockedSent)
 
 	// Alice should be waiting for the server to notify when Bob comes back
 	// online.
@@ -1873,7 +1868,7 @@ func TestFundingManagerOfflinePeer(t *testing.T) {
 	}
 
 	// Before sending on the con chan, update Alice's NotifyWhenOnline
-	// function so that the next invocation in receivedChannelReady will
+	// function so that the next invocation in receivedFundingLocked will
 	// use this new function.
 	alice.fundingMgr.cfg.NotifyWhenOnline = func(peer [33]byte,
 		connected chan<- lnpeer.Peer) {
@@ -1886,22 +1881,21 @@ func TestFundingManagerOfflinePeer(t *testing.T) {
 	bob.sendMessage = workingSendMessage
 	con <- bob
 
-	// This should make Alice send the channelReady.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// This should make Alice send the fundingLocked.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
-	// The state should now be channelReadySent
-	assertDatabaseState(t, alice, fundingOutPoint, channelReadySent)
+	// The state should now be fundingLockedSent
+	assertDatabaseState(t, alice, fundingOutPoint, fundingLockedSent)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -2278,10 +2272,10 @@ func TestFundingManagerFundingNotTimeoutInitiator(t *testing.T) {
 	assertNumPendingChannelsBecomes(t, bob, 0)
 }
 
-// TestFundingManagerReceiveChannelReadyTwice checks that the fundingManager
-// continues to operate as expected in case we receive a duplicate channelReady
+// TestFundingManagerReceiveFundingLockedTwice checks that the fundingManager
+// continues to operate as expected in case we receive a duplicate fundingLocked
 // message.
-func TestFundingManagerReceiveChannelReadyTwice(t *testing.T) {
+func TestFundingManagerReceiveFundingLockedTwice(t *testing.T) {
 	t.Parallel()
 
 	alice, bob := setupFundingManagers(t)
@@ -2316,29 +2310,27 @@ func TestFundingManagerReceiveChannelReadyTwice(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Send the channelReady message twice to Alice, and once to Bob.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Send the fundingLocked message twice to Alice, and once to Bob.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Alice should not send the channel state the second time, as the
 	// second funding locked should just be ignored.
@@ -2349,9 +2341,9 @@ func TestFundingManagerReceiveChannelReadyTwice(t *testing.T) {
 		// Expected
 	}
 
-	// Another channelReady should also be ignored, since Alice should
+	// Another fundingLocked should also be ignored, since Alice should
 	// have updated her database at this point.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
 	select {
 	case <-alice.newChannels:
 		t.Fatalf("alice sent new channel to peer a second time")
@@ -2392,7 +2384,7 @@ func TestFundingManagerReceiveChannelReadyTwice(t *testing.T) {
 }
 
 // TestFundingManagerRestartAfterChanAnn checks that the fundingManager properly
-// handles receiving a channelReady after the its own channelReady and channel
+// handles receiving a fundingLocked after the its own fundingLocked and channel
 // announcement is sent and gets restarted.
 func TestFundingManagerRestartAfterChanAnn(t *testing.T) {
 	t.Parallel()
@@ -2429,28 +2421,26 @@ func TestFundingManagerRestartAfterChanAnn(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -2464,7 +2454,7 @@ func TestFundingManagerRestartAfterChanAnn(t *testing.T) {
 	waitForOpenUpdate(t, updateChan)
 
 	// At this point we restart Alice's fundingManager, before she receives
-	// the channelReady message. After restart, she will receive it, and
+	// the fundingLocked message. After restart, she will receive it, and
 	// we expect her to be able to handle it correctly.
 	recreateAliceFundingManager(t, alice)
 
@@ -2490,10 +2480,10 @@ func TestFundingManagerRestartAfterChanAnn(t *testing.T) {
 	assertNoFwdingPolicy(t, alice, bob, fundingOutPoint)
 }
 
-// TestFundingManagerRestartAfterReceivingChannelReady checks that the
+// TestFundingManagerRestartAfterReceivingFundingLocked checks that the
 // fundingManager continues to operate as expected after it has received
-// channelReady and then gets restarted.
-func TestFundingManagerRestartAfterReceivingChannelReady(t *testing.T) {
+// fundingLocked and then gets restarted.
+func TestFundingManagerRestartAfterReceivingFundingLocked(t *testing.T) {
 	t.Parallel()
 
 	alice, bob := setupFundingManagers(t)
@@ -2528,30 +2518,28 @@ func TestFundingManagerRestartAfterReceivingChannelReady(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Let Alice immediately get the channelReady message.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
+	// Let Alice immediately get the fundingLocked message.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
 
-	// Also let Bob get the channelReady message.
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Also let Bob get the fundingLocked message.
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// At this point we restart Alice's fundingManager.
 	recreateAliceFundingManager(t, alice)
@@ -2623,28 +2611,26 @@ func TestFundingManagerPrivateChannel(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -2748,28 +2734,26 @@ func TestFundingManagerPrivateRestart(t *testing.T) {
 	assertMarkedOpen(t, alice, bob, fundingOutPoint)
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// Check that the state machine is updated accordingly
-	assertChannelReadySent(t, alice, bob, fundingOutPoint)
+	assertFundingLockedSent(t, alice, bob, fundingOutPoint)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -3185,25 +3169,23 @@ func TestFundingManagerCustomChannelParameters(t *testing.T) {
 	}
 
 	// After the funding transaction is mined, Alice will send
-	// channelReady to Bob.
-	channelReadyAlice, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	// fundingLocked to Bob.
+	fundingLockedAlice := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
 	// And similarly Bob will send funding locked to Alice.
-	channelReadyBob, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
+	fundingLockedBob := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
 
-	// Exchange the channelReady messages.
-	alice.fundingMgr.ProcessFundingMsg(channelReadyBob, bob)
-	bob.fundingMgr.ProcessFundingMsg(channelReadyAlice, alice)
+	// Exchange the fundingLocked messages.
+	alice.fundingMgr.ProcessFundingMsg(fundingLockedBob, bob)
+	bob.fundingMgr.ProcessFundingMsg(fundingLockedAlice, alice)
 
 	// Check that they notify the breach arbiter and peer about the new
 	// channel.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// Make sure both fundingManagers send the expected channel
 	// announcements.
@@ -3504,14 +3486,14 @@ func TestFundingManagerMaxPendingChannels(t *testing.T) {
 			Tx: txs[i],
 		}
 
-		// Expect both to be sending ChannelReady.
+		// Expect both to be sending FundingLocked.
 		_ = assertFundingMsgSent(
-			t, alice.msgChan, "ChannelReady",
-		).(*lnwire.ChannelReady)
+			t, alice.msgChan, "FundingLocked",
+		).(*lnwire.FundingLocked)
 
 		_ = assertFundingMsgSent(
-			t, bob.msgChan, "ChannelReady",
-		).(*lnwire.ChannelReady)
+			t, bob.msgChan, "FundingLocked",
+		).(*lnwire.FundingLocked)
 
 	}
 
@@ -4220,28 +4202,26 @@ func TestFundingManagerZeroConf(t *testing.T) {
 		Index: 0,
 	}
 
-	// Assert that Bob's channel_ready message has an AliasScid.
-	bobChannelReady, ok := assertFundingMsgSent(
-		t, bob.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
-	require.NotNil(t, bobChannelReady.AliasScid)
-	require.Equal(t, *bobChannelReady.AliasScid, alias)
+	// Assert that Bob's funding_locked message has an AliasScid.
+	bobFundingLocked := assertFundingMsgSent(
+		t, bob.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
+	require.NotNil(t, bobFundingLocked.AliasScid)
+	require.Equal(t, *bobFundingLocked.AliasScid, alias)
 
 	// Do the same for Alice as well.
-	aliceChannelReady, ok := assertFundingMsgSent(
-		t, alice.msgChan, "ChannelReady",
-	).(*lnwire.ChannelReady)
-	require.True(t, ok)
-	require.NotNil(t, aliceChannelReady.AliasScid)
-	require.Equal(t, *aliceChannelReady.AliasScid, alias)
+	aliceFundingLocked := assertFundingMsgSent(
+		t, alice.msgChan, "FundingLocked",
+	).(*lnwire.FundingLocked)
+	require.NotNil(t, aliceFundingLocked.AliasScid)
+	require.Equal(t, *aliceFundingLocked.AliasScid, alias)
 
-	// Exchange the channel_ready messages.
-	alice.fundingMgr.ProcessFundingMsg(bobChannelReady, bob)
-	bob.fundingMgr.ProcessFundingMsg(aliceChannelReady, alice)
+	// Exchange the funding_locked messages.
+	alice.fundingMgr.ProcessFundingMsg(bobFundingLocked, bob)
+	bob.fundingMgr.ProcessFundingMsg(aliceFundingLocked, alice)
 
 	// We'll assert that they both create new links.
-	assertHandleChannelReady(t, alice, bob)
+	assertHandleFundingLocked(t, alice, bob)
 
 	// We'll now assert that both sides send ChannelAnnouncement and
 	// ChannelUpdate messages.
diff --git a/htlcswitch/link_test.go b/htlcswitch/link_test.go
index 72afa2ebb..b58c8a63b 100644
--- a/htlcswitch/link_test.go
+++ b/htlcswitch/link_test.go
@@ -1684,8 +1684,8 @@ func TestChannelLinkSingleHopMessageOrdering(t *testing.T) {
 		{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 		{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-		{"alice", "bob", &lnwire.ChannelReady{}, false},
-		{"bob", "alice", &lnwire.ChannelReady{}, false},
+		{"alice", "bob", &lnwire.FundingLocked{}, false},
+		{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 		{"alice", "bob", &lnwire.UpdateAddHTLC{}, false},
 		{"alice", "bob", &lnwire.CommitSig{}, false},
@@ -3303,8 +3303,8 @@ func TestChannelRetransmission(t *testing.T) {
 				{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 				{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-				{"alice", "bob", &lnwire.ChannelReady{}, false},
-				{"bob", "alice", &lnwire.ChannelReady{}, false},
+				{"alice", "bob", &lnwire.FundingLocked{}, false},
+				{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 				// Send payment from Alice to Bob and intercept
 				// the last revocation message, in this case
@@ -3343,8 +3343,8 @@ func TestChannelRetransmission(t *testing.T) {
 				{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 				{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-				{"alice", "bob", &lnwire.ChannelReady{}, false},
-				{"bob", "alice", &lnwire.ChannelReady{}, false},
+				{"alice", "bob", &lnwire.FundingLocked{}, false},
+				{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 				// Send payment from Alice to Bob and intercept
 				// the last revocation message, in this case
@@ -3385,8 +3385,8 @@ func TestChannelRetransmission(t *testing.T) {
 				{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 				{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-				{"alice", "bob", &lnwire.ChannelReady{}, false},
-				{"bob", "alice", &lnwire.ChannelReady{}, false},
+				{"alice", "bob", &lnwire.FundingLocked{}, false},
+				{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 				// Attempt make a payment from Alice to Bob,
 				// which is intercepted, emulating the Bob
@@ -3399,8 +3399,8 @@ func TestChannelRetransmission(t *testing.T) {
 				{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 				{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-				{"alice", "bob", &lnwire.ChannelReady{}, false},
-				{"bob", "alice", &lnwire.ChannelReady{}, false},
+				{"alice", "bob", &lnwire.FundingLocked{}, false},
+				{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 				// After Bob has notified Alice that he didn't
 				// receive updates Alice should re-send them.
@@ -3816,8 +3816,8 @@ func TestChannelLinkUpdateCommitFee(t *testing.T) {
 		{"alice", "bob", &lnwire.ChannelReestablish{}, false},
 		{"bob", "alice", &lnwire.ChannelReestablish{}, false},
 
-		{"alice", "bob", &lnwire.ChannelReady{}, false},
-		{"bob", "alice", &lnwire.ChannelReady{}, false},
+		{"alice", "bob", &lnwire.FundingLocked{}, false},
+		{"bob", "alice", &lnwire.FundingLocked{}, false},
 
 		// First fee update.
 		{"alice", "bob", &lnwire.UpdateFee{}, false},
diff --git a/htlcswitch/switch_test.go b/htlcswitch/switch_test.go
index 099fdb8f6..b1e134954 100644
--- a/htlcswitch/switch_test.go
+++ b/htlcswitch/switch_test.go
@@ -82,7 +82,7 @@ func TestSwitchAddDuplicateLink(t *testing.T) {
 // TestSwitchHasActiveLink tests the behavior of HasActiveLink, and asserts that
 // it only returns true if a link's short channel id has confirmed (meaning the
 // channel is no longer pending) and it's EligibleToForward method returns true,
-// i.e. it has received ChannelReady from the remote peer.
+// i.e. it has received FundingLocked from the remote peer.
 func TestSwitchHasActiveLink(t *testing.T) {
 	t.Parallel()
 
diff --git a/htlcswitch/test_utils.go b/htlcswitch/test_utils.go
index c1bfb1f55..e1bd6783a 100644
--- a/htlcswitch/test_utils.go
+++ b/htlcswitch/test_utils.go
@@ -495,7 +495,7 @@ func getChanID(msg lnwire.Message) (lnwire.ChannelID, error) {
 		chanID = msg.ChanID
 	case *lnwire.ChannelReestablish:
 		chanID = msg.ChanID
-	case *lnwire.ChannelReady:
+	case *lnwire.FundingLocked:
 		chanID = msg.ChanID
 	case *lnwire.UpdateFee:
 		chanID = msg.ChanID
diff --git a/itest/lnd_psbt_test.go b/itest/lnd_psbt_test.go
index ffa680d75..57a0a67b7 100644
--- a/itest/lnd_psbt_test.go
+++ b/itest/lnd_psbt_test.go
@@ -1009,28 +1009,17 @@ func assertPsbtSpend(ht *lntest.HarnessTest, alice *node.HarnessNode,
 	packet, err := psbt.NewFromUnsignedTx(pendingTx)
 	require.NoError(ht, err)
 
-	// We first try to sign the psbt without the necessary input data
-	// which should fail with the expected error.
-	var buf bytes.Buffer
-	err = packet.Serialize(&buf)
-	require.NoError(ht, err)
-
-	signReq := &walletrpc.SignPsbtRequest{FundedPsbt: buf.Bytes()}
-	err = alice.RPC.SignPsbtErr(signReq)
-	require.ErrorContains(ht, err, "input (index=0) doesn't specify "+
-		"any UTXO info", "error does not match")
-
 	// Now let's add the meta information that we need for signing.
 	packet.Inputs[0].WitnessUtxo = utxo
 	packet.Inputs[0].NonWitnessUtxo = prevTx
 	decorateUnsigned(packet)
 
 	// That's it, we should be able to sign the PSBT now.
-	buf.Reset()
+	var buf bytes.Buffer
 	err = packet.Serialize(&buf)
 	require.NoError(ht, err)
 
-	signReq = &walletrpc.SignPsbtRequest{FundedPsbt: buf.Bytes()}
+	signReq := &walletrpc.SignPsbtRequest{FundedPsbt: buf.Bytes()}
 	signResp := alice.RPC.SignPsbt(signReq)
 
 	// Let's make sure we have a partial signature.
diff --git a/lntest/README.md b/lntest/README.md
index 5752031ec..be28b218f 100644
--- a/lntest/README.md
+++ b/lntest/README.md
@@ -101,8 +101,8 @@ the real-world has. Aside from that, `lnd` has several places that use
 different code, which is triggered by the build flag `integration`, to speed up
 the tests. They are summarized as followings,
 
-1. `funding.checkPeerChannelReadyInterval`, which is used when we wait for the
-   peer to send us `ChannelReady`. This value is 1 second in `lnd`, and 10
+1. `funding.checkPeerFundingLockInterval`, which is used when we wait for the
+   peer to send us `FundingLocked`. This value is 1 second in `lnd`, and 10
    milliseconds in `lntest`.
 2. `lncfg.ProtocolOptions`, which is used to specify protocol flags. In `lnd`,
    anchor and script enforced lease are enabled by default, while in `lntest`,
diff --git a/lntest/rpc/wallet_kit.go b/lntest/rpc/wallet_kit.go
index 9a88fe6e7..1d0a12858 100644
--- a/lntest/rpc/wallet_kit.go
+++ b/lntest/rpc/wallet_kit.go
@@ -263,19 +263,6 @@ func (h *HarnessRPC) SignPsbt(
 	return resp
 }
 
-// SignPsbtErr makes a RPC call to the node's WalletKitClient and asserts
-// an error returned.
-func (h *HarnessRPC) SignPsbtErr(req *walletrpc.SignPsbtRequest) error {
-	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
-	defer cancel()
-
-	_, err := h.WalletKit.SignPsbt(ctxt, req)
-	require.Errorf(h, err, "%s: expect sign psbt to return an error",
-		h.Name)
-
-	return err
-}
-
 // ImportTapscript makes a RPC call to the node's WalletKitClient and asserts.
 //
 //nolint:lll
diff --git a/lnwire/fuzz_test.go b/lnwire/fuzz_test.go
index f578663a3..34d144c84 100644
--- a/lnwire/fuzz_test.go
+++ b/lnwire/fuzz_test.go
@@ -286,10 +286,10 @@ func FuzzFundingCreated(f *testing.F) {
 	})
 }
 
-func FuzzChannelReady(f *testing.F) {
+func FuzzFundingLocked(f *testing.F) {
 	f.Fuzz(func(t *testing.T, data []byte) {
-		// Prefix with MsgChannelReady.
-		data = prefixWithMsgType(data, MsgChannelReady)
+		// Prefix with MsgFundingLocked.
+		data = prefixWithMsgType(data, MsgFundingLocked)
 
 		// Pass the message into our general fuzz harness for wire
 		// messages!
diff --git a/lnwire/lnwire_test.go b/lnwire/lnwire_test.go
index 1ad93c96b..96d0c8ae5 100644
--- a/lnwire/lnwire_test.go
+++ b/lnwire/lnwire_test.go
@@ -566,7 +566,8 @@ func TestLightningWireProtocol(t *testing.T) {
 
 			v[0] = reflect.ValueOf(req)
 		},
-		MsgChannelReady: func(v []reflect.Value, r *rand.Rand) {
+		MsgFundingLocked: func(v []reflect.Value, r *rand.Rand) {
+
 			var c [32]byte
 			if _, err := r.Read(c[:]); err != nil {
 				t.Fatalf("unable to generate chan id: %v", err)
@@ -579,7 +580,7 @@ func TestLightningWireProtocol(t *testing.T) {
 				return
 			}
 
-			req := NewChannelReady(ChannelID(c), pubKey)
+			req := NewFundingLocked(ChannelID(c), pubKey)
 
 			v[0] = reflect.ValueOf(*req)
 		},
@@ -1012,8 +1013,8 @@ func TestLightningWireProtocol(t *testing.T) {
 			},
 		},
 		{
-			msgType: MsgChannelReady,
-			scenario: func(m ChannelReady) bool {
+			msgType: MsgFundingLocked,
+			scenario: func(m FundingLocked) bool {
 				return mainScenario(&m)
 			},
 		},
diff --git a/lnwire/message_test.go b/lnwire/message_test.go
index f39a88995..090978a74 100644
--- a/lnwire/message_test.go
+++ b/lnwire/message_test.go
@@ -268,7 +268,7 @@ func makeAllMessages(t testing.TB, r *rand.Rand) []lnwire.Message {
 	msgAll = append(msgAll, newMsgAcceptChannel(t, r))
 	msgAll = append(msgAll, newMsgFundingCreated(t, r))
 	msgAll = append(msgAll, newMsgFundingSigned(t, r))
-	msgAll = append(msgAll, newMsgChannelReady(t, r))
+	msgAll = append(msgAll, newMsgFundingLocked(t, r))
 	msgAll = append(msgAll, newMsgShutdown(t, r))
 	msgAll = append(msgAll, newMsgClosingSigned(t, r))
 	msgAll = append(msgAll, newMsgUpdateAddHTLC(t, r))
@@ -442,7 +442,7 @@ func newMsgFundingSigned(t testing.TB, r io.Reader) *lnwire.FundingSigned {
 	return msg
 }
 
-func newMsgChannelReady(t testing.TB, r io.Reader) *lnwire.ChannelReady {
+func newMsgFundingLocked(t testing.TB, r io.Reader) *lnwire.FundingLocked {
 	t.Helper()
 
 	var c [32]byte
@@ -452,7 +452,7 @@ func newMsgChannelReady(t testing.TB, r io.Reader) *lnwire.ChannelReady {
 
 	pubKey := randPubKey(t)
 
-	msg := lnwire.NewChannelReady(lnwire.ChannelID(c), pubKey)
+	msg := lnwire.NewFundingLocked(lnwire.ChannelID(c), pubKey)
 	msg.ExtraData = createExtraData(t, r)
 
 	return msg
diff --git a/watchtower/wtclient/addr_iterator_test.go b/watchtower/wtclient/addr_iterator_test.go
index a2e49ff90..89a35c4cb 100644
--- a/watchtower/wtclient/addr_iterator_test.go
+++ b/watchtower/wtclient/addr_iterator_test.go
@@ -10,227 +10,184 @@ import (
 
 // TestAddrIterator tests the behaviour of the addressIterator.
 func TestAddrIterator(t *testing.T) {
-	t.Parallel()
+	// Assert that an iterator can't be initialised with an empty address
+	// list.
+	_, err := newAddressIterator()
+	require.ErrorContains(t, err, "must have at least one address")
 
-	// Prep some addresses to use in the subtests.
 	addr1, err := net.ResolveTCPAddr("tcp", "1.2.3.4:8000")
 	require.NoError(t, err)
 
+	// Initialise the iterator with addr1.
+	iter, err := newAddressIterator(addr1)
+	require.NoError(t, err)
+
+	// Attempting to remove addr1 should fail now since it is the only
+	// address in the iterator.
+	iter.Add(addr1)
+	err = iter.Remove(addr1)
+	require.ErrorIs(t, err, wtdb.ErrLastTowerAddr)
+
+	// Adding a duplicate of addr1 and then calling Remove should still
+	// return an error.
+	err = iter.Remove(addr1)
+	require.ErrorIs(t, err, wtdb.ErrLastTowerAddr)
+
 	addr2, err := net.ResolveTCPAddr("tcp", "1.2.3.4:8001")
 	require.NoError(t, err)
 
+	// Add addr2 to the iterator.
+	iter.Add(addr2)
+
+	// Check that peek returns addr1.
+	a1 := iter.Peek()
+	require.NoError(t, err)
+	require.Equal(t, addr1, a1)
+
+	// Calling peek multiple times should return the same result.
+	a1 = iter.Peek()
+	require.Equal(t, addr1, a1)
+
+	// Calling Next should now return addr2.
+	a2, err := iter.Next()
+	require.NoError(t, err)
+	require.Equal(t, addr2, a2)
+
+	// Assert that Peek now returns addr2.
+	a2 = iter.Peek()
+	require.NoError(t, err)
+	require.Equal(t, addr2, a2)
+
+	// Calling Next should result in reaching the end of th list.
+	_, err = iter.Next()
+	require.ErrorIs(t, err, ErrAddressesExhausted)
+
+	// Calling Peek now should reset the queue and return addr1.
+	a1 = iter.Peek()
+	require.Equal(t, addr1, a1)
+
+	// Wind the list to the end again so that we can test the Reset func.
+	_, err = iter.Next()
+	require.NoError(t, err)
+
+	_, err = iter.Next()
+	require.ErrorIs(t, err, ErrAddressesExhausted)
+
+	iter.Reset()
+
+	// Now Next should return addr 2.
+	a2, err = iter.Next()
+	require.NoError(t, err)
+	require.Equal(t, addr2, a2)
+
 	addr3, err := net.ResolveTCPAddr("tcp", "1.2.3.4:8002")
 	require.NoError(t, err)
 
-	t.Run("always at least one address", func(t *testing.T) {
-		t.Parallel()
-
-		// Assert that an iterator can't be initialised with an empty
-		// address list.
-		_, err := newAddressIterator()
-		require.ErrorContains(t, err, "must have at least one address")
-
-		// Initialise the iterator with addr1.
-		iter, err := newAddressIterator(addr1)
-		require.NoError(t, err)
-
-		// Attempting to remove addr1 should fail now since it is the
-		// only address in the iterator.
-		iter.Add(addr1)
-		err = iter.Remove(addr1)
-		require.ErrorIs(t, err, wtdb.ErrLastTowerAddr)
-
-		// Adding a duplicate of addr1 and then calling Remove should
-		// still return an error.
-		err = iter.Remove(addr1)
-		require.ErrorIs(t, err, wtdb.ErrLastTowerAddr)
-	})
-
-	t.Run("address iteration", func(t *testing.T) {
-		t.Parallel()
-
-		// Initialise the iterator with addr1.
-		iter, err := newAddressIterator(addr1)
-		require.NoError(t, err)
-
-		// Add addr2 to the iterator.
-		iter.Add(addr2)
-
-		// Check that peek returns addr1.
-		a1 := iter.Peek()
-		require.NoError(t, err)
-		require.Equal(t, addr1, a1)
-
-		// Calling peek multiple times should return the same result.
-		a1 = iter.Peek()
-		require.Equal(t, addr1, a1)
-
-		// Calling Next should now return addr2.
-		a2, err := iter.Next()
-		require.NoError(t, err)
-		require.Equal(t, addr2, a2)
-
-		// Assert that Peek now returns addr2.
-		a2 = iter.Peek()
-		require.NoError(t, err)
-		require.Equal(t, addr2, a2)
-
-		// Calling Next should result in reaching the end of th list.
-		_, err = iter.Next()
-		require.ErrorIs(t, err, ErrAddressesExhausted)
-
-		// Calling Peek now should reset the queue and return addr1.
-		a1 = iter.Peek()
-		require.Equal(t, addr1, a1)
-
-		// Wind the list to the end again so that we can test the Reset
-		// func.
-		_, err = iter.Next()
-		require.NoError(t, err)
-
-		_, err = iter.Next()
-		require.ErrorIs(t, err, ErrAddressesExhausted)
-
-		iter.Reset()
-
-		// Now Next should return addr 2.
-		a2, err = iter.Next()
-		require.NoError(t, err)
-		require.Equal(t, addr2, a2)
-
-		// Add addr3 now to ensure that the iteration works even if we
-		// are midway through the queue.
-		iter.Add(addr3)
-
-		// Now Next should return addr 3.
-		a3, err := iter.Next()
-		require.NoError(t, err)
-		require.Equal(t, addr3, a3)
-
-		// Quickly test that GetAll correctly returns a copy of all the
-		// addresses in the iterator.
-		addrList := iter.GetAll()
-		require.ElementsMatch(
-			t, addrList, []net.Addr{addr1, addr2, addr3},
-		)
-
-		// Also check that an iterator constructed via the Copy method,
-		// also contains all the expected addresses.
-		newIterAddrs := iter.Copy().GetAll()
-		require.ElementsMatch(
-			t, newIterAddrs, []net.Addr{addr1, addr2, addr3},
-		)
-
-		// Let's now remove addr3.
-		err = iter.Remove(addr3)
-		require.NoError(t, err)
-
-		// Since addr3 is gone, Peek should return addr1.
-		a1 = iter.Peek()
-		require.Equal(t, addr1, a1)
-	})
-
-	t.Run("address locking", func(t *testing.T) {
-		t.Parallel()
-
-		// Initialise the iterator with addr1 and addr2.
-		iter, err := newAddressIterator(addr1, addr2)
-		require.NoError(t, err)
-
-		// First we test the locking of an address via the PeekAndLock
-		// function.
-		a1 := iter.PeekAndLock()
-		require.Equal(t, addr1, a1)
-		require.True(t, iter.HasLocked())
-
-		// Assert that we can't remove addr1 if there is a lock on it.
-		err = iter.Remove(addr1)
-		require.ErrorIs(t, err, ErrAddrInUse)
-
-		// Now release the lock on addr1.
-		iter.ReleaseLock(addr1)
-		require.False(t, iter.HasLocked())
-
-		// Since the lock has been released, we should now be able to
-		// remove addr1.
-		err = iter.Remove(addr1)
-		require.NoError(t, err)
-
-		// Now we test the locking of an address via the NextAndLock
-		// function. To do this, we first re-add addr3.
-		iter.Add(addr3)
-
-		a2, err := iter.NextAndLock()
-		require.NoError(t, err)
-		require.Equal(t, addr2, a2)
-		require.True(t, iter.HasLocked())
-
-		// Assert that we can't remove addr2 if there is a lock on it.
-		err = iter.Remove(addr2)
-		require.ErrorIs(t, err, ErrAddrInUse)
-
-		// Now release the lock on addr2.
-		iter.ReleaseLock(addr2)
-		require.False(t, iter.HasLocked())
-
-		// Since the lock has been released, we should now be able to
-		// remove addr1.
-		err = iter.Remove(addr2)
-		require.NoError(t, err)
-
-		// Only addr3 should still be left in the iterator.
-		addrList := iter.GetAll()
-		require.Len(t, addrList, 1)
-		require.Contains(t, addrList, addr3)
-
-		// Ensure that HasLocked acts correctly in the case where more
-		// than one address is being locked and unlock as well as the
-		// case where the same address is locked more than once.
-		require.False(t, iter.HasLocked())
-
-		a3 := iter.PeekAndLock()
-		require.Equal(t, addr3, a3)
-		require.True(t, iter.HasLocked())
-
-		a3 = iter.PeekAndLock()
-		require.Equal(t, addr3, a3)
-		require.True(t, iter.HasLocked())
-
-		iter.Add(addr2)
-		a2, err = iter.NextAndLock()
-		require.NoError(t, err)
-		require.Equal(t, addr2, a2)
-		require.True(t, iter.HasLocked())
-
-		// Now release addr2 and assert that HasLock is still true.
-		iter.ReleaseLock(addr2)
-		require.True(t, iter.HasLocked())
-
-		// Releasing one of the locks on addr3 now should still result
-		// in HasLocked returning true.
-		iter.ReleaseLock(addr3)
-		require.True(t, iter.HasLocked())
-
-		// Releasing it again should now result in should still result
-		// in HasLocked returning false.
-		iter.ReleaseLock(addr3)
-		require.False(t, iter.HasLocked())
-	})
-
-	t.Run("calling Next twice without Reset is safe", func(t *testing.T) {
-		t.Parallel()
-
-		// Initialise the iterator with addr1.
-		iter, err := newAddressIterator(addr1)
-		require.NoError(t, err)
-
-		a1 := iter.Peek()
-		require.Equal(t, addr1, a1)
-
-		_, err = iter.Next()
-		require.ErrorIs(t, err, ErrAddressesExhausted)
-
-		_, err = iter.Next()
-		require.ErrorIs(t, err, ErrAddressesExhausted)
-	})
+	// Add addr3 now to ensure that the iteration works even if we are
+	// midway through the queue.
+	iter.Add(addr3)
+
+	// Now Next should return addr 3.
+	a3, err := iter.Next()
+	require.NoError(t, err)
+	require.Equal(t, addr3, a3)
+
+	// Quickly test that GetAll correctly returns a copy of all the
+	// addresses in the iterator.
+	addrList := iter.GetAll()
+	require.ElementsMatch(t, addrList, []net.Addr{addr1, addr2, addr3})
+
+	// Also check that an iterator constructed via the Copy method, also
+	// contains all the expected addresses.
+	newIterAddrs := iter.Copy().GetAll()
+	require.ElementsMatch(t, newIterAddrs, []net.Addr{addr1, addr2, addr3})
+
+	// Let's now remove addr3.
+	err = iter.Remove(addr3)
+	require.NoError(t, err)
+
+	// Since addr3 is gone, Peek should return addr1.
+	a1 = iter.Peek()
+	require.Equal(t, addr1, a1)
+
+	// Lastly, we will test the "locking" of addresses.
+
+	// First we test the locking of an address via the PeekAndLock function.
+	a1 = iter.PeekAndLock()
+	require.Equal(t, addr1, a1)
+	require.True(t, iter.HasLocked())
+
+	// Assert that we can't remove addr1 if there is a lock on it.
+	err = iter.Remove(addr1)
+	require.ErrorIs(t, err, ErrAddrInUse)
+
+	// Now release the lock on addr1.
+	iter.ReleaseLock(addr1)
+	require.False(t, iter.HasLocked())
+
+	// Since the lock has been released, we should now be able to remove
+	// addr1.
+	err = iter.Remove(addr1)
+	require.NoError(t, err)
+
+	// Now we test the locking of an address via the NextAndLock function.
+	// To do this, we first re-add addr3.
+	iter.Add(addr3)
+
+	a2, err = iter.NextAndLock()
+	require.NoError(t, err)
+	require.Equal(t, addr2, a2)
+	require.True(t, iter.HasLocked())
+
+	// Assert that we can't remove addr2 if there is a lock on it.
+	err = iter.Remove(addr2)
+	require.ErrorIs(t, err, ErrAddrInUse)
+
+	// Now release the lock on addr2.
+	iter.ReleaseLock(addr2)
+	require.False(t, iter.HasLocked())
+
+	// Since the lock has been released, we should now be able to remove
+	// addr1.
+	err = iter.Remove(addr2)
+	require.NoError(t, err)
+
+	// Only addr3 should still be left in the iterator.
+	addrList = iter.GetAll()
+	require.Len(t, addrList, 1)
+	require.Contains(t, addrList, addr3)
+
+	// Ensure that HasLocked acts correctly in the case where more than one
+	// address is being locked and unlock as well as the case where the same
+	// address is locked more than once.
+
+	require.False(t, iter.HasLocked())
+
+	a3 = iter.PeekAndLock()
+	require.Equal(t, addr3, a3)
+	require.True(t, iter.HasLocked())
+
+	a3 = iter.PeekAndLock()
+	require.Equal(t, addr3, a3)
+	require.True(t, iter.HasLocked())
+
+	iter.Add(addr2)
+	a2, err = iter.NextAndLock()
+	require.NoError(t, err)
+	require.Equal(t, addr2, a2)
+	require.True(t, iter.HasLocked())
+
+	// Now release addr2 and asset that HasLock is still true.
+	iter.ReleaseLock(addr2)
+	require.True(t, iter.HasLocked())
+
+	// Releasing one of the locks on addr3 now should still result in
+	// HasLocked returning true.
+	iter.ReleaseLock(addr3)
+	require.True(t, iter.HasLocked())
+
+	// Releasing it again should now result in should still result in
+	// HasLocked returning false.
+	iter.ReleaseLock(addr3)
+	require.False(t, iter.HasLocked())
 }
diff --git a/watchtower/wtclient/client_test.go b/watchtower/wtclient/client_test.go
index 7be616d77..f870af527 100644
--- a/watchtower/wtclient/client_test.go
+++ b/watchtower/wtclient/client_test.go
@@ -1466,7 +1466,7 @@ var clientTests = []clientTest{
 			h.waitServerUpdates(hints[:numUpdates/2], time.Second)
 
 			// Stop the client, which should have no more backups.
-			require.NoError(h.t, h.client.Stop())
+			h.client.Stop()
 
 			// Record the policy that the first half was stored
 			// under. We'll expect the second half to also be stored
@@ -1527,7 +1527,7 @@ var clientTests = []clientTest{
 
 			// Restart the client, so we can ensure the deduping is
 			// maintained across restarts.
-			require.NoError(h.t, h.client.Stop())
+			h.client.Stop()
 			h.startClient()
 
 			// Try to back up the full range of retributions. Only
@@ -2013,58 +2013,6 @@ var clientTests = []clientTest{
 			require.NoError(h.t, err)
 		},
 	},
-	{
-		// Demonstrate that the client is unable to recover after
-		// deleting its database by skipping through key indices until
-		// it gets to one that does not result in the
-		// CreateSessionCodeAlreadyExists error code being returned from
-		// the server.
-		name: "continue after client database deletion",
-		cfg: harnessCfg{
-			localBalance:  localBalance,
-			remoteBalance: remoteBalance,
-			policy: wtpolicy.Policy{
-				TxPolicy:   defaultTxPolicy,
-				MaxUpdates: 5,
-			},
-		},
-		fn: func(h *testHarness) {
-			const (
-				numUpdates = 5
-				chanID     = 0
-			)
-
-			// Generate numUpdates retributions.
-			hints := h.advanceChannelN(chanID, numUpdates)
-
-			// Back half of the states up.
-			h.backupStates(chanID, 0, numUpdates/2, nil)
-
-			// Wait for the updates to be populated in the server's
-			// database.
-			h.waitServerUpdates(hints[:numUpdates/2], waitTime)
-
-			// Now stop the client and reset its database.
-			require.NoError(h.t, h.client.Stop())
-
-			db := wtmock.NewClientDB()
-			h.clientDB = db
-			h.clientCfg.DB = db
-
-			// Restart the client.
-			h.startClient()
-
-			// We need to re-register the channel due to the client
-			// db being reset.
-			h.registerChannel(0)
-
-			// Attempt to back up the remaining tasks.
-			h.backupStates(chanID, numUpdates/2, numUpdates, nil)
-
-			// Show that the server does get the remaining updates.
-			h.waitServerUpdates(hints[numUpdates/2:], waitTime)
-		},
-	},
 }
 
 // TestClient executes the client test suite, asserting the ability to backup
diff --git a/watchtower/wtdb/client_db_test.go b/watchtower/wtdb/client_db_test.go
index 80557f1f8..26d02bcf3 100644
--- a/watchtower/wtdb/client_db_test.go
+++ b/watchtower/wtdb/client_db_test.go
@@ -62,12 +62,12 @@ func (h *clientDBHarness) listSessions(id *wtdb.TowerID,
 	return sessions
 }
 
-func (h *clientDBHarness) nextKeyIndex(id wtdb.TowerID, blobType blob.Type,
-	forceNext bool) uint32 {
+func (h *clientDBHarness) nextKeyIndex(id wtdb.TowerID,
+	blobType blob.Type) uint32 {
 
 	h.t.Helper()
 
-	index, err := h.db.NextSessionKeyIndex(id, blobType, forceNext)
+	index, err := h.db.NextSessionKeyIndex(id, blobType)
 	require.NoError(h.t, err, "unable to create next session key index")
 	require.NotZero(h.t, index, "next key index should never be 0")
 
@@ -309,7 +309,7 @@ func testCreateClientSession(h *clientDBHarness) {
 	h.insertSession(session, wtdb.ErrNoReservedKeyIndex)
 
 	// Now, reserve a session key for this tower.
-	keyIndex := h.nextKeyIndex(session.TowerID, blobType, false)
+	keyIndex := h.nextKeyIndex(session.TowerID, blobType)
 
 	// The client session hasn't been updated with the reserved key index
 	// (since it's still zero). Inserting should fail due to the mismatch.
@@ -318,7 +318,7 @@ func testCreateClientSession(h *clientDBHarness) {
 	// Reserve another key for the same index. Since no session has been
 	// successfully created, it should return the same index to maintain
 	// idempotency across restarts.
-	keyIndex2 := h.nextKeyIndex(session.TowerID, blobType, false)
+	keyIndex2 := h.nextKeyIndex(session.TowerID, blobType)
 	require.Equalf(h.t, keyIndex, keyIndex2, "next key index should "+
 		"be idempotent: want: %v, got %v", keyIndex, keyIndex2)
 
@@ -335,23 +335,11 @@ func testCreateClientSession(h *clientDBHarness) {
 	// session already existing.
 	h.insertSession(session, wtdb.ErrClientSessionAlreadyExists)
 
-	// Assert that reserving another key index succeeds with a different key
-	// index, now that the first one has been finalized.
-	keyIndex3 := h.nextKeyIndex(session.TowerID, blobType, false)
+	// Finally, assert that reserving another key index succeeds with a
+	// different key index, now that the first one has been finalized.
+	keyIndex3 := h.nextKeyIndex(session.TowerID, blobType)
 	require.NotEqualf(h.t, keyIndex, keyIndex3, "key index still "+
 		"reserved after creating session")
-
-	// Show that calling NextSessionKeyIndex again now will result in the
-	// same key being returned as long as forceNext remains false.
-	keyIndex4 := h.nextKeyIndex(session.TowerID, blobType, false)
-	require.Equal(h.t, keyIndex3, keyIndex4)
-
-	// Finally, assert that if the forceNext param of the
-	// NextSessionKeyIndex method is true, then the key index returned will
-	// be different.
-	keyIndex5 := h.nextKeyIndex(session.TowerID, blobType, true)
-	require.NotEqual(h.t, keyIndex5, keyIndex4)
-	require.Equal(h.t, keyIndex3+1000, keyIndex5)
 }
 
 // testFilterClientSessions asserts that we can correctly filter client sessions
@@ -364,7 +352,7 @@ func testFilterClientSessions(h *clientDBHarness) {
 	towerSessions := make(map[wtdb.TowerID][]wtdb.SessionID)
 	for i := 0; i < numSessions; i++ {
 		tower := h.newTower()
-		keyIndex := h.nextKeyIndex(tower.ID, blobType, false)
+		keyIndex := h.nextKeyIndex(tower.ID, blobType)
 		sessionID := wtdb.SessionID([33]byte{byte(i)})
 		h.insertSession(&wtdb.ClientSession{
 			ClientSessionBody: wtdb.ClientSessionBody{
@@ -511,9 +499,7 @@ func testRemoveTower(h *clientDBHarness) {
 				MaxUpdates: 100,
 			},
 			RewardPkScript: []byte{0x01, 0x02, 0x03},
-			KeyIndex: h.nextKeyIndex(
-				tower.ID, blobType, false,
-			),
+			KeyIndex:       h.nextKeyIndex(tower.ID, blobType),
 		},
 		ID: wtdb.SessionID([33]byte{0x01}),
 	}
@@ -595,7 +581,7 @@ func testCommitUpdate(h *clientDBHarness) {
 	)
 
 	// Reserve a session key index and insert the session.
-	session.KeyIndex = h.nextKeyIndex(session.TowerID, blobType, false)
+	session.KeyIndex = h.nextKeyIndex(session.TowerID, blobType)
 	h.insertSession(session, nil)
 
 	// Now, try to commit the update that failed initially which should
@@ -788,7 +774,7 @@ func testAckUpdate(h *clientDBHarness) {
 	h.ackUpdate(&session.ID, 1, 0, wtdb.ErrClientSessionNotFound)
 
 	// Reserve a session key and insert the client session.
-	session.KeyIndex = h.nextKeyIndex(session.TowerID, blobType, false)
+	session.KeyIndex = h.nextKeyIndex(session.TowerID, blobType)
 	h.insertSession(session, nil)
 
 	// Now, try to ack update 1. This should fail since update 1 was never
@@ -1065,9 +1051,7 @@ func (h *clientDBHarness) randSession(t *testing.T,
 				MaxUpdates: maxUpdates,
 			},
 			RewardPkScript: []byte{0x01, 0x02, 0x03},
-			KeyIndex: h.nextKeyIndex(
-				towerID, blobType, false,
-			),
+			KeyIndex:       h.nextKeyIndex(towerID, blobType),
 		},
 		ID: id,
 	}