Repository: lightningnetwork/lnd
Pull request #8452 (2024-02-01 01:04:20)

contractcourt: homogenize naming convention
## Change Description
This is a strict refactor and document cleanup

## Steps to Test
N/A

## Pull Request Checklist
### Testing
- [ ] Your PR passes all CI checks.
- [x] Tests covering the positive and negative (error paths) are included.
- [x] 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] Any new lncli commands have appropriate tags in the comments for the rpc in the proto file.
- [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.



Patch:
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 619cffcc4..6799325de 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -3,13 +3,13 @@
 # respective areas
 
 # aezeed
-/aezeed/ @guggero @yyforyongyu @roasbeef
+/aezeed/ @guggero @yyforyongyu
 
 # alias manager
 /aliasmgr/ @Crypt-iQ
 
 # amp
-/amp/ @yyforyongyu @roasbeef
+/amp/ @yyforyongyu
 
 # auto pilot
 /autopilot/ @bitromortac
@@ -63,7 +63,7 @@
 /cmd/ @ellemouton
 
 # contract court
-/contractcourt/ @yyforyongyu @Roasbeef @Crypt-iQ
+/contractcourt/ @yyforyongyu
 
 # contrib
 /contrib/ @guggero
@@ -95,8 +95,11 @@
 # invoices
 /invoices/ @yyforyongyu @bhandras
 
+#itest
+/itest/ @yyforyongyu @ellemouton
+
 # key chain
-/keychain/ @guggero @roasbeef
+/keychain/ @guggero
 
 # kvdb
 /kvdb/ @bhandras
@@ -110,6 +113,9 @@
 # lnpeer
 /lnpeer/ @Roasbeef
 
+# lnrpc
+/lnrpc/ @guggero @ellemouton
+
 #lntest
 /lntest/ @yyforyongyu
 
@@ -120,7 +126,7 @@
 /lnutils/ @yyforyongyu
 
 # lnwallet
-/lnwallet/ @Roasbeef @yyforyongyu @Crypt-iQ
+/lnwallet/ @Roasbeef @yyforyongyu
 
 # lnwire
 /lnwire/ @ellemouton
@@ -192,4 +198,4 @@
 /watchtower/ @ellemouton
 
 # zpay32
-/zpay32/ @Roasbeef
+/zpay32/ @Roasbeef
\ No newline at end of file
diff --git a/channeldb/invoices.go b/channeldb/invoices.go
index 9ffc6aa27..f163f40b8 100644
--- a/channeldb/invoices.go
+++ b/channeldb/invoices.go
@@ -497,7 +497,11 @@ func (d *DB) FetchPendingInvoices(_ context.Context) (
 func (d *DB) QueryInvoices(_ context.Context, q invpkg.InvoiceQuery) (
 	invpkg.InvoiceSlice, error) {
 
-	var resp invpkg.InvoiceSlice
+	var (
+		resp         invpkg.InvoiceSlice
+		startDateSet = !q.CreationDateStart.IsZero()
+		endDateSet   = !q.CreationDateEnd.IsZero()
+	)
 
 	err := kvdb.View(d, func(tx kvdb.RTx) error {
 		// If the bucket wasn't found, then there aren't any invoices
@@ -537,20 +541,20 @@ func (d *DB) QueryInvoices(_ context.Context, q invpkg.InvoiceQuery) (
 				return false, nil
 			}
 
-			// Get the creation time in Unix seconds, this always
-			// rounds down the nanoseconds to full seconds.
-			createTime := invoice.CreationDate.Unix()
-
 			// Skip any invoices that were created before the
 			// specified time.
-			if createTime < q.CreationDateStart {
+			if startDateSet && invoice.CreationDate.Before(
+				q.CreationDateStart,
+			) {
+
 				return false, nil
 			}
 
 			// Skip any invoices that were created after the
 			// specified time.
-			if q.CreationDateEnd != 0 &&
-				createTime > q.CreationDateEnd {
+			if endDateSet && invoice.CreationDate.After(
+				q.CreationDateEnd,
+			) {
 
 				return false, nil
 			}
diff --git a/channeldb/payments.go b/channeldb/payments.go
index 15bcd8342..c2d32ee8a 100644
--- a/channeldb/payments.go
+++ b/channeldb/payments.go
@@ -471,13 +471,13 @@ type PaymentsQuery struct {
 	// payment index (complete and incomplete) should be counted.
 	CountTotal bool
 
-	// CreationDateStart, expressed in Unix seconds, if set, filters out
-	// all payments with a creation date greater than or equal to it.
-	CreationDateStart int64
+	// CreationDateStart, if set, filters out all payments with a creation
+	// date greater than or euqal to it.
+	CreationDateStart time.Time
 
-	// CreationDateEnd, expressed in Unix seconds, if set, filters out all
-	// payments with a creation date less than or equal to it.
-	CreationDateEnd int64
+	// CreationDateEnd, if set, filters out all payments with a creation
+	// date less than or euqal to it.
+	CreationDateEnd time.Time
 }
 
 // PaymentsResponse contains the result of a query to the payments database.
@@ -512,7 +512,11 @@ type PaymentsResponse struct {
 // to a subset of payments by the payments query, containing an offset
 // index and a maximum number of returned payments.
 func (d *DB) QueryPayments(query PaymentsQuery) (PaymentsResponse, error) {
-	var resp PaymentsResponse
+	var (
+		resp         PaymentsResponse
+		startDateSet = !query.CreationDateStart.IsZero()
+		endDateSet   = !query.CreationDateEnd.IsZero()
+	)
 
 	if err := kvdb.View(d, func(tx kvdb.RTx) error {
 		// Get the root payments bucket.
@@ -557,20 +561,20 @@ func (d *DB) QueryPayments(query PaymentsQuery) (PaymentsResponse, error) {
 				return false, err
 			}
 
-			// Get the creation time in Unix seconds, this always
-			// rounds down the nanoseconds to full seconds.
-			createTime := payment.Info.CreationTime.Unix()
-
 			// Skip any payments that were created before the
 			// specified time.
-			if createTime < query.CreationDateStart {
+			if startDateSet && payment.Info.CreationTime.Before(
+				query.CreationDateStart,
+			) {
+
 				return false, nil
 			}
 
 			// Skip any payments that were created after the
 			// specified time.
-			if query.CreationDateEnd != 0 &&
-				createTime > query.CreationDateEnd {
+			if endDateSet && payment.Info.CreationTime.After(
+				query.CreationDateEnd,
+			) {
 
 				return false, nil
 			}
diff --git a/config.go b/config.go
index 5cf54dece..ec6220b9b 100644
--- a/config.go
+++ b/config.go
@@ -285,7 +285,7 @@ var (
 type Config struct {
 	ShowVersion bool `short:"V" long:"version" description:"Display version information and exit"`
 
-	LndDir       string `long:"lnddir" description:"The base directory that contains lnd's data, logs, configuration file, etc. This option overwrites all other directory options."`
+	LndDir       string `long:"lnddir" description:"The base directory that contains lnd's data, logs, configuration file, etc."`
 	ConfigFile   string `short:"C" long:"configfile" description:"Path to configuration file"`
 	DataDir      string `short:"b" long:"datadir" description:"The directory to store lnd's data within"`
 	SyncFreelist bool   `long:"sync-freelist" description:"Whether the databases used within lnd should sync their freelist to disk. This is disabled by default resulting in improved memory performance during operation, but with an increase in startup time."`
diff --git a/contractcourt/breacharbiter.go b/contractcourt/breach_arbitrator.go
similarity index 96%
rename from contractcourt/breacharbiter.go
rename to contractcourt/breach_arbitrator.go
index 739e70f13..c8238df43 100644
--- a/contractcourt/breacharbiter.go
+++ b/contractcourt/breach_arbitrator.go
@@ -53,12 +53,12 @@ var (
 	// for the first and one for the second level).
 	taprootRetributionBucket = []byte("tap-retribution")
 
-	// errBrarShuttingDown is an error returned if the breacharbiter has
+	// errBrarShuttingDown is an error returned if the BreachArbitrator has
 	// been signalled to exit.
-	errBrarShuttingDown = errors.New("breacharbiter shutting down")
+	errBrarShuttingDown = errors.New("BreachArbitrator shutting down")
 )
 
-// ContractBreachEvent is an event the BreachArbiter will receive in case a
+// ContractBreachEvent is an event the BreachArbitrator will receive in case a
 // contract breach is observed on-chain. It contains the necessary information
 // to handle the breach, and a ProcessACK closure we will use to ACK the event
 // when we have safely stored all the necessary information.
@@ -71,7 +71,7 @@ type ContractBreachEvent struct {
 	// store. In case storing the information to the store fails, a non-nil
 	// error should be used. When this closure returns, it means that the
 	// contract court has marked the channel pending close in the DB, and
-	// it is safe for the BreachArbiter to carry on its duty.
+	// it is safe for the BreachArbitrator to carry on its duty.
 	ProcessACK func(error)
 
 	// BreachRetribution is the information needed to act on this contract
@@ -94,11 +94,12 @@ const (
 )
 
 // RetributionStorer provides an interface for managing a persistent map from
-// wire.OutPoint -> retributionInfo. Upon learning of a breach, a BreachArbiter
-// should record the retributionInfo for the breached channel, which serves a
-// checkpoint in the event that retribution needs to be resumed after failure.
-// A RetributionStore provides an interface for managing the persisted set, as
-// well as mapping user defined functions over the entire on-disk contents.
+// wire.OutPoint -> retributionInfo. Upon learning of a breach, a
+// BreachArbitrator should record the retributionInfo for the breached channel,
+// which serves a checkpoint in the event that retribution needs to be resumed
+// after failure. A RetributionStore provides an interface for managing the
+// persisted set, as well as mapping user defined functions over the entire
+// on-disk contents.
 //
 // Calls to RetributionStore may occur concurrently. A concrete instance of
 // RetributionStore should use appropriate synchronization primitives, or
@@ -125,7 +126,8 @@ type RetributionStorer interface {
 }
 
 // BreachConfig bundles the required subsystems used by the breach arbiter. An
-// instance of BreachConfig is passed to newBreachArbiter during instantiation.
+// instance of BreachConfig is passed to NewBreachArbitrator during
+// instantiation.
 type BreachConfig struct {
 	// CloseLink allows the breach arbiter to shutdown any channel links for
 	// which it detects a breach, ensuring now further activity will
@@ -154,9 +156,9 @@ type BreachConfig struct {
 	// transaction to the network.
 	PublishTransaction func(*wire.MsgTx, string) error
 
-	// ContractBreaches is a channel where the BreachArbiter will receive
+	// ContractBreaches is a channel where the BreachArbitrator will receive
 	// notifications in the event of a contract breach being observed. A
-	// ContractBreachEvent must be ACKed by the BreachArbiter, such that
+	// ContractBreachEvent must be ACKed by the BreachArbitrator, such that
 	// the sending subsystem knows that the event is properly handed off.
 	ContractBreaches <-chan *ContractBreachEvent
 
@@ -171,7 +173,7 @@ type BreachConfig struct {
 	Store RetributionStorer
 }
 
-// BreachArbiter is a special subsystem which is responsible for watching and
+// BreachArbitrator is a special subsystem which is responsible for watching and
 // acting on the detection of any attempted uncooperative channel breaches by
 // channel counterparties. This file essentially acts as deterrence code for
 // those attempting to launch attacks against the daemon. In practice it's
@@ -179,7 +181,7 @@ type BreachConfig struct {
 // important to have it in place just in case we encounter cheating channel
 // counterparties.
 // TODO(roasbeef): closures in config for subsystem pointers to decouple?
-type BreachArbiter struct {
+type BreachArbitrator struct {
 	started sync.Once
 	stopped sync.Once
 
@@ -192,19 +194,19 @@ type BreachArbiter struct {
 	sync.Mutex
 }
 
-// NewBreachArbiter creates a new instance of a BreachArbiter initialized with
-// its dependent objects.
-func NewBreachArbiter(cfg *BreachConfig) *BreachArbiter {
-	return &BreachArbiter{
+// NewBreachArbitrator creates a new instance of a BreachArbitrator initialized
+// with its dependent objects.
+func NewBreachArbitrator(cfg *BreachConfig) *BreachArbitrator {
+	return &BreachArbitrator{
 		cfg:           cfg,
 		subscriptions: make(map[wire.OutPoint]chan struct{}),
 		quit:          make(chan struct{}),
 	}
 }
 
-// Start is an idempotent method that officially starts the BreachArbiter along
-// with all other goroutines it needs to perform its functions.
-func (b *BreachArbiter) Start() error {
+// Start is an idempotent method that officially starts the BreachArbitrator
+// along with all other goroutines it needs to perform its functions.
+func (b *BreachArbitrator) Start() error {
 	var err error
 	b.started.Do(func() {
 		brarLog.Info("Breach arbiter starting")
@@ -213,7 +215,7 @@ func (b *BreachArbiter) Start() error {
 	return err
 }
 
-func (b *BreachArbiter) start() error {
+func (b *BreachArbitrator) start() error {
 	// Load all retributions currently persisted in the retribution store.
 	var breachRetInfos map[wire.OutPoint]retributionInfo
 	if err := b.cfg.Store.ForAll(func(ret *retributionInfo) error {
@@ -305,10 +307,10 @@ func (b *BreachArbiter) start() error {
 	return nil
 }
 
-// Stop is an idempotent method that signals the BreachArbiter to execute a
+// Stop is an idempotent method that signals the BreachArbitrator to execute a
 // graceful shutdown. This function will block until all goroutines spawned by
-// the BreachArbiter have gracefully exited.
-func (b *BreachArbiter) Stop() error {
+// the BreachArbitrator have gracefully exited.
+func (b *BreachArbitrator) Stop() error {
 	b.stopped.Do(func() {
 		brarLog.Infof("Breach arbiter shutting down...")
 		defer brarLog.Debug("Breach arbiter shutdown complete")
@@ -321,13 +323,13 @@ func (b *BreachArbiter) Stop() error {
 
 // IsBreached queries the breach arbiter's retribution store to see if it is
 // aware of any channel breaches for a particular channel point.
-func (b *BreachArbiter) IsBreached(chanPoint *wire.OutPoint) (bool, error) {
+func (b *BreachArbitrator) IsBreached(chanPoint *wire.OutPoint) (bool, error) {
 	return b.cfg.Store.IsBreached(chanPoint)
 }
 
 // SubscribeBreachComplete is used by outside subsystems to be notified of a
 // successful breach resolution.
-func (b *BreachArbiter) SubscribeBreachComplete(chanPoint *wire.OutPoint,
+func (b *BreachArbitrator) SubscribeBreachComplete(chanPoint *wire.OutPoint,
 	c chan struct{}) (bool, error) {
 
 	breached, err := b.cfg.Store.IsBreached(chanPoint)
@@ -353,9 +355,9 @@ func (b *BreachArbiter) SubscribeBreachComplete(chanPoint *wire.OutPoint,
 	return false, nil
 }
 
-// notifyBreachComplete is used by the BreachArbiter to notify outside
+// notifyBreachComplete is used by the BreachArbitrator to notify outside
 // subsystems that the breach resolution process is complete.
-func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
+func (b *BreachArbitrator) notifyBreachComplete(chanPoint *wire.OutPoint) {
 	b.Lock()
 	defer b.Unlock()
 	if c, ok := b.subscriptions[*chanPoint]; ok {
@@ -366,7 +368,7 @@ func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
 	delete(b.subscriptions, *chanPoint)
 }
 
-// contractObserver is the primary goroutine for the BreachArbiter. This
+// contractObserver is the primary goroutine for the BreachArbitrator. This
 // goroutine is responsible for handling breach events coming from the
 // contractcourt on the ContractBreaches channel. If a channel breach is
 // detected, then the contractObserver will execute the retribution logic
@@ -374,7 +376,7 @@ func (b *BreachArbiter) notifyBreachComplete(chanPoint *wire.OutPoint) {
 // wallet.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) contractObserver() {
+func (b *BreachArbitrator) contractObserver() {
 	defer b.wg.Done()
 
 	brarLog.Infof("Starting contract observer, watching for breaches.")
@@ -406,7 +408,7 @@ type spend struct {
 // returns the spend details for those outputs. The spendNtfns map is a cache
 // used to store registered spend subscriptions, in case we must call this
 // method multiple times.
-func (b *BreachArbiter) waitForSpendEvent(breachInfo *retributionInfo,
+func (b *BreachArbitrator) waitForSpendEvent(breachInfo *retributionInfo,
 	spendNtfns map[wire.OutPoint]*chainntnfs.SpendEvent) ([]spend, error) {
 
 	inputs := breachInfo.breachedOutputs
@@ -684,8 +686,10 @@ func updateBreachInfo(breachInfo *retributionInfo, spends []spend) (
 // the lingering funds within the channel into the daemon's wallet.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) exactRetribution(confChan *chainntnfs.ConfirmationEvent,
-	breachInfo *retributionInfo) {
+//
+//nolint:funlen
+func (b *BreachArbitrator) exactRetribution(
+	confChan *chainntnfs.ConfirmationEvent, breachInfo *retributionInfo) {
 
 	defer b.wg.Done()
 
@@ -916,7 +920,7 @@ Loop:
 
 // cleanupBreach marks the given channel point as fully resolved and removes the
 // retribution for that the channel from the retribution store.
-func (b *BreachArbiter) cleanupBreach(chanPoint *wire.OutPoint) error {
+func (b *BreachArbitrator) cleanupBreach(chanPoint *wire.OutPoint) error {
 	// With the channel closed, mark it in the database as such.
 	err := b.cfg.DB.MarkChanFullyClosed(chanPoint)
 	if err != nil {
@@ -943,15 +947,17 @@ func (b *BreachArbiter) cleanupBreach(chanPoint *wire.OutPoint) error {
 }
 
 // handleBreachHandoff handles a new breach event, by writing it to disk, then
-// notifies the BreachArbiter contract observer goroutine that a channel's
+// notifies the BreachArbitrator contract observer goroutine that a channel's
 // contract has been breached by the prior counterparty. Once notified the
-// BreachArbiter will attempt to sweep ALL funds within the channel using the
+// BreachArbitrator will attempt to sweep ALL funds within the channel using the
 // information provided within the BreachRetribution generated due to the
 // breach of channel contract. The funds will be swept only after the breaching
 // transaction receives a necessary number of confirmations.
 //
 // NOTE: This MUST be run as a goroutine.
-func (b *BreachArbiter) handleBreachHandoff(breachEvent *ContractBreachEvent) {
+func (b *BreachArbitrator) handleBreachHandoff(
+	breachEvent *ContractBreachEvent) {
+
 	defer b.wg.Done()
 
 	chanPoint := breachEvent.ChanPoint
@@ -1367,7 +1373,7 @@ type justiceTxVariants struct {
 // the funds within the channel which we are now entitled to due to a breach of
 // the channel's contract by the counterparty. This function returns a *fully*
 // signed transaction with the witness for each input fully in place.
-func (b *BreachArbiter) createJusticeTx(
+func (b *BreachArbitrator) createJusticeTx(
 	breachedOutputs []breachedOutput) (*justiceTxVariants, error) {
 
 	var (
@@ -1442,7 +1448,7 @@ func (b *BreachArbiter) createJusticeTx(
 }
 
 // createSweepTx creates a tx that sweeps the passed inputs back to our wallet.
-func (b *BreachArbiter) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
+func (b *BreachArbitrator) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
 	error) {
 
 	if len(inputs) == 0 {
@@ -1498,7 +1504,7 @@ func (b *BreachArbiter) createSweepTx(inputs ...input.Input) (*wire.MsgTx,
 
 // sweepSpendableOutputsTxn creates a signed transaction from a sequence of
 // spendable outputs by sweeping the funds into a single p2wkh output.
-func (b *BreachArbiter) sweepSpendableOutputsTxn(txWeight int64,
+func (b *BreachArbitrator) sweepSpendableOutputsTxn(txWeight int64,
 	inputs ...input.Input) (*wire.MsgTx, error) {
 
 	// First, we obtain a new public key script from the wallet which we'll
diff --git a/contractcourt/breach_resolver.go b/contractcourt/breach_resolver.go
index 922ec609a..c76d20a6a 100644
--- a/contractcourt/breach_resolver.go
+++ b/contractcourt/breach_resolver.go
@@ -8,13 +8,14 @@ import (
 )
 
 // breachResolver is a resolver that will handle breached closes. In the
-// future, this will likely take over the duties the current breacharbiter has.
+// future, this will likely take over the duties the current BreachArbitrator
+// has.
 type breachResolver struct {
 	// resolved reflects if the contract has been fully resolved or not.
 	resolved bool
 
 	// subscribed denotes whether or not the breach resolver has subscribed
-	// to the breacharbiter for breach resolution.
+	// to the BreachArbitrator for breach resolution.
 	subscribed bool
 
 	// replyChan is closed when the breach arbiter has completed serving
@@ -42,8 +43,8 @@ func (b *breachResolver) ResolverKey() []byte {
 	return key[:]
 }
 
-// Resolve queries the breacharbiter to see if the justice transaction has been
-// broadcast.
+// Resolve queries the BreachArbitrator to see if the justice transaction has
+// been broadcast.
 func (b *breachResolver) Resolve() (ContractResolver, error) {
 	if !b.subscribed {
 		complete, err := b.SubscribeBreachComplete(
diff --git a/contractcourt/chain_arbitrator.go b/contractcourt/chain_arbitrator.go
index acf3512af..1fa348b3f 100644
--- a/contractcourt/chain_arbitrator.go
+++ b/contractcourt/chain_arbitrator.go
@@ -100,10 +100,10 @@ type ChainArbitratorConfig struct {
 	MarkLinkInactive func(wire.OutPoint) error
 
 	// ContractBreach is a function closure that the ChainArbitrator will
-	// use to notify the breachArbiter about a contract breach. It should
-	// only return a non-nil error when the breachArbiter has preserved
+	// use to notify the BreachArbitrator about a contract breach. It should
+	// only return a non-nil error when the BreachArbitrator has preserved
 	// the necessary breach info for this channel point. Once the breach
-	// resolution is persisted in the channel arbitrator, it will be safe
+	// resolution is persisted in the ChannelArbitrator, it will be safe
 	// to mark the channel closed.
 	ContractBreach func(wire.OutPoint, *lnwallet.BreachRetribution) error
 
diff --git a/contractcourt/chain_watcher.go b/contractcourt/chain_watcher.go
index 71f2f9a83..b560795df 100644
--- a/contractcourt/chain_watcher.go
+++ b/contractcourt/chain_watcher.go
@@ -175,7 +175,7 @@ type chainWatcherConfig struct {
 
 	// contractBreach is a method that will be called by the watcher if it
 	// detects that a contract breach transaction has been confirmed. It
-	// will only return a non-nil error when the breachArbiter has
+	// will only return a non-nil error when the BreachArbitrator has
 	// preserved the necessary breach info for this channel point.
 	contractBreach func(*lnwallet.BreachRetribution) error
 
@@ -1243,14 +1243,14 @@ func (c *chainWatcher) dispatchContractBreach(spendEvent *chainntnfs.SpendDetail
 		closeSummary.LastChanSyncMsg = chanSync
 	}
 
-	// Hand the retribution info over to the breach arbiter. This function
+	// Hand the retribution info over to the BreachArbitrator. This function
 	// will wait for a response from the breach arbiter and then proceed to
 	// send a BreachCloseInfo to the channel arbitrator. The channel arb
 	// will then mark the channel as closed after resolutions and the
 	// commit set are logged in the arbitrator log.
 	if err := c.cfg.contractBreach(retribution); err != nil {
 		log.Errorf("unable to hand breached contract off to "+
-			"breachArbiter: %v", err)
+			"BreachArbitrator: %v", err)
 		return err
 	}
 
diff --git a/contractcourt/channel_arbitrator.go b/contractcourt/channel_arbitrator.go
index a15031a2e..e6f91d3cd 100644
--- a/contractcourt/channel_arbitrator.go
+++ b/contractcourt/channel_arbitrator.go
@@ -860,7 +860,7 @@ const (
 
 	// breachCloseTrigger is a transition trigger driven by a remote breach
 	// being confirmed. In this case the channel arbitrator will wait for
-	// the breacharbiter to finish and then clean up gracefully.
+	// the BreachArbitrator to finish and then clean up gracefully.
 	breachCloseTrigger
 )
 
@@ -2891,7 +2891,7 @@ func (c *ChannelArbitrator) channelAttendant(bestHeight int32) {
 			}
 
 		// The remote has breached the channel. As this is handled by
-		// the ChainWatcher and BreachArbiter, we don't have to do
+		// the ChainWatcher and BreachArbitrator, we don't have to do
 		// anything in particular, so just advance our state and
 		// gracefully exit.
 		case breachInfo := <-c.cfg.ChainEvents.ContractBreach:
@@ -2926,7 +2926,7 @@ func (c *ChannelArbitrator) channelAttendant(bestHeight int32) {
 			}
 
 			// The channel is finally marked pending closed here as
-			// the breacharbiter and channel arbitrator have
+			// the BreachArbitrator and channel arbitrator have
 			// persisted the relevant states.
 			closeSummary := &breachInfo.CloseSummary
 			err = c.cfg.MarkChannelClosed(
diff --git a/docs/release-notes/release-notes-0.18.0.md b/docs/release-notes/release-notes-0.18.0.md
index 1323c1f0e..46f0f42cc 100644
--- a/docs/release-notes/release-notes-0.18.0.md
+++ b/docs/release-notes/release-notes-0.18.0.md
@@ -77,13 +77,6 @@
 
 * [Add Taproot witness types
   to rpc](https://github.com/lightningnetwork/lnd/pull/8431)
-  
-* [Fixed](https://github.com/lightningnetwork/lnd/pull/7852) the payload size
-  calculation in our pathfinder because blinded hops introduced new tlv records.
-
-* [Fixed](https://github.com/lightningnetwork/lnd/pull/8432) a timestamp
-  precision issue when querying payments and invoices using the start and end
-  date filters.
 
 # New Features
 ## Functional Enhancements
diff --git a/invoices/interface.go b/invoices/interface.go
index 73274dfb5..0da031842 100644
--- a/invoices/interface.go
+++ b/invoices/interface.go
@@ -2,6 +2,7 @@ package invoices
 
 import (
 	"context"
+	"time"
 
 	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -125,13 +126,13 @@ type InvoiceQuery struct {
 	// from the IndexOffset and go backwards.
 	Reversed bool
 
-	// CreationDateStart, expressed in Unix seconds, if set, filters out
-	// all invoices with a creation date greater than or equal to it.
-	CreationDateStart int64
+	// CreationDateStart, if set, filters out all invoices with a creation
+	// date greater than or euqal to it.
+	CreationDateStart time.Time
 
 	// CreationDateEnd, if set, filters out all invoices with a creation
-	// date less than or equal to it.
-	CreationDateEnd int64
+	// date less than or euqal to it.
+	CreationDateEnd time.Time
 }
 
 // InvoiceSlice is the response to a invoice query. It includes the original
diff --git a/lnrpc/routerrpc/router_backend.go b/lnrpc/routerrpc/router_backend.go
index 4d82c72e4..420259de2 100644
--- a/lnrpc/routerrpc/router_backend.go
+++ b/lnrpc/routerrpc/router_backend.go
@@ -15,6 +15,7 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	sphinx "github.com/lightningnetwork/lightning-onion"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/feature"
 	"github.com/lightningnetwork/lnd/htlcswitch"
 	"github.com/lightningnetwork/lnd/lnrpc"
@@ -279,7 +280,7 @@ func (r *RouterBackend) parseQueryRoutesRequest(in *lnrpc.QueryRoutesRequest) (
 	// inside of the path rather than the request's fields.
 	var (
 		targetPubKey   *route.Vertex
-		routeHintEdges map[route.Vertex][]routing.AdditionalEdge
+		routeHintEdges map[route.Vertex][]*models.CachedEdgePolicy
 		blindedPmt     *routing.BlindedPayment
 
 		// finalCLTVDelta varies depending on whether we're sending to
@@ -390,7 +391,6 @@ func (r *RouterBackend) parseQueryRoutesRequest(in *lnrpc.QueryRoutesRequest) (
 		DestCustomRecords: record.CustomSet(in.DestCustomRecords),
 		CltvLimit:         cltvLimit,
 		DestFeatures:      destinationFeatures,
-		BlindedPayment:    blindedPmt,
 	}
 
 	// Pass along an outgoing channel restriction if specified.
@@ -967,9 +967,6 @@ func (r *RouterBackend) extractIntentFromSendRequest(
 			// pseudo-reusable, e.g. the invoice parameters are
 			// reused (amt, cltv, hop hints, etc) even though the
 			// payments will share different payment hashes.
-			//
-			// NOTE: This will only work when the peer has
-			// spontaneous AMP payments enabled.
 			if len(rpcPayReq.PaymentAddr) > 0 {
 				var addr [32]byte
 				copy(addr[:], rpcPayReq.PaymentAddr)
diff --git a/lnrpc/walletrpc/walletkit_server.go b/lnrpc/walletrpc/walletkit_server.go
index 9d70baa73..88065572d 100644
--- a/lnrpc/walletrpc/walletkit_server.go
+++ b/lnrpc/walletrpc/walletkit_server.go
@@ -201,7 +201,7 @@ var (
 	// are numbered differently. The protobuf enum cannot be renumbered
 	// because this would break backwards compatibility with older clients,
 	// and the native enum cannot be renumbered because it is stored in the
-	// watchtower and breacharbiter databases.
+	// watchtower and BreachArbitrator databases.
 	//
 	//nolint:lll
 	allWitnessTypes = map[input.WitnessType]WitnessType{
diff --git a/lnwallet/channel.go b/lnwallet/channel.go
index 028b06e46..4d2f798df 100644
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@@ -153,6 +153,38 @@ func (e *ErrCommitSyncLocalDataLoss) Error() string {
 		e.CommitPoint.SerializeCompressed())
 }
 
+// channelState is an enum like type which represents the current state of a
+// particular channel.
+// TODO(roasbeef): actually update state
+type channelState uint8
+
+const (
+	// channelPending indicates this channel is still going through the
+	// funding workflow, and isn't yet open.
+	channelPending channelState = iota // nolint: unused
+
+	// channelOpen represents an open, active channel capable of
+	// sending/receiving HTLCs.
+	channelOpen
+
+	// channelClosing represents a channel which is in the process of being
+	// closed.
+	channelClosing
+
+	// channelClosed represents a channel which has been fully closed. Note
+	// that before a channel can be closed, ALL pending HTLCs must be
+	// settled/removed.
+	channelClosed
+
+	// channelDispute indicates that an un-cooperative closure has been
+	// detected within the channel.
+	channelDispute
+
+	// channelPendingPayment indicates that there a currently outstanding
+	// HTLCs within the channel.
+	channelPendingPayment // nolint:unused
+)
+
 // PaymentHash represents the sha256 of a random value. This hash is used to
 // uniquely track incoming/outgoing payments within this channel, as well as
 // payments requested by the wallet/daemon.
@@ -1251,7 +1283,7 @@ type LightningChannel struct {
 	// the commitment transaction that spends the multi-sig output.
 	signDesc *input.SignDescriptor
 
-	isClosed bool
+	status channelState
 
 	// ChanPoint is the funding outpoint of this channel.
 	ChanPoint *wire.OutPoint
@@ -1506,7 +1538,7 @@ func (lc *LightningChannel) createSignDesc() error {
 // events do so properly.
 func (lc *LightningChannel) ResetState() {
 	lc.Lock()
-	lc.isClosed = false
+	lc.status = channelOpen
 	lc.Unlock()
 }
 
@@ -7561,8 +7593,9 @@ func (lc *LightningChannel) ForceClose() (*LocalForceCloseSummary, error) {
 			"summary: %w", err)
 	}
 
-	// Mark the channel as closed to block future closure requests.
-	lc.isClosed = true
+	// Set the channel state to indicate that the channel is now in a
+	// contested state.
+	lc.status = channelDispute
 
 	return summary, nil
 }
@@ -7756,8 +7789,8 @@ func (lc *LightningChannel) CreateCloseProposal(proposedFee btcutil.Amount,
 	lc.Lock()
 	defer lc.Unlock()
 
-	// If we're already closing the channel, then ignore this request.
-	if lc.isClosed {
+	// If we've already closed the channel, then ignore this request.
+	if lc.status == channelClosed {
 		// TODO(roasbeef): check to ensure no pending payments
 		return nil, nil, 0, ErrChanClosing
 	}
@@ -7820,6 +7853,10 @@ func (lc *LightningChannel) CreateCloseProposal(proposedFee btcutil.Amount,
 		}
 	}
 
+	// As everything checks out, indicate in the channel status that a
+	// channel closure has been initiated.
+	lc.status = channelClosing
+
 	closeTXID := closeTx.TxHash()
 	return sig, &closeTXID, ourBalance, nil
 }
@@ -7840,8 +7877,8 @@ func (lc *LightningChannel) CompleteCooperativeClose(
 	lc.Lock()
 	defer lc.Unlock()
 
-	// If the channel is already closing, then ignore this request.
-	if lc.isClosed {
+	// If the channel is already closed, then ignore this request.
+	if lc.status == channelClosed {
 		// TODO(roasbeef): check to ensure no pending payments
 		return nil, 0, ErrChanClosing
 	}
@@ -7945,7 +7982,7 @@ func (lc *LightningChannel) CompleteCooperativeClose(
 	// As the transaction is sane, and the scripts are valid we'll mark the
 	// channel now as closed as the closure transaction should get into the
 	// chain in a timely manner and possibly be re-broadcast by the wallet.
-	lc.isClosed = true
+	lc.status = channelClosed
 
 	return closeTx, ourBalance, nil
 }
diff --git a/lnwire/closing_complete.go b/lnwire/closing_complete.go
deleted file mode 100644
index c3cd0cc4d..000000000
--- a/lnwire/closing_complete.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package lnwire
-
-import (
-	"bytes"
-	"io"
-
-	"github.com/btcsuite/btcd/btcutil"
-	"github.com/lightningnetwork/lnd/tlv"
-)
-
-// ClosingSigs houses the 3 possible signatures that can be sent when
-// attempting to complete a cooperative channel closure. A signature will
-// either include both outputs, or only one of the outputs from either side.
-type ClosingSigs struct {
-	// CloserNoClosee is a signature that excludes the output of the
-	// clsoee.
-	CloserNoClosee tlv.OptionalRecordT[tlv.TlvType1, Sig]
-
-	// NoCloserClosee is a signature that excludes the output of the
-	// closer.
-	NoCloserClosee tlv.OptionalRecordT[tlv.TlvType2, Sig]
-
-	// CloserAndClosee is a signature that includes both outputs.
-	CloserAndClosee tlv.OptionalRecordT[tlv.TlvType3, Sig]
-}
-
-// ClosingComplete is sent by either side to kick off the process of obtaining
-// a valid signature on a c o-operative channel closure of their choice.
-type ClosingComplete struct {
-	// ChannelID serves to identify which channel is to be closed.
-	ChannelID ChannelID
-
-	// FeeSatoshis is the total fee in satoshis that the party to the
-	// channel would like to propose for the close transaction.
-	FeeSatoshis btcutil.Amount
-
-	// Sequence is the sequence number to be used in the input spending the
-	// funding transaction.
-	Sequence uint32
-
-	// ClosingSigs houses the 3 possible signatures that can be sent.
-	ClosingSigs
-
-	// ExtraData is the set of data that was appended to this message to
-	// fill out the full maximum transport message size. These fields can
-	// be used to specify optional data such as custom TLV fields.
-	ExtraData ExtraOpaqueData
-}
-
-// decodeClosingSigs decodes the closing sig TLV records in the passed
-// ExtraOpaqueData.
-func decodeClosingSigs(c *ClosingSigs, tlvRecords ExtraOpaqueData) error {
-	sig1 := tlv.ZeroRecordT[tlv.TlvType1, Sig]()
-	sig2 := tlv.ZeroRecordT[tlv.TlvType2, Sig]()
-	sig3 := tlv.ZeroRecordT[tlv.TlvType3, Sig]()
-
-	typeMap, err := tlvRecords.ExtractRecords(&sig1, &sig2, &sig3)
-	if err != nil {
-		return err
-	}
-
-	// TODO(roasbeef): helper func to made decode of the optional vals
-	// easier?
-
-	if val, ok := typeMap[c.CloserNoClosee.TlvType()]; ok && val == nil {
-		c.CloserNoClosee = tlv.SomeRecordT(sig1)
-	}
-	if val, ok := typeMap[c.NoCloserClosee.TlvType()]; ok && val == nil {
-		c.NoCloserClosee = tlv.SomeRecordT(sig2)
-	}
-	if val, ok := typeMap[c.CloserAndClosee.TlvType()]; ok && val == nil {
-		c.CloserAndClosee = tlv.SomeRecordT(sig3)
-	}
-
-	return nil
-}
-
-// Decode deserializes a serialized ClosingComplete message stored in the
-// passed io.Reader.
-func (c *ClosingComplete) Decode(r io.Reader, _ uint32) error {
-	// First, read out all the fields that are hard coded into the message.
-	err := ReadElements(r, &c.ChannelID, &c.FeeSatoshis, &c.Sequence)
-	if err != nil {
-		return err
-	}
-
-	// With the hard coded messages read, we'll now read out the TLV fields
-	// of the message.
-	var tlvRecords ExtraOpaqueData
-	if err := ReadElements(r, &tlvRecords); err != nil {
-		return err
-	}
-
-	if err := decodeClosingSigs(&c.ClosingSigs, tlvRecords); err != nil {
-		return err
-	}
-
-	if len(tlvRecords) != 0 {
-		c.ExtraData = tlvRecords
-	}
-
-	return nil
-}
-
-// closingSigRecords returns the set of records that encode the closing sigs,
-// if present.
-func closingSigRecords(c *ClosingSigs) []tlv.RecordProducer {
-	recordProducers := make([]tlv.RecordProducer, 0, 3)
-	c.CloserNoClosee.WhenSome(func(sig tlv.RecordT[tlv.TlvType1, Sig]) {
-		recordProducers = append(recordProducers, &sig)
-	})
-	c.NoCloserClosee.WhenSome(func(sig tlv.RecordT[tlv.TlvType2, Sig]) {
-		recordProducers = append(recordProducers, &sig)
-	})
-	c.CloserAndClosee.WhenSome(func(sig tlv.RecordT[tlv.TlvType3, Sig]) {
-		recordProducers = append(recordProducers, &sig)
-	})
-
-	return recordProducers
-}
-
-// Encode serializes the target ClosingComplete into the passed io.Writer.
-func (c *ClosingComplete) Encode(w *bytes.Buffer, _ uint32) error {
-	if err := WriteChannelID(w, c.ChannelID); err != nil {
-		return err
-	}
-
-	if err := WriteSatoshi(w, c.FeeSatoshis); err != nil {
-		return err
-	}
-
-	if err := WriteUint32(w, c.Sequence); err != nil {
-		return err
-	}
-
-	recordProducers := closingSigRecords(&c.ClosingSigs)
-
-	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)
-	if err != nil {
-		return err
-	}
-
-	return WriteBytes(w, c.ExtraData)
-}
-
-// MsgType returns the uint32 code which uniquely identifies this message as a
-// ClosingComplete message on the wire.
-//
-// This is part of the lnwire.Message interface.
-func (c *ClosingComplete) MsgType() MessageType {
-	return MsgClosingComplete
-}
-
-// A compile time check to ensure ClosingComplete implements the lnwire.Message
-// interface.
-var _ Message = (*ClosingComplete)(nil)
diff --git a/lnwire/closing_sig.go b/lnwire/closing_sig.go
deleted file mode 100644
index df160d12e..000000000
--- a/lnwire/closing_sig.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package lnwire
-
-import (
-	"bytes"
-	"io"
-)
-
-// ClosingSig is sent in response to a ClosingComplete message. It carries the
-// signatures of the closee to the closer.
-type ClosingSig struct {
-	// ChannelID serves to identify which channel is to be closed.
-	ChannelID ChannelID
-
-	// ClosingSigs houses the 3 possible signatures that can be sent.
-	ClosingSigs
-
-	// ExtraData is the set of data that was appended to this message to
-	// fill out the full maximum transport message size. These fields can
-	// be used to specify optional data such as custom TLV fields.
-	ExtraData ExtraOpaqueData
-}
-
-// Decode deserializes a serialized ClosingSig message stored in the passed
-// io.Reader.
-func (c *ClosingSig) Decode(r io.Reader, _ uint32) error {
-	// First, read out all the fields that are hard coded into the message.
-	err := ReadElements(r, &c.ChannelID)
-	if err != nil {
-		return err
-	}
-
-	// With the hard coded messages read, we'll now read out the TLV fields
-	// of the message.
-	var tlvRecords ExtraOpaqueData
-	if err := ReadElements(r, &tlvRecords); err != nil {
-		return err
-	}
-
-	if err := decodeClosingSigs(&c.ClosingSigs, tlvRecords); err != nil {
-		return err
-	}
-
-	if len(tlvRecords) != 0 {
-		c.ExtraData = tlvRecords
-	}
-
-	return nil
-}
-
-// Encode serializes the target ClosingSig into the passed io.Writer.
-func (c *ClosingSig) Encode(w *bytes.Buffer, _ uint32) error {
-	if err := WriteChannelID(w, c.ChannelID); err != nil {
-		return err
-	}
-
-	recordProducers := closingSigRecords(&c.ClosingSigs)
-
-	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)
-	if err != nil {
-		return err
-	}
-
-	return WriteBytes(w, c.ExtraData)
-}
-
-// MsgType returns the uint32 code which uniquely identifies this message as a
-// ClosingSig message on the wire.
-//
-// This is part of the lnwire.Message interface.
-func (c *ClosingSig) MsgType() MessageType {
-	return MsgClosingSig
-}
-
-// A compile time check to ensure ClosingSig implements the lnwire.Message
-// interface.
-var _ Message = (*ClosingSig)(nil)
diff --git a/lnwire/message.go b/lnwire/message.go
index 634f78ab3..bc79ed003 100644
--- a/lnwire/message.go
+++ b/lnwire/message.go
@@ -34,8 +34,6 @@ const (
 	MsgChannelReady                        = 36
 	MsgShutdown                            = 38
 	MsgClosingSigned                       = 39
-	MsgClosingComplete                     = 40
-	MsgClosingSig                          = 41
 	MsgDynPropose                          = 111
 	MsgDynAck                              = 113
 	MsgDynReject                           = 115
@@ -148,10 +146,6 @@ func (t MessageType) String() string {
 		return "ReplyChannelRange"
 	case MsgGossipTimestampRange:
 		return "GossipTimestampRange"
-	case MsgClosingComplete:
-		return "ClosingComplete"
-	case MsgClosingSig:
-		return "ClosingSig"
 	default:
 		return "<unknown>"
 	}
@@ -262,10 +256,6 @@ func makeEmptyMessage(msgType MessageType) (Message, error) {
 		msg = &ReplyChannelRange{}
 	case MsgGossipTimestampRange:
 		msg = &GossipTimestampRange{}
-	case MsgClosingComplete:
-		msg = &ClosingComplete{}
-	case MsgClosingSig:
-		msg = &ClosingSig{}
 	default:
 		// If the message is not within our custom range and has not
 		// specifically been overridden, return an unknown message.
diff --git a/lnwire/signature.go b/lnwire/signature.go
index 35b039ed0..db6d59052 100644
--- a/lnwire/signature.go
+++ b/lnwire/signature.go
@@ -7,7 +7,6 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/lightningnetwork/lnd/input"
-	"github.com/lightningnetwork/lnd/tlv"
 )
 
 var (
@@ -65,17 +64,6 @@ func (s *Sig) Copy() Sig {
 	return sCopy
 }
 
-// Record returns a Record that can be used to encode or decode the backing
-// object.
-//
-// This returns a record that serializes the sig as a 64-byte fixed size
-// signature.
-func (s *Sig) Record() tlv.Record {
-	// We set a type here as zero as it isn't needed when used as a
-	// RecordT.
-	return tlv.MakePrimitiveRecord(0, &s.bytes)
-}
-
 // NewSigFromWireECDSA returns a Sig instance based on an ECDSA signature
 // that's already in the 64-byte format we expect.
 func NewSigFromWireECDSA(sig []byte) (Sig, error) {
diff --git a/record/amp.go b/record/amp.go
index f63c7a141..eb431fec3 100644
--- a/record/amp.go
+++ b/record/amp.go
@@ -19,16 +19,6 @@ type AMP struct {
 	childIndex uint32
 }
 
-// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
-// the maximum payload size. The `childIndex` is created randomly and is a
-// 4 byte `varint` type so we make sure we use an index which will be encoded in
-// 4 bytes.
-var MaxAmpPayLoadSize = AMP{
-	rootShare:  [32]byte{},
-	setID:      [32]byte{},
-	childIndex: 0x80000000,
-}
-
 // NewAMP generate a new AMP record with the given root_share, set_id, and
 // child_index.
 func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {
diff --git a/routing/additional_edge.go b/routing/additional_edge.go
deleted file mode 100644
index 22cf3032b..000000000
--- a/routing/additional_edge.go
+++ /dev/null
@@ -1,107 +0,0 @@
-package routing
-
-import (
-	"errors"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/lightningnetwork/lnd/channeldb/models"
-	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/lightningnetwork/lnd/routing/route"
-)
-
-var (
-	// ErrNoPayLoadSizeFunc is returned when no payload size function is
-	// definied.
-	ErrNoPayLoadSizeFunc = errors.New("no payloadSizeFunc defined for " +
-		"additional edge")
-)
-
-// AdditionalEdge is an interface which specifies additional edges which can
-// be appended to an existing route. Compared to normal edges of a route they
-// provide an explicit payload size function and are introduced because blinded
-// paths differ in their payload structure.
-type AdditionalEdge interface {
-	// IntermediatePayloadSize returns the size of the payload for the
-	// additional edge when being an intermediate hop in a route NOT the
-	// final hop.
-	IntermediatePayloadSize(amount lnwire.MilliSatoshi, expiry uint32,
-		legacy bool, channelID uint64) uint64
-
-	// EdgePolicy returns the policy of the additional edge.
-	EdgePolicy() *models.CachedEdgePolicy
-}
-
-// PayloadSizeFunc defines the interface for the payload size function.
-type PayloadSizeFunc func(amount lnwire.MilliSatoshi, expiry uint32,
-	legacy bool, channelID uint64) uint64
-
-// PrivateEdge implements the AdditionalEdge interface. As the name implies it
-// is used for private route hints that the receiver adds for example to an
-// invoice.
-type PrivateEdge struct {
-	policy *models.CachedEdgePolicy
-}
-
-// EdgePolicy return the policy of the PrivateEdge.
-func (p *PrivateEdge) EdgePolicy() *models.CachedEdgePolicy {
-	return p.policy
-}
-
-// IntermediatePayloadSize returns the sphinx payload size defined in BOLT04 if
-// this edge were to be included in a route.
-func (p *PrivateEdge) IntermediatePayloadSize(amount lnwire.MilliSatoshi,
-	expiry uint32, legacy bool, channelID uint64) uint64 {
-
-	hop := route.Hop{
-		AmtToForward:     amount,
-		OutgoingTimeLock: expiry,
-		LegacyPayload:    legacy,
-	}
-
-	return hop.PayloadSize(channelID)
-}
-
-// BlindedEdge implements the AdditionalEdge interface. Blinded hops are viewed
-// as additional edges because they are appened at the end of a normal route.
-type BlindedEdge struct {
-	policy        *models.CachedEdgePolicy
-	cipherText    []byte
-	blindingPoint *btcec.PublicKey
-}
-
-// EdgePolicy return the policy of the BlindedEdge.
-func (b *BlindedEdge) EdgePolicy() *models.CachedEdgePolicy {
-	return b.policy
-}
-
-// IntermediatePayloadSize returns the sphinx payload size defined in BOLT04 if
-// this edge were to be included in a route.
-func (b *BlindedEdge) IntermediatePayloadSize(_ lnwire.MilliSatoshi, _ uint32,
-	_ bool, _ uint64) uint64 {
-
-	hop := route.Hop{
-		BlindingPoint: b.blindingPoint,
-		LegacyPayload: false,
-		EncryptedData: b.cipherText,
-	}
-
-	// For blinded paths the next chanID is in the encrypted data tlv.
-	return hop.PayloadSize(0)
-}
-
-// Compile-time constraints to ensure the PrivateEdge and the BlindedEdge
-// implement the AdditionalEdge interface.
-var _ AdditionalEdge = (*PrivateEdge)(nil)
-var _ AdditionalEdge = (*BlindedEdge)(nil)
-
-// defaultHopPayloadSize is the default payload size of a normal (not-blinded)
-// hop in the route.
-func defaultHopPayloadSize(amount lnwire.MilliSatoshi, expiry uint32,
-	legacy bool, channelID uint64) uint64 {
-
-	// The payload size of a cleartext intermediate hop is equal to the
-	// payload size of a private edge therefore we reuse its size function.
-	edge := PrivateEdge{}
-
-	return edge.IntermediatePayloadSize(amount, expiry, legacy, channelID)
-}
diff --git a/routing/blinding.go b/routing/blinding.go
index 61d303a0c..50d3b6f79 100644
--- a/routing/blinding.go
+++ b/routing/blinding.go
@@ -99,7 +99,7 @@ func (b *BlindedPayment) toRouteHints() RouteHints {
 
 	hintCount := len(b.BlindedPath.BlindedHops) - 1
 	hints := make(
-		RouteHints, hintCount,
+		map[route.Vertex][]*models.CachedEdgePolicy, hintCount,
 	)
 
 	// Start at the unblinded introduction node, because our pathfinding
@@ -116,31 +116,25 @@ func (b *BlindedPayment) toRouteHints() RouteHints {
 	// will ensure that pathfinding provides sufficient fees/delay for the
 	// blinded portion to the introduction node.
 	firstBlindedHop := b.BlindedPath.BlindedHops[1].BlindedNodePub
-	edgePolicy := &models.CachedEdgePolicy{
-		TimeLockDelta: b.CltvExpiryDelta,
-		MinHTLC:       lnwire.MilliSatoshi(b.HtlcMinimum),
-		MaxHTLC:       lnwire.MilliSatoshi(b.HtlcMaximum),
-		FeeBaseMSat:   lnwire.MilliSatoshi(b.BaseFee),
-		FeeProportionalMillionths: lnwire.MilliSatoshi(
-			b.ProportionalFee,
-		),
-		ToNodePubKey: func() route.Vertex {
-			return route.NewVertex(
-				// The first node in this slice is
-				// the introduction node, so we start
-				// at index 1 to get the first blinded
-				// relaying node.
-				firstBlindedHop,
-			)
-		},
-		ToNodeFeatures: features,
-	}
-
-	hints[fromNode] = []AdditionalEdge{
-		&BlindedEdge{
-			policy:        edgePolicy,
-			cipherText:    b.BlindedPath.BlindedHops[0].CipherText,
-			blindingPoint: b.BlindedPath.BlindingPoint,
+	hints[fromNode] = []*models.CachedEdgePolicy{
+		{
+			TimeLockDelta: b.CltvExpiryDelta,
+			MinHTLC:       lnwire.MilliSatoshi(b.HtlcMinimum),
+			MaxHTLC:       lnwire.MilliSatoshi(b.HtlcMaximum),
+			FeeBaseMSat:   lnwire.MilliSatoshi(b.BaseFee),
+			FeeProportionalMillionths: lnwire.MilliSatoshi(
+				b.ProportionalFee,
+			),
+			ToNodePubKey: func() route.Vertex {
+				return route.NewVertex(
+					// The first node in this slice is
+					// the introduction node, so we start
+					// at index 1 to get the first blinded
+					// relaying node.
+					firstBlindedHop,
+				)
+			},
+			ToNodeFeatures: features,
 		},
 	}
 
@@ -162,19 +156,15 @@ func (b *BlindedPayment) toRouteHints() RouteHints {
 			b.BlindedPath.BlindedHops[nextHopIdx].BlindedNodePub,
 		)
 
-		edgePolicy := &models.CachedEdgePolicy{
+		hint := &models.CachedEdgePolicy{
 			ToNodePubKey: func() route.Vertex {
 				return nextNode
 			},
 			ToNodeFeatures: features,
 		}
 
-		hints[fromNode] = []AdditionalEdge{
-			&BlindedEdge{
-				policy: edgePolicy,
-				cipherText: b.BlindedPath.BlindedHops[i].
-					CipherText,
-			},
+		hints[fromNode] = []*models.CachedEdgePolicy{
+			hint,
 		}
 	}
 
diff --git a/routing/mocks.go b/routing/mocks.go
deleted file mode 100644
index 9c019abc9..000000000
--- a/routing/mocks.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package routing
-
-import (
-	"github.com/lightningnetwork/lnd/channeldb/models"
-	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/stretchr/testify/mock"
-)
-
-// mockAdditionalEdge is a mock of the AdditionalEdge interface.
-type mockAdditionalEdge struct{ mock.Mock }
-
-// IntermediatePayloadSize returns the sphinx payload size defined in BOLT04 if
-// this edge were to be included in a route.
-func (m *mockAdditionalEdge) IntermediatePayloadSize(amount lnwire.MilliSatoshi,
-	expiry uint32, legacy bool, channelID uint64) uint64 {
-
-	args := m.Called(amount, expiry, legacy, channelID)
-
-	return args.Get(0).(uint64)
-}
-
-// EdgePolicy return the policy of the mockAdditionalEdge.
-func (m *mockAdditionalEdge) EdgePolicy() *models.CachedEdgePolicy {
-	args := m.Called()
-
-	edgePolicy := args.Get(0)
-	if edgePolicy == nil {
-		return nil
-	}
-
-	return edgePolicy.(*models.CachedEdgePolicy)
-}
diff --git a/routing/pathfind.go b/routing/pathfind.go
index 53eb0dfb4..642dab90b 100644
--- a/routing/pathfind.go
+++ b/routing/pathfind.go
@@ -88,7 +88,7 @@ var (
 // of the edge.
 type edgePolicyWithSource struct {
 	sourceNode route.Vertex
-	edge       AdditionalEdge
+	edge       *models.CachedEdgePolicy
 }
 
 // finalHopParams encapsulates various parameters for route construction that
@@ -355,9 +355,8 @@ type graphParams struct {
 
 	// additionalEdges is an optional set of edges that should be
 	// considered during path finding, that is not already found in the
-	// channel graph. These can either be private edges for bolt 11 invoices
-	// or blinded edges when a payment to a blinded path is made.
-	additionalEdges map[route.Vertex][]AdditionalEdge
+	// channel graph.
+	additionalEdges map[route.Vertex][]*models.CachedEdgePolicy
 
 	// bandwidthHints is an interface that provides bandwidth hints that
 	// can provide a better estimate of the current channel bandwidth than
@@ -408,18 +407,9 @@ type RestrictParams struct {
 	// invoices.
 	PaymentAddr *[32]byte
 
-	// Amp signals to the pathfinder that this payment is an AMP payment
-	// and therefore it needs to account for additional AMP data in the
-	// final hop payload size calculation.
-	Amp *AMPOptions
-
 	// Metadata is additional data that is sent along with the payment to
 	// the payee.
 	Metadata []byte
-
-	// BlindedPayment is necessary to determine the hop size of the
-	// last/exit hop.
-	BlindedPayment *BlindedPayment
 }
 
 // PathFindingConfig defines global parameters that control the trade-off in
@@ -619,7 +609,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 	distance := make(map[route.Vertex]*nodeWithDist, estimatedNodeCount)
 
 	additionalEdgesWithSrc := make(map[route.Vertex][]*edgePolicyWithSource)
-	for vertex, additionalEdges := range g.additionalEdges {
+	for vertex, outgoingEdgePolicies := range g.additionalEdges {
 		// Edges connected to self are always included in the graph,
 		// therefore can be skipped. This prevents us from trying
 		// routes to malformed hop hints.
@@ -629,13 +619,12 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 
 		// Build reverse lookup to find incoming edges. Needed because
 		// search is taken place from target to source.
-		for _, additionalEdge := range additionalEdges {
-			outgoingEdgePolicy := additionalEdge.EdgePolicy()
+		for _, outgoingEdgePolicy := range outgoingEdgePolicies {
 			toVertex := outgoingEdgePolicy.ToNodePubKey()
 
 			incomingEdgePolicy := &edgePolicyWithSource{
 				sourceNode: vertex,
-				edge:       additionalEdge,
+				edge:       outgoingEdgePolicy,
 			}
 
 			additionalEdgesWithSrc[toVertex] =
@@ -644,10 +633,23 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		}
 	}
 
-	// The payload size of the final hop differ from intermediate hops
-	// and depends on whether the destination is blinded or not.
-	lastHopPayloadSize := lastHopPayloadSize(r, finalHtlcExpiry, amt,
-		!features.HasFeature(lnwire.TLVOnionPayloadOptional))
+	// Build a preliminary destination hop structure to obtain the payload
+	// size.
+	var mpp *record.MPP
+	if r.PaymentAddr != nil {
+		mpp = record.NewMPP(amt, *r.PaymentAddr)
+	}
+
+	finalHop := route.Hop{
+		AmtToForward:     amt,
+		OutgoingTimeLock: uint32(finalHtlcExpiry),
+		CustomRecords:    r.DestCustomRecords,
+		LegacyPayload: !features.HasFeature(
+			lnwire.TLVOnionPayloadOptional,
+		),
+		MPP:      mpp,
+		Metadata: r.Metadata,
+	}
 
 	// We can't always assume that the end destination is publicly
 	// advertised to the network so we'll manually include the target node.
@@ -665,7 +667,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		amountToReceive: amt,
 		incomingCltv:    finalHtlcExpiry,
 		probability:     1,
-		routingInfoSize: lastHopPayloadSize,
+		routingInfoSize: finalHop.PayloadSize(0),
 	}
 
 	// Calculate the absolute cltv limit. Use uint64 to prevent an overflow
@@ -819,30 +821,23 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		// blob.
 		var payloadSize uint64
 		if fromVertex != source {
-			// In case the unifiedEdge does not have a payload size
-			// function supplied we request a graceful shutdown
-			// because this should never happen.
-			if edge.hopPayloadSizeFn == nil {
-				log.Criticalf("No payload size function "+
-					"available for edge=%v unable to "+
-					"determine payload size: %v", edge,
-					ErrNoPayLoadSizeFunc)
-
-				return
-			}
-
 			supportsTlv := fromFeatures.HasFeature(
 				lnwire.TLVOnionPayloadOptional,
 			)
 
-			payloadSize = edge.hopPayloadSizeFn(
-				amountToSend,
-				uint32(toNodeDist.incomingCltv),
-				!supportsTlv, edge.policy.ChannelID,
-			)
+			hop := route.Hop{
+				AmtToForward: amountToSend,
+				OutgoingTimeLock: uint32(
+					toNodeDist.incomingCltv,
+				),
+				LegacyPayload: !supportsTlv,
+			}
+
+			payloadSize = hop.PayloadSize(edge.policy.ChannelID)
 		}
 
 		routingInfoSize := toNodeDist.routingInfoSize + payloadSize
+
 		// Skip paths that would exceed the maximum routing info size.
 		if routingInfoSize > sphinx.MaxPayloadSize {
 			return
@@ -935,14 +930,9 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 			// calculations. We set a high capacity to act as if
 			// there is enough liquidity, otherwise the hint would
 			// not have been added by a wallet.
-			// We also pass the payload size function to the
-			// graph data so that we calculate the exact payload
-			// size when evaluating this hop for a route.
 			u.addPolicy(
-				reverseEdge.sourceNode,
-				reverseEdge.edge.EdgePolicy(),
+				reverseEdge.sourceNode, reverseEdge.edge,
 				fakeHopHintCapacity,
-				reverseEdge.edge.IntermediatePayloadSize,
 			)
 		}
 
@@ -1108,55 +1098,3 @@ func getProbabilityBasedDist(weight int64, probability float64,
 
 	return int64(dist)
 }
-
-// lastHopPayloadSize calculates the payload size of the final hop in a route.
-// It depends on the tlv types which are present and also whether the hop is
-// part of a blinded route or not.
-func lastHopPayloadSize(r *RestrictParams, finalHtlcExpiry int32,
-	amount lnwire.MilliSatoshi, legacy bool) uint64 {
-
-	if r.BlindedPayment != nil {
-		blindedPath := r.BlindedPayment.BlindedPath.BlindedHops
-		blindedPoint := r.BlindedPayment.BlindedPath.BlindingPoint
-
-		encryptedData := blindedPath[len(blindedPath)-1].CipherText
-		finalHop := route.Hop{
-			AmtToForward:     amount,
-			OutgoingTimeLock: uint32(finalHtlcExpiry),
-			LegacyPayload:    false,
-			EncryptedData:    encryptedData,
-		}
-		if len(blindedPath) == 1 {
-			finalHop.BlindingPoint = blindedPoint
-		}
-
-		// The final hop does not have a short chanID set.
-		return finalHop.PayloadSize(0)
-	}
-
-	var mpp *record.MPP
-	if r.PaymentAddr != nil {
-		mpp = record.NewMPP(amount, *r.PaymentAddr)
-	}
-
-	var amp *record.AMP
-	if r.Amp != nil {
-		// The AMP payload is not easy accessible at this point but we
-		// are only interested in the size of the payload so we just use
-		// the AMP record dummy.
-		amp = &record.MaxAmpPayLoadSize
-	}
-
-	finalHop := route.Hop{
-		AmtToForward:     amount,
-		OutgoingTimeLock: uint32(finalHtlcExpiry),
-		CustomRecords:    r.DestCustomRecords,
-		LegacyPayload:    legacy,
-		MPP:              mpp,
-		AMP:              amp,
-		Metadata:         r.Metadata,
-	}
-
-	// The final hop does not have a short chanID set.
-	return finalHop.PayloadSize(0)
-}
diff --git a/routing/payment_lifecycle.go b/routing/payment_lifecycle.go
index e3bf77170..9853f8fd9 100644
--- a/routing/payment_lifecycle.go
+++ b/routing/payment_lifecycle.go
@@ -628,7 +628,7 @@ func (p *paymentLifecycle) createNewPaymentAttempt(rt *route.Route,
 		return nil, err
 	}
 
-	// If this shard carries MPP or AMP options, add them to the last hop
+	// It this shard carries MPP or AMP options, add them to the last hop
 	// on the route.
 	hop := rt.Hops[len(rt.Hops)-1]
 	if shard.MPP() != nil {
diff --git a/routing/payment_session.go b/routing/payment_session.go
index 2d174244c..a04a4de55 100644
--- a/routing/payment_session.go
+++ b/routing/payment_session.go
@@ -163,7 +163,7 @@ type PaymentSession interface {
 // loop if payment attempts take long enough. An additional set of edges can
 // also be provided to assist in reaching the payment's destination.
 type paymentSession struct {
-	additionalEdges map[route.Vertex][]AdditionalEdge
+	additionalEdges map[route.Vertex][]*models.CachedEdgePolicy
 
 	getBandwidthHints func(routingGraph) (bandwidthHints, error)
 
@@ -258,7 +258,6 @@ func (p *paymentSession) RequestRoute(maxAmt, feeLimit lnwire.MilliSatoshi,
 		DestCustomRecords:  p.payment.DestCustomRecords,
 		DestFeatures:       p.payment.DestFeatures,
 		PaymentAddr:        p.payment.PaymentAddr,
-		Amp:                p.payment.amp,
 		Metadata:           p.payment.Metadata,
 	}
 
@@ -442,12 +441,11 @@ func (p *paymentSession) GetAdditionalEdgePolicy(pubKey *btcec.PublicKey,
 	}
 
 	for _, edge := range edges {
-		policy := edge.EdgePolicy()
-		if policy.ChannelID != channelID {
+		if edge.ChannelID != channelID {
 			continue
 		}
 
-		return policy
+		return edge
 	}
 
 	return nil
diff --git a/routing/payment_session_source.go b/routing/payment_session_source.go
index b96a2294b..229c932f3 100644
--- a/routing/payment_session_source.go
+++ b/routing/payment_session_source.go
@@ -95,9 +95,9 @@ func (m *SessionSource) NewPaymentSessionEmpty() PaymentSession {
 // RouteHintsToEdges converts a list of invoice route hints to an edge map that
 // can be passed into pathfinding.
 func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
-	map[route.Vertex][]AdditionalEdge, error) {
+	map[route.Vertex][]*models.CachedEdgePolicy, error) {
 
-	edges := make(map[route.Vertex][]AdditionalEdge)
+	edges := make(map[route.Vertex][]*models.CachedEdgePolicy)
 
 	// Traverse through all of the available hop hints and include them in
 	// our edges map, indexed by the public key of the channel's starting
@@ -127,7 +127,7 @@ func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
 			// Finally, create the channel edge from the hop hint
 			// and add it to list of edges corresponding to the node
 			// at the start of the channel.
-			edgePolicy := &models.CachedEdgePolicy{
+			edge := &models.CachedEdgePolicy{
 				ToNodePubKey: func() route.Vertex {
 					return endNode.PubKeyBytes
 				},
@@ -142,10 +142,6 @@ func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
 				TimeLockDelta: hopHint.CLTVExpiryDelta,
 			}
 
-			edge := &PrivateEdge{
-				policy: edgePolicy,
-			}
-
 			v := route.NewVertex(hopHint.NodeID)
 			edges[v] = append(edges[v], edge)
 		}
diff --git a/routing/router.go b/routing/router.go
index 00c0ded57..c602573eb 100644
--- a/routing/router.go
+++ b/routing/router.go
@@ -1954,7 +1954,7 @@ type RouteRequest struct {
 
 // RouteHints is an alias type for a set of route hints, with the source node
 // as the map's key and the details of the hint(s) in the edge policy.
-type RouteHints map[route.Vertex][]AdditionalEdge
+type RouteHints map[route.Vertex][]*models.CachedEdgePolicy
 
 // NewRouteRequest produces a new route request for a regular payment or one
 // to a blinded route, validating that the target, routeHints and finalExpiry
diff --git a/routing/unified_edges.go b/routing/unified_edges.go
index c828e9a6e..aee168348 100644
--- a/routing/unified_edges.go
+++ b/routing/unified_edges.go
@@ -40,12 +40,9 @@ func newNodeEdgeUnifier(sourceNode, toNode route.Vertex,
 }
 
 // addPolicy adds a single channel policy. Capacity may be zero if unknown
-// (light clients). We expect a non-nil payload size function and will request a
-// graceful shutdown if it is not provided as this indicates that edges are
-// incorrectly specified.
+// (light clients).
 func (u *nodeEdgeUnifier) addPolicy(fromNode route.Vertex,
-	edge *models.CachedEdgePolicy, capacity btcutil.Amount,
-	hopPayloadSizeFn PayloadSizeFunc) {
+	edge *models.CachedEdgePolicy, capacity btcutil.Amount) {
 
 	localChan := fromNode == u.sourceNode
 
@@ -65,20 +62,9 @@ func (u *nodeEdgeUnifier) addPolicy(fromNode route.Vertex,
 		u.edgeUnifiers[fromNode] = unifier
 	}
 
-	// In case no payload size function was provided a graceful shutdown
-	// is requested, because this function is not used as intended.
-	if hopPayloadSizeFn == nil {
-		log.Criticalf("No payloadsize function was provided for the "+
-			"edge (chanid=%v) when adding it to the edge unifier "+
-			"of node: %v", edge.ChannelID, fromNode)
-
-		return
-	}
-
 	unifier.edges = append(unifier.edges, &unifiedEdge{
-		policy:           edge,
-		capacity:         capacity,
-		hopPayloadSizeFn: hopPayloadSizeFn,
+		policy:   edge,
+		capacity: capacity,
 	})
 }
 
@@ -93,13 +79,9 @@ func (u *nodeEdgeUnifier) addGraphPolicies(g routingGraph) error {
 			return nil
 		}
 
-		// Add this policy to the corresponding edgeUnifier. We default
-		// to the clear hop payload size function because
-		// `addGraphPolicies` is only used for cleartext intermediate
-		// hops in a route.
+		// Add this policy to the corresponding edgeUnifier.
 		u.addPolicy(
 			channel.OtherNode, channel.InPolicy, channel.Capacity,
-			defaultHopPayloadSize,
 		)
 
 		return nil
@@ -114,12 +96,6 @@ func (u *nodeEdgeUnifier) addGraphPolicies(g routingGraph) error {
 type unifiedEdge struct {
 	policy   *models.CachedEdgePolicy
 	capacity btcutil.Amount
-
-	// hopPayloadSize supplies an edge with the ability to calculate the
-	// exact payload size if this edge would be included in a route. This
-	// is needed because hops of a blinded path differ in their payload
-	// structure compared to cleartext hops.
-	hopPayloadSizeFn PayloadSizeFunc
 }
 
 // amtInRange checks whether an amount falls within the valid range for a
@@ -226,7 +202,6 @@ func (u *edgeUnifier) getEdgeLocal(amt lnwire.MilliSatoshi,
 			log.Debugf("Skipped edge %v: not enough bandwidth, "+
 				"bandwidth=%v, amt=%v", edge.policy.ChannelID,
 				bandwidth, amt)
-
 			continue
 		}
 
@@ -239,16 +214,14 @@ func (u *edgeUnifier) getEdgeLocal(amt lnwire.MilliSatoshi,
 			log.Debugf("Skipped edge %v: not max bandwidth, "+
 				"bandwidth=%v, maxBandwidth=%v",
 				bandwidth, maxBandwidth)
-
 			continue
 		}
 		maxBandwidth = bandwidth
 
 		// Update best edge.
 		bestEdge = &unifiedEdge{
-			policy:           edge.policy,
-			capacity:         edge.capacity,
-			hopPayloadSizeFn: edge.hopPayloadSizeFn,
+			policy:   edge.policy,
+			capacity: edge.capacity,
 		}
 	}
 
@@ -261,11 +234,10 @@ func (u *edgeUnifier) getEdgeLocal(amt lnwire.MilliSatoshi,
 // forwarding context.
 func (u *edgeUnifier) getEdgeNetwork(amt lnwire.MilliSatoshi) *unifiedEdge {
 	var (
-		bestPolicy       *models.CachedEdgePolicy
-		maxFee           lnwire.MilliSatoshi
-		maxTimelock      uint16
-		maxCapMsat       lnwire.MilliSatoshi
-		hopPayloadSizeFn PayloadSizeFunc
+		bestPolicy  *models.CachedEdgePolicy
+		maxFee      lnwire.MilliSatoshi
+		maxTimelock uint16
+		maxCapMsat  lnwire.MilliSatoshi
 	)
 
 	for _, edge := range u.edges {
@@ -302,6 +274,7 @@ func (u *edgeUnifier) getEdgeNetwork(amt lnwire.MilliSatoshi) *unifiedEdge {
 		maxTimelock = lntypes.Max(
 			maxTimelock, edge.policy.TimeLockDelta,
 		)
+
 		// Use the policy that results in the highest fee for this
 		// specific amount.
 		fee := edge.policy.ComputeFee(amt)
@@ -309,17 +282,11 @@ func (u *edgeUnifier) getEdgeNetwork(amt lnwire.MilliSatoshi) *unifiedEdge {
 			log.Debugf("Skipped edge %v due to it produces less "+
 				"fee: fee=%v, maxFee=%v",
 				edge.policy.ChannelID, fee, maxFee)
-
 			continue
 		}
 		maxFee = fee
 
 		bestPolicy = edge.policy
-		// The payload size function for edges to a connected peer is
-		// always the same hence there is not need to find the maximum.
-		// This also counts for blinded edges where we only have one
-		// edge to a blinded peer.
-		hopPayloadSizeFn = edge.hopPayloadSizeFn
 	}
 
 	// Return early if no channel matches.
@@ -341,7 +308,6 @@ func (u *edgeUnifier) getEdgeNetwork(amt lnwire.MilliSatoshi) *unifiedEdge {
 	modifiedEdge := unifiedEdge{policy: &policyCopy}
 	modifiedEdge.policy.TimeLockDelta = maxTimelock
 	modifiedEdge.capacity = maxCapMsat.ToSatoshis()
-	modifiedEdge.hopPayloadSizeFn = hopPayloadSizeFn
 
 	return &modifiedEdge
 }
diff --git a/rpcserver.go b/rpcserver.go
index e415606b7..370dfd992 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -5796,12 +5796,20 @@ func (r *rpcServer) ListInvoices(ctx context.Context,
 	// Next, we'll map the proto request into a format that is understood by
 	// the database.
 	q := invoices.InvoiceQuery{
-		IndexOffset:       req.IndexOffset,
-		NumMaxInvoices:    req.NumMaxInvoices,
-		PendingOnly:       req.PendingOnly,
-		Reversed:          req.Reversed,
-		CreationDateStart: int64(req.CreationDateStart),
-		CreationDateEnd:   int64(req.CreationDateEnd),
+		IndexOffset:    req.IndexOffset,
+		NumMaxInvoices: req.NumMaxInvoices,
+		PendingOnly:    req.PendingOnly,
+		Reversed:       req.Reversed,
+	}
+
+	// Attach the start date if set.
+	if req.CreationDateStart != 0 {
+		q.CreationDateStart = time.Unix(int64(req.CreationDateStart), 0)
+	}
+
+	// Attach the end date if set.
+	if req.CreationDateEnd != 0 {
+		q.CreationDateEnd = time.Unix(int64(req.CreationDateEnd), 0)
 	}
 
 	invoiceSlice, err := r.server.miscDB.QueryInvoices(ctx, q)
@@ -6637,8 +6645,20 @@ func (r *rpcServer) ListPayments(ctx context.Context,
 		Reversed:          req.Reversed,
 		IncludeIncomplete: req.IncludeIncomplete,
 		CountTotal:        req.CountTotalPayments,
-		CreationDateStart: int64(req.CreationDateStart),
-		CreationDateEnd:   int64(req.CreationDateEnd),
+	}
+
+	// Attach the start date if set.
+	if req.CreationDateStart != 0 {
+		query.CreationDateStart = time.Unix(
+			int64(req.CreationDateStart), 0,
+		)
+	}
+
+	// Attach the end date if set.
+	if req.CreationDateEnd != 0 {
+		query.CreationDateEnd = time.Unix(
+			int64(req.CreationDateEnd), 0,
+		)
 	}
 
 	// If the maximum number of payments wasn't specified, then we'll
diff --git a/server.go b/server.go
index b8ca7bdb8..f7f78d6dd 100644
--- a/server.go
+++ b/server.go
@@ -262,7 +262,7 @@ type server struct {
 
 	witnessBeacon contractcourt.WitnessBeacon
 
-	breachArbiter *contractcourt.BreachArbiter
+	breachArbitrator *contractcourt.BreachArbitrator
 
 	missionControl *routing.MissionControl
 
@@ -1099,22 +1099,24 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 	}
 
 	// We will use the following channel to reliably hand off contract
-	// breach events from the ChannelArbitrator to the breachArbiter,
+	// breach events from the ChannelArbitrator to the BreachArbitrator,
 	contractBreaches := make(chan *contractcourt.ContractBreachEvent, 1)
 
-	s.breachArbiter = contractcourt.NewBreachArbiter(&contractcourt.BreachConfig{
-		CloseLink:          closeLink,
-		DB:                 s.chanStateDB,
-		Estimator:          s.cc.FeeEstimator,
-		GenSweepScript:     newSweepPkScriptGen(cc.Wallet),
-		Notifier:           cc.ChainNotifier,
-		PublishTransaction: cc.Wallet.PublishTransaction,
-		ContractBreaches:   contractBreaches,
-		Signer:             cc.Wallet.Cfg.Signer,
-		Store: contractcourt.NewRetributionStore(
-			dbs.ChanStateDB,
-		),
-	})
+	s.breachArbitrator = contractcourt.NewBreachArbitrator(
+		&contractcourt.BreachConfig{
+			CloseLink:          closeLink,
+			DB:                 s.chanStateDB,
+			Estimator:          s.cc.FeeEstimator,
+			GenSweepScript:     newSweepPkScriptGen(cc.Wallet),
+			Notifier:           cc.ChainNotifier,
+			PublishTransaction: cc.Wallet.PublishTransaction,
+			ContractBreaches:   contractBreaches,
+			Signer:             cc.Wallet.Cfg.Signer,
+			Store: contractcourt.NewRetributionStore(
+				dbs.ChanStateDB,
+			),
+		},
+	)
 
 	s.chainArb = contractcourt.NewChainArbitrator(contractcourt.ChainArbitratorConfig{
 		ChainHash:              *s.cfg.ActiveNetParams.GenesisHash,
@@ -1167,8 +1169,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 		ContractBreach: func(chanPoint wire.OutPoint,
 			breachRet *lnwallet.BreachRetribution) error {
 
-			// processACK will handle the breachArbiter ACKing the
-			// event.
+			// processACK will handle the BreachArbitrator ACKing
+			// the event.
 			finalErr := make(chan error, 1)
 			processACK := func(brarErr error) {
 				if brarErr != nil {
@@ -1176,7 +1178,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 					return
 				}
 
-				// If the breachArbiter successfully handled
+				// If the BreachArbitrator successfully handled
 				// the event, we can signal that the handoff
 				// was successful.
 				finalErr <- nil
@@ -1188,7 +1190,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 				BreachRetribution: breachRet,
 			}
 
-			// Send the contract breach event to the breachArbiter.
+			// Send the contract breach event to the
+			// BreachArbitrator.
 			select {
 			case contractBreaches <- event:
 			case <-s.quit:
@@ -1196,7 +1199,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 			}
 
 			// We'll wait for a final error to be available from
-			// the breachArbiter.
+			// the BreachArbitrator.
 			select {
 			case err := <-finalErr:
 				return err
@@ -1215,8 +1218,8 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 		PaymentsExpirationGracePeriod: cfg.PaymentsExpirationGracePeriod,
 		IsForwardedHTLC:               s.htlcSwitch.IsForwardedHTLC,
 		Clock:                         clock.NewDefaultClock(),
-		SubscribeBreachComplete:       s.breachArbiter.SubscribeBreachComplete,
-		PutFinalHtlcOutcome:           s.chanStateDB.PutOnchainFinalHtlcOutcome, //nolint: lll
+		SubscribeBreachComplete:       s.breachArbitrator.SubscribeBreachComplete, //nolint:lll
+		PutFinalHtlcOutcome:           s.chanStateDB.PutOnchainFinalHtlcOutcome,   //nolint: lll
 		HtlcNotifier:                  s.htlcNotifier,
 	}, dbs.ChanStateDB)
 
@@ -1936,11 +1939,11 @@ func (s *server) Start() error {
 		}
 		cleanup = cleanup.add(s.utxoNursery.Stop)
 
-		if err := s.breachArbiter.Start(); err != nil {
+		if err := s.breachArbitrator.Start(); err != nil {
 			startErr = err
 			return
 		}
-		cleanup = cleanup.add(s.breachArbiter.Stop)
+		cleanup = cleanup.add(s.breachArbitrator.Stop)
 
 		if err := s.fundingMgr.Start(); err != nil {
 			startErr = err
@@ -2244,8 +2247,9 @@ func (s *server) Stop() error {
 		if err := s.fundingMgr.Stop(); err != nil {
 			srvrLog.Warnf("failed to stop fundingMgr: %v", err)
 		}
-		if err := s.breachArbiter.Stop(); err != nil {
-			srvrLog.Warnf("failed to stop breachArbiter: %v", err)
+		if err := s.breachArbitrator.Stop(); err != nil {
+			srvrLog.Warnf("failed to stop breachArbitrator: %v",
+				err)
 		}
 		if err := s.utxoNursery.Stop(); err != nil {
 			srvrLog.Warnf("failed to stop utxoNursery: %v", err)
diff --git a/tlv/record_type.go b/tlv/record_type.go
index 248ebc415..6540f8d8e 100644
--- a/tlv/record_type.go
+++ b/tlv/record_type.go
@@ -87,11 +87,6 @@ func (t *RecordT[T, V]) TlvType() Type {
 	return t.recordType.TypeVal()
 }
 
-// Zero returns a zero value of the record type.
-func (t *RecordT[T, V]) Zero() RecordT[T, V] {
-	return ZeroRecordT[T, V]()
-}
-
 // OptionalRecordT is a high-order type that represents an optional TLV record.
 // This can be used when a TLV record doesn't always need to be present (ok to
 // be odd).


Test patch:
diff --git a/channeldb/invoice_test.go b/channeldb/invoice_test.go
index d7bbc5b5c..3f189c8fa 100644
--- a/channeldb/invoice_test.go
+++ b/channeldb/invoice_test.go
@@ -1407,7 +1407,7 @@ func TestQueryInvoices(t *testing.T) {
 		{
 			query: invpkg.InvoiceQuery{
 				NumMaxInvoices:  numInvoices,
-				CreationDateEnd: 25,
+				CreationDateEnd: time.Unix(25, 0),
 			},
 			expected: invoices[:25],
 		},
@@ -1415,7 +1415,7 @@ func TestQueryInvoices(t *testing.T) {
 		{
 			query: invpkg.InvoiceQuery{
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 26,
+				CreationDateStart: time.Unix(26, 0),
 			},
 			expected: invoices[25:],
 		},
@@ -1424,7 +1424,7 @@ func TestQueryInvoices(t *testing.T) {
 			query: invpkg.InvoiceQuery{
 				PendingOnly:     true,
 				NumMaxInvoices:  numInvoices,
-				CreationDateEnd: 25,
+				CreationDateEnd: time.Unix(25, 0),
 			},
 			expected: pendingInvoices[:13],
 		},
@@ -1433,7 +1433,7 @@ func TestQueryInvoices(t *testing.T) {
 			query: invpkg.InvoiceQuery{
 				PendingOnly:       true,
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 26,
+				CreationDateStart: time.Unix(26, 0),
 			},
 			expected: pendingInvoices[13:],
 		},
@@ -1442,7 +1442,7 @@ func TestQueryInvoices(t *testing.T) {
 			query: invpkg.InvoiceQuery{
 				IndexOffset:     20,
 				NumMaxInvoices:  numInvoices,
-				CreationDateEnd: 30,
+				CreationDateEnd: time.Unix(30, 0),
 			},
 			// Since we're skipping to invoice 20 and iterating
 			// to invoice 30, we'll expect those invoices.
@@ -1455,7 +1455,7 @@ func TestQueryInvoices(t *testing.T) {
 				IndexOffset:       21,
 				Reversed:          true,
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 11,
+				CreationDateStart: time.Unix(11, 0),
 			},
 			// Since we're skipping to invoice 20 and iterating
 			// backward to invoice 10, we'll expect those invoices.
@@ -1465,8 +1465,8 @@ func TestQueryInvoices(t *testing.T) {
 		{
 			query: invpkg.InvoiceQuery{
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 11,
-				CreationDateEnd:   20,
+				CreationDateStart: time.Unix(11, 0),
+				CreationDateEnd:   time.Unix(20, 0),
 			},
 			expected: invoices[10:20],
 		},
@@ -1475,8 +1475,8 @@ func TestQueryInvoices(t *testing.T) {
 			query: invpkg.InvoiceQuery{
 				PendingOnly:       true,
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 11,
-				CreationDateEnd:   20,
+				CreationDateStart: time.Unix(11, 0),
+				CreationDateEnd:   time.Unix(20, 0),
 			},
 			expected: pendingInvoices[5:10],
 		},
@@ -1486,8 +1486,8 @@ func TestQueryInvoices(t *testing.T) {
 			query: invpkg.InvoiceQuery{
 				Reversed:          true,
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 11,
-				CreationDateEnd:   20,
+				CreationDateStart: time.Unix(11, 0),
+				CreationDateEnd:   time.Unix(20, 0),
 			},
 			expected: invoices[10:20],
 		},
@@ -1498,8 +1498,8 @@ func TestQueryInvoices(t *testing.T) {
 				PendingOnly:       true,
 				Reversed:          true,
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 11,
-				CreationDateEnd:   20,
+				CreationDateStart: time.Unix(11, 0),
+				CreationDateEnd:   time.Unix(20, 0),
 			},
 			expected: pendingInvoices[5:10],
 		},
@@ -1508,8 +1508,8 @@ func TestQueryInvoices(t *testing.T) {
 		{
 			query: invpkg.InvoiceQuery{
 				NumMaxInvoices:    numInvoices,
-				CreationDateStart: 20,
-				CreationDateEnd:   11,
+				CreationDateStart: time.Unix(20, 0),
+				CreationDateEnd:   time.Unix(11, 0),
 			},
 			expected: nil,
 		},
diff --git a/channeldb/payments_test.go b/channeldb/payments_test.go
index 769f4cc77..37a7e30e7 100644
--- a/channeldb/payments_test.go
+++ b/channeldb/payments_test.go
@@ -438,7 +438,7 @@ func TestQueryPayments(t *testing.T) {
 				MaxPayments:       2,
 				Reversed:          false,
 				IncludeIncomplete: true,
-				CreationDateStart: 5,
+				CreationDateStart: time.Unix(0, 5),
 			},
 			firstIndex:     5,
 			lastIndex:      6,
@@ -452,7 +452,7 @@ func TestQueryPayments(t *testing.T) {
 				MaxPayments:       2,
 				Reversed:          false,
 				IncludeIncomplete: true,
-				CreationDateStart: 7,
+				CreationDateStart: time.Unix(0, 7),
 			},
 			firstIndex:     7,
 			lastIndex:      7,
@@ -465,8 +465,8 @@ func TestQueryPayments(t *testing.T) {
 				MaxPayments:       math.MaxUint64,
 				Reversed:          true,
 				IncludeIncomplete: true,
-				CreationDateStart: 3,
-				CreationDateEnd:   5,
+				CreationDateStart: time.Unix(0, 3),
+				CreationDateEnd:   time.Unix(0, 5),
 			},
 			firstIndex:     3,
 			lastIndex:      5,
@@ -509,7 +509,7 @@ func TestQueryPayments(t *testing.T) {
 				}
 				// Override creation time to allow for testing
 				// of CreationDateStart and CreationDateEnd.
-				info.CreationTime = time.Unix(int64(i+1), 0)
+				info.CreationTime = time.Unix(0, int64(i+1))
 
 				// Create a new payment entry in the database.
 				err = pControl.InitPayment(info.PaymentIdentifier, info)
diff --git a/contractcourt/breacharbiter_test.go b/contractcourt/breach_arbitrator_test.go
similarity index 99%
rename from contractcourt/breacharbiter_test.go
rename to contractcourt/breach_arbitrator_test.go
index 78fa9d707..29f33881a 100644
--- a/contractcourt/breacharbiter_test.go
+++ b/contractcourt/breach_arbitrator_test.go
@@ -951,7 +951,7 @@ restartCheck:
 	}
 }
 
-func initBreachedState(t *testing.T) (*BreachArbiter,
+func initBreachedState(t *testing.T) (*BreachArbitrator,
 	*lnwallet.LightningChannel, *lnwallet.LightningChannel,
 	*lnwallet.LocalForceCloseSummary, chan *ContractBreachEvent) {
 
@@ -1338,7 +1338,7 @@ func getSpendTransactions(signer input.Signer, chanPoint *wire.OutPoint,
 		},
 	}
 
-	// In order for  the breacharbiter to detect that it is being spent
+	// In order for  the BreachArbitrator to detect that it is being spent
 	// using the revocation key, it will inspect the witness. Therefore
 	// sign and add the witness to the HTLC sweep.
 	retInfo := newRetributionInfo(chanPoint, retribution)
@@ -1684,7 +1684,7 @@ func testBreachSpends(t *testing.T, test breachTest) {
 	}
 
 	// We also keep a map of those remaining outputs we expect the
-	// breacharbiter to try and sweep.
+	// BreachArbitrator to try and sweep.
 	inputsToSweep := map[wire.OutPoint]struct{}{
 		htlcOutpoint:   {},
 		localOutpoint:  {},
@@ -1892,7 +1892,7 @@ func TestBreachDelayedJusticeConfirmation(t *testing.T) {
 	}
 
 	// Now mine another block without the justice tx confirming. This
-	// should lead to the breacharbiter publishing the split justice tx
+	// should lead to the BreachArbitrator publishing the split justice tx
 	// variants.
 	notifier.EpochChan <- &chainntnfs.BlockEpoch{
 		Height: blockHeight + 4,
@@ -1988,7 +1988,7 @@ func findInputIndex(t *testing.T, op wire.OutPoint, tx *wire.MsgTx) int {
 
 // assertArbiterBreach checks that the breach arbiter has persisted the breach
 // information for a particular channel.
-func assertArbiterBreach(t *testing.T, brar *BreachArbiter,
+func assertArbiterBreach(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint) {
 
 	t.Helper()
@@ -2008,7 +2008,7 @@ func assertArbiterBreach(t *testing.T, brar *BreachArbiter,
 
 // assertNoArbiterBreach checks that the breach arbiter has not persisted the
 // breach information for a particular channel.
-func assertNoArbiterBreach(t *testing.T, brar *BreachArbiter,
+func assertNoArbiterBreach(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint) {
 
 	t.Helper()
@@ -2027,7 +2027,7 @@ func assertNoArbiterBreach(t *testing.T, brar *BreachArbiter,
 
 // assertBrarCleanup blocks until the given channel point has been removed the
 // retribution store and the channel is fully closed in the database.
-func assertBrarCleanup(t *testing.T, brar *BreachArbiter,
+func assertBrarCleanup(t *testing.T, brar *BreachArbitrator,
 	chanPoint *wire.OutPoint, db *channeldb.ChannelStateDB) {
 
 	t.Helper()
@@ -2108,7 +2108,7 @@ func assertNotPendingClosed(t *testing.T, c *lnwallet.LightningChannel) {
 // createTestArbiter instantiates a breach arbiter with a failing retribution
 // store, so that controlled failures can be tested.
 func createTestArbiter(t *testing.T, contractBreaches chan *ContractBreachEvent,
-	db *channeldb.DB) (*BreachArbiter, error) {
+	db *channeldb.DB) (*BreachArbitrator, error) {
 
 	// Create a failing retribution store, that wraps a normal one.
 	store := newFailingRetributionStore(func() RetributionStorer {
@@ -2120,7 +2120,7 @@ func createTestArbiter(t *testing.T, contractBreaches chan *ContractBreachEvent,
 
 	// Assemble our test arbiter.
 	notifier := mock.MakeMockSpendNotifier()
-	ba := NewBreachArbiter(&BreachConfig{
+	ba := NewBreachArbitrator(&BreachConfig{
 		CloseLink:          func(_ *wire.OutPoint, _ ChannelCloseType) {},
 		DB:                 db.ChannelStateDB(),
 		Estimator:          chainfee.NewStaticEstimator(12500, 0),
diff --git a/contractcourt/channel_arbitrator_test.go b/contractcourt/channel_arbitrator_test.go
index 34c6122fd..8c72e02f6 100644
--- a/contractcourt/channel_arbitrator_test.go
+++ b/contractcourt/channel_arbitrator_test.go
@@ -1430,7 +1430,7 @@ func TestChannelArbitratorPersistence(t *testing.T) {
 // is breached by the remote node. In these cases we expect the
 // ChannelArbitrator to properly execute the breachResolver flow and then
 // gracefully exit once the breachResolver receives the signal from what would
-// normally be the breacharbiter.
+// normally be the BreachArbitrator.
 func TestChannelArbitratorForceCloseBreachedChannel(t *testing.T) {
 	log := &mockArbitratorLog{
 		state:     StateDefault,
diff --git a/itest/list_on_test.go b/itest/list_on_test.go
index e8cf80c5f..390e9a49e 100644
--- a/itest/list_on_test.go
+++ b/itest/list_on_test.go
@@ -174,7 +174,7 @@ var allTestCases = []*lntest.TestCase{
 		TestFunc: testUpdateNodeAnnouncement,
 	},
 	{
-		Name:     "list payments",
+		Name:     "list outgoing payments",
 		TestFunc: testListPayments,
 	},
 	{
diff --git a/itest/lnd_amp_test.go b/itest/lnd_amp_test.go
index 61b6d194a..ba17a30b6 100644
--- a/itest/lnd_amp_test.go
+++ b/itest/lnd_amp_test.go
@@ -104,10 +104,6 @@ func testSendPaymentAMPInvoiceCase(ht *lntest.HarnessTest,
 	// expect an extra invoice to appear in the ListInvoices response, since
 	// a new invoice will be JIT inserted under a different payment address
 	// than the one in the invoice.
-	//
-	// NOTE: This will only work when the peer has spontaneous AMP payments
-	// enabled otherwise no invoice under a different payment_addr will be
-	// found.
 	var (
 		expNumInvoices  = 1
 		externalPayAddr []byte
diff --git a/itest/lnd_payment_test.go b/itest/lnd_payment_test.go
index 143b645fd..d3d61582b 100644
--- a/itest/lnd_payment_test.go
+++ b/itest/lnd_payment_test.go
@@ -153,6 +153,13 @@ func testListPayments(ht *lntest.HarnessTest) {
 		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
 	)
 
+	// Get the number of invoices Bob already has.
+	//
+	// TODO(yy): we can remove this check once the `DeleteAllInvoices` rpc
+	// is added.
+	invResp := bob.RPC.ListInvoices(nil)
+	numOldInvoices := len(invResp.Invoices)
+
 	// Now that the channel is open, create an invoice for Bob which
 	// expects a payment of 1000 satoshis from Alice paid via a particular
 	// preimage.
@@ -166,7 +173,8 @@ func testListPayments(ht *lntest.HarnessTest) {
 	invoiceResp := bob.RPC.AddInvoice(invoice)
 
 	// Check that Bob has added the invoice.
-	invoice = ht.AssertNumInvoices(bob, 1)[0]
+	numInvoices := numOldInvoices + 1
+	ht.AssertNumInvoices(bob, 1)
 
 	// With the invoice for Bob added, send a payment towards Alice paying
 	// to the above generated invoice.
@@ -202,108 +210,65 @@ func testListPayments(ht *lntest.HarnessTest) {
 	require.Equal(ht, invoiceResp.PaymentRequest, p.PaymentRequest,
 		"incorrect payreq")
 
-	// testCase holds a case to be used by both the payment and the invoice
-	// tests.
-	type testCase struct {
-		name      string
-		startDate uint64
-		endDate   uint64
-		expected  bool
+	// We now check the timestamp filters in `ListPayments`.
+	//
+	// Use a start date long time ago should return us the payment.
+	req := &lnrpc.ListPaymentsRequest{
+		CreationDateStart: 1227035905,
 	}
+	resp := alice.RPC.ListPayments(req)
+	require.Len(ht, resp.Payments, 1)
 
-	// Create test cases to check the timestamp filters.
-	createCases := func(createTimeSeconds uint64) []testCase {
-		return []testCase{
-			{
-				// Use a start date same as the creation date
-				// should return us the item.
-				name:      "exact start date",
-				startDate: createTimeSeconds,
-				expected:  true,
-			},
-			{
-				// Use an earlier start date should return us
-				// the item.
-				name:      "earlier start date",
-				startDate: createTimeSeconds - 1,
-				expected:  true,
-			},
-			{
-				// Use a future start date should return us
-				// nothing.
-				name:      "future start date",
-				startDate: createTimeSeconds + 1,
-				expected:  false,
-			},
-			{
-				// Use an end date same as the creation date
-				// should return us the item.
-				name:     "exact end date",
-				endDate:  createTimeSeconds,
-				expected: true,
-			},
-			{
-				// Use an end date in the future should return
-				// us the item.
-				name:     "future end date",
-				endDate:  createTimeSeconds + 1,
-				expected: true,
-			},
-			{
-				// Use an earlier end date should return us
-				// nothing.
-				name:     "earlier end date",
-				endDate:  createTimeSeconds - 1,
-				expected: false,
-			},
-		}
+	// Use an end date long time ago should return us nothing.
+	req = &lnrpc.ListPaymentsRequest{
+		CreationDateEnd: 1227035905,
 	}
+	resp = alice.RPC.ListPayments(req)
+	require.Empty(ht, resp.Payments)
 
-	// Get the payment creation time in seconds.
-	paymentCreateSeconds := uint64(
-		p.CreationTimeNs / time.Second.Nanoseconds(),
-	)
-
-	// Create test cases from the payment creation time.
-	testCases := createCases(paymentCreateSeconds)
-
-	// We now check the timestamp filters in `ListPayments`.
-	for _, tc := range testCases {
-		ht.Run("payment_"+tc.name, func(t *testing.T) {
-			req := &lnrpc.ListPaymentsRequest{
-				CreationDateStart: tc.startDate,
-				CreationDateEnd:   tc.endDate,
-			}
-			resp := alice.RPC.ListPayments(req)
+	// Use a start date far in the future should return us nothing.
+	req = &lnrpc.ListPaymentsRequest{
+		CreationDateStart: 5392552705,
+	}
+	resp = alice.RPC.ListPayments(req)
+	require.Empty(ht, resp.Payments)
 
-			if tc.expected {
-				require.Lenf(t, resp.Payments, 1, "req=%v", req)
-			} else {
-				require.Emptyf(t, resp.Payments, "req=%v", req)
-			}
-		})
+	// Use an end date far in the future should return us the payment.
+	req = &lnrpc.ListPaymentsRequest{
+		CreationDateEnd: 5392552705,
 	}
+	resp = alice.RPC.ListPayments(req)
+	require.Len(ht, resp.Payments, 1)
+
+	// We now do the same check for `ListInvoices`
+	//
+	// Use a start date long time ago should return us the invoice.
+	invReq := &lnrpc.ListInvoiceRequest{
+		CreationDateStart: 1227035905,
+	}
+	invResp = bob.RPC.ListInvoices(invReq)
+	require.Len(ht, invResp.Invoices, numInvoices)
 
-	// Create test cases from the invoice creation time.
-	testCases = createCases(uint64(invoice.CreationDate))
+	// Use an end date long time ago should return us nothing.
+	invReq = &lnrpc.ListInvoiceRequest{
+		CreationDateEnd: 1227035905,
+	}
+	invResp = bob.RPC.ListInvoices(invReq)
+	require.Empty(ht, invResp.Invoices)
 
-	// We now do the same check for `ListInvoices`.
-	for _, tc := range testCases {
-		ht.Run("invoice_"+tc.name, func(t *testing.T) {
-			req := &lnrpc.ListInvoiceRequest{
-				CreationDateStart: tc.startDate,
-				CreationDateEnd:   tc.endDate,
-			}
-			resp := bob.RPC.ListInvoices(req)
+	// Use a start date far in the future should return us nothing.
+	invReq = &lnrpc.ListInvoiceRequest{
+		CreationDateStart: 5392552705,
+	}
+	invResp = bob.RPC.ListInvoices(invReq)
+	require.Empty(ht, invResp.Invoices)
 
-			if tc.expected {
-				require.Lenf(t, resp.Invoices, 1, "req: %v",
-					req)
-			} else {
-				require.Emptyf(t, resp.Invoices, "req: %v", req)
-			}
-		})
+	// Use an end date far in the future should return us the invoice.
+	invReq = &lnrpc.ListInvoiceRequest{
+		CreationDateEnd: 5392552705,
 	}
+	invResp = bob.RPC.ListInvoices(invReq)
+	require.Len(ht, invResp.Invoices, numInvoices)
 
 	// Delete all payments from Alice. DB should have no payments.
 	alice.RPC.DeleteAllPayments()
diff --git a/lnwallet/channel_test.go b/lnwallet/channel_test.go
index 32a00e769..db5d0f468 100644
--- a/lnwallet/channel_test.go
+++ b/lnwallet/channel_test.go
@@ -2147,8 +2147,8 @@ func TestCooperativeCloseDustAdherence(t *testing.T) {
 	}
 
 	resetChannelState := func() {
-		aliceChannel.ResetState()
-		bobChannel.ResetState()
+		aliceChannel.status = channelOpen
+		bobChannel.status = channelOpen
 	}
 
 	setBalances := func(aliceBalance, bobBalance lnwire.MilliSatoshi) {
diff --git a/lnwire/fuzz_test.go b/lnwire/fuzz_test.go
index 542a2f0c0..f364867a7 100644
--- a/lnwire/fuzz_test.go
+++ b/lnwire/fuzz_test.go
@@ -878,25 +878,3 @@ func FuzzInvalidOnionPayload(f *testing.F) {
 		onionFailureHarness(t, data, CodeInvalidOnionPayload)
 	})
 }
-
-func FuzzClosingSig(f *testing.F) {
-	f.Fuzz(func(t *testing.T, data []byte) {
-		// Prefix with ClosingSig.
-		data = prefixWithMsgType(data, MsgClosingSig)
-
-		// Pass the message into our general fuzz harness for wire
-		// messages!
-		harness(t, data)
-	})
-}
-
-func FuzzClosingComplete(f *testing.F) {
-	f.Fuzz(func(t *testing.T, data []byte) {
-		// Prefix with ClosingComplete.
-		data = prefixWithMsgType(data, MsgClosingComplete)
-
-		// Pass the message into our general fuzz harness for wire
-		// messages!
-		harness(t, data)
-	})
-}
diff --git a/lnwire/lnwire_test.go b/lnwire/lnwire_test.go
index 1246f92e7..c3248c3c9 100644
--- a/lnwire/lnwire_test.go
+++ b/lnwire/lnwire_test.go
@@ -22,7 +22,6 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
-	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/lightningnetwork/lnd/tor"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -1213,107 +1212,6 @@ func TestLightningWireProtocol(t *testing.T) {
 				PaddingBytes: paddingBytes,
 			}
 
-			v[0] = reflect.ValueOf(req)
-		},
-		MsgClosingComplete: func(v []reflect.Value, r *rand.Rand) {
-			var c [32]byte
-			_, err := r.Read(c[:])
-			if err != nil {
-				t.Fatalf("unable to generate chan id: %v",
-					err)
-				return
-			}
-
-			req := ClosingComplete{
-				ChannelID:   ChannelID(c),
-				FeeSatoshis: btcutil.Amount(r.Int63()),
-				Sequence:    uint32(r.Int63()),
-				ClosingSigs: ClosingSigs{},
-			}
-
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType1, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.CloserNoClosee = tlv.SomeRecordT(sig)
-			}
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType2, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.NoCloserClosee = tlv.SomeRecordT(sig)
-			}
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType3, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.CloserAndClosee = tlv.SomeRecordT(sig)
-			}
-
-			v[0] = reflect.ValueOf(req)
-		},
-		MsgClosingSig: func(v []reflect.Value, r *rand.Rand) {
-			var c [32]byte
-			_, err := r.Read(c[:])
-			if err != nil {
-				t.Fatalf("unable to generate chan id: %v", err)
-				return
-			}
-
-			req := ClosingSig{
-				ChannelID:   ChannelID(c),
-				ClosingSigs: ClosingSigs{},
-			}
-
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType1, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.CloserNoClosee = tlv.SomeRecordT(sig)
-			}
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType2, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.NoCloserClosee = tlv.SomeRecordT(sig)
-			}
-			if r.Intn(2) == 0 {
-				sig := tlv.ZeroRecordT[tlv.TlvType3, Sig]()
-				_, err := r.Read(sig.Val.bytes[:])
-				if err != nil {
-					t.Fatalf("unable to generate sig: %v",
-						err)
-					return
-				}
-
-				req.CloserAndClosee = tlv.SomeRecordT(sig)
-			}
-
 			v[0] = reflect.ValueOf(req)
 		},
 	}
@@ -1526,18 +1424,6 @@ func TestLightningWireProtocol(t *testing.T) {
 				return mainScenario(&m)
 			},
 		},
-		{
-			msgType: MsgClosingComplete,
-			scenario: func(m ClosingComplete) bool {
-				return mainScenario(&m)
-			},
-		},
-		{
-			msgType: MsgClosingSig,
-			scenario: func(m ClosingSig) bool {
-				return mainScenario(&m)
-			},
-		},
 	}
 	for _, test := range tests {
 		var config *quick.Config
diff --git a/routing/additional_edge_test.go b/routing/additional_edge_test.go
deleted file mode 100644
index b3ea3b501..000000000
--- a/routing/additional_edge_test.go
+++ /dev/null
@@ -1,136 +0,0 @@
-package routing
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/hex"
-	"testing"
-
-	"github.com/btcsuite/btcd/btcec/v2"
-	sphinx "github.com/lightningnetwork/lightning-onion"
-	"github.com/lightningnetwork/lnd/routing/route"
-	"github.com/stretchr/testify/require"
-)
-
-// TestIntermediatePayloadSize tests the payload size functions of the
-// PrivateEdge and the BlindedEdge.
-func TestIntermediatePayloadSize(t *testing.T) {
-	t.Parallel()
-
-	testPrivKeyBytes, _ := hex.DecodeString("e126f68f7eafcc8b74f54d269fe" +
-		"206be715000f94dac067d1c04a8ca3b2db734")
-	_, blindedPoint := btcec.PrivKeyFromBytes(testPrivKeyBytes)
-
-	testCases := []struct {
-		name    string
-		hop     route.Hop
-		nextHop uint64
-		edge    AdditionalEdge
-	}{
-		{
-			name: "Legacy payload private edge",
-			hop: route.Hop{
-				AmtToForward:     1000,
-				OutgoingTimeLock: 600000,
-				ChannelID:        3432483437438,
-				LegacyPayload:    true,
-			},
-			nextHop: 1,
-			edge:    &PrivateEdge{},
-		},
-		{
-			name: "Tlv payload private edge",
-			hop: route.Hop{
-				AmtToForward:     1000,
-				OutgoingTimeLock: 600000,
-				ChannelID:        3432483437438,
-				LegacyPayload:    false,
-			},
-			nextHop: 1,
-			edge:    &PrivateEdge{},
-		},
-		{
-			name: "Blinded edge",
-			hop: route.Hop{
-				EncryptedData: []byte{12, 13},
-			},
-			edge: &BlindedEdge{
-				cipherText: []byte{12, 13},
-			},
-		},
-		{
-			name: "Blinded edge - introduction point",
-			hop: route.Hop{
-				EncryptedData: []byte{12, 13},
-				BlindingPoint: blindedPoint,
-			},
-			edge: &BlindedEdge{
-				cipherText:    []byte{12, 13},
-				blindingPoint: blindedPoint,
-			},
-		},
-	}
-
-	for _, testCase := range testCases {
-		testCase := testCase
-
-		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-
-			payLoad, err := createHopPayload(
-				testCase.hop, testCase.nextHop, false,
-			)
-			require.NoErrorf(t, err, "failed to create hop payload")
-
-			expectedPayloadSize := testCase.edge.
-				IntermediatePayloadSize(
-					testCase.hop.AmtToForward,
-					testCase.hop.OutgoingTimeLock,
-					testCase.hop.LegacyPayload,
-					testCase.nextHop,
-				)
-
-			require.Equal(
-				t, expectedPayloadSize,
-				uint64(payLoad.NumBytes()),
-			)
-		})
-	}
-}
-
-// createHopPayload creates the hop payload of the sphinx package to facilitate
-// the testing of the payload size.
-func createHopPayload(hop route.Hop, nextHop uint64,
-	finalHop bool) (sphinx.HopPayload, error) {
-
-	// If this is the legacy payload, then we can just include the
-	// hop data as normal.
-	if hop.LegacyPayload {
-		// Before we encode this value, we'll pack the next hop
-		// into the NextAddress field of the hop info to ensure
-		// we point to the right now.
-		hopData := sphinx.HopData{
-			ForwardAmount: uint64(hop.AmtToForward),
-			OutgoingCltv:  hop.OutgoingTimeLock,
-		}
-		binary.BigEndian.PutUint64(
-			hopData.NextAddress[:], nextHop,
-		)
-
-		return sphinx.NewLegacyHopPayload(&hopData)
-	}
-
-	// For non-legacy payloads, we'll need to pack the
-	// routing information, along with any extra TLV
-	// information into the new per-hop payload format.
-	// We'll also pass in the chan ID of the hop this
-	// channel should be forwarded to so we can construct a
-	// valid payload.
-	var b bytes.Buffer
-	err := hop.PackHopPayload(&b, nextHop, finalHop)
-	if err != nil {
-		return sphinx.HopPayload{}, err
-	}
-
-	return sphinx.NewTLVHopPayload(b.Bytes())
-}
diff --git a/routing/blinding_test.go b/routing/blinding_test.go
index 561ace6fc..5dc71354f 100644
--- a/routing/blinding_test.go
+++ b/routing/blinding_test.go
@@ -1,12 +1,10 @@
 package routing
 
 import (
-	"bytes"
 	"testing"
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	sphinx "github.com/lightningnetwork/lightning-onion"
-	"github.com/lightningnetwork/lnd/channeldb/models"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/stretchr/testify/require"
@@ -96,12 +94,6 @@ func TestBlindedPaymentToHints(t *testing.T) {
 		htlcMin   uint64 = 100
 		htlcMax   uint64 = 100_000_000
 
-		sizeEncryptedData = 100
-		cipherText        = bytes.Repeat(
-			[]byte{1}, sizeEncryptedData,
-		)
-		_, blindedPoint = btcec.PrivKeyFromBytes([]byte{5})
-
 		rawFeatures = lnwire.NewRawFeatureVector(
 			lnwire.AMPOptional,
 		)
@@ -116,7 +108,6 @@ func TestBlindedPaymentToHints(t *testing.T) {
 	blindedPayment := &BlindedPayment{
 		BlindedPath: &sphinx.BlindedPath{
 			IntroductionPoint: pk1,
-			BlindingPoint:     blindedPoint,
 			BlindedHops: []*sphinx.BlindedHopInfo{
 				{},
 			},
@@ -134,52 +125,40 @@ func TestBlindedPaymentToHints(t *testing.T) {
 	blindedPayment.BlindedPath.BlindedHops = []*sphinx.BlindedHopInfo{
 		{
 			BlindedNodePub: pkb1,
-			CipherText:     cipherText,
 		},
 		{
 			BlindedNodePub: pkb2,
-			CipherText:     cipherText,
 		},
 		{
 			BlindedNodePub: pkb3,
-			CipherText:     cipherText,
 		},
 	}
 
 	expected := RouteHints{
 		v1: {
-			//nolint:lll
-			&BlindedEdge{
-				policy: &models.CachedEdgePolicy{
-					TimeLockDelta: cltvDelta,
-					MinHTLC:       lnwire.MilliSatoshi(htlcMin),
-					MaxHTLC:       lnwire.MilliSatoshi(htlcMax),
-					FeeBaseMSat:   lnwire.MilliSatoshi(baseFee),
-					FeeProportionalMillionths: lnwire.MilliSatoshi(
-						ppmFee,
-					),
-					ToNodePubKey: func() route.Vertex {
-						return vb2
-					},
-					ToNodeFeatures: features,
+			{
+				TimeLockDelta: cltvDelta,
+				MinHTLC:       lnwire.MilliSatoshi(htlcMin),
+				MaxHTLC:       lnwire.MilliSatoshi(htlcMax),
+				FeeBaseMSat:   lnwire.MilliSatoshi(baseFee),
+				FeeProportionalMillionths: lnwire.MilliSatoshi(
+					ppmFee,
+				),
+				ToNodePubKey: func() route.Vertex {
+					return vb2
 				},
-				blindingPoint: blindedPoint,
-				cipherText:    cipherText,
+				ToNodeFeatures: features,
 			},
 		},
 		vb2: {
-			&BlindedEdge{
-				policy: &models.CachedEdgePolicy{
-					ToNodePubKey: func() route.Vertex {
-						return vb3
-					},
-					ToNodeFeatures: features,
+			{
+				ToNodePubKey: func() route.Vertex {
+					return vb3
 				},
-				cipherText: cipherText,
+				ToNodeFeatures: features,
 			},
 		},
 	}
-
 	actual := blindedPayment.toRouteHints()
 
 	require.Equal(t, len(expected), len(actual))
@@ -191,24 +170,13 @@ func TestBlindedPaymentToHints(t *testing.T) {
 		require.Len(t, actualHint, 1)
 
 		// We can't assert that our functions are equal, so we check
-		// their output and then mark them as nil so that we can use
+		// their output and then mark as nil so that we can use
 		// require.Equal for all our other fields.
-		require.Equal(t, expectedHint[0].EdgePolicy().ToNodePubKey(),
-			actualHint[0].EdgePolicy().ToNodePubKey())
-
-		actualHint[0].EdgePolicy().ToNodePubKey = nil
-		expectedHint[0].EdgePolicy().ToNodePubKey = nil
-
-		// The arguments we use for the payload do not matter as long as
-		// both functions return the same payload.
-		expectedPayloadSize := expectedHint[0].IntermediatePayloadSize(
-			0, 0, false, 0,
-		)
-		actualPayloadSize := actualHint[0].IntermediatePayloadSize(
-			0, 0, false, 0,
-		)
+		require.Equal(t, expectedHint[0].ToNodePubKey(),
+			actualHint[0].ToNodePubKey())
 
-		require.Equal(t, expectedPayloadSize, actualPayloadSize)
+		actualHint[0].ToNodePubKey = nil
+		expectedHint[0].ToNodePubKey = nil
 
 		require.Equal(t, expectedHint[0], actualHint[0])
 	}
diff --git a/routing/pathfind_test.go b/routing/pathfind_test.go
index 6bf754c82..7c4f635df 100644
--- a/routing/pathfind_test.go
+++ b/routing/pathfind_test.go
@@ -746,9 +746,6 @@ func TestPathFinding(t *testing.T) {
 	}, {
 		name: "path finding with additional edges",
 		fn:   runPathFindingWithAdditionalEdges,
-	}, {
-		name: "path finding max payload restriction",
-		fn:   runPathFindingMaxPayloadRestriction,
 	}, {
 		name: "path finding with redundant additional edges",
 		fn:   runPathFindingWithRedundantAdditionalEdges,
@@ -1207,7 +1204,7 @@ func runPathFindingWithAdditionalEdges(t *testing.T, useCache bool) {
 
 	// Create the channel edge going from songoku to doge and include it in
 	// our map of additional edges.
-	songokuToDogePolicy := &models.CachedEdgePolicy{
+	songokuToDoge := &models.CachedEdgePolicy{
 		ToNodePubKey: func() route.Vertex {
 			return doge.PubKeyBytes
 		},
@@ -1218,10 +1215,8 @@ func runPathFindingWithAdditionalEdges(t *testing.T, useCache bool) {
 		TimeLockDelta:             9,
 	}
 
-	additionalEdges := map[route.Vertex][]AdditionalEdge{
-		graph.aliasMap["songoku"]: {&PrivateEdge{
-			policy: songokuToDogePolicy,
-		}},
+	additionalEdges := map[route.Vertex][]*models.CachedEdgePolicy{
+		graph.aliasMap["songoku"]: {songokuToDoge},
 	}
 
 	find := func(r *RestrictParams) (
@@ -1271,122 +1266,6 @@ func runPathFindingWithAdditionalEdges(t *testing.T, useCache bool) {
 	assertExpectedPath(t, graph.aliasMap, path, "songoku", "doge")
 }
 
-// runPathFindingMaxPayloadRestriction tests the maximum size of a sphinx
-// package when creating a route. So we make sure the pathfinder does not return
-// a route which is greater than the maximum sphinx package size of 1300 bytes
-// defined in BOLT04.
-func runPathFindingMaxPayloadRestriction(t *testing.T, useCache bool) {
-	graph, err := parseTestGraph(t, useCache, basicGraphFilePath)
-	require.NoError(t, err, "unable to create graph")
-
-	sourceNode, err := graph.graph.SourceNode()
-	require.NoError(t, err, "unable to fetch source node")
-
-	paymentAmt := lnwire.NewMSatFromSatoshis(100)
-
-	// Create a node doge which is not visible in the graph.
-	dogePubKeyHex := "03dd46ff29a6941b4a2607525b043ec9b020b3f318a1bf281" +
-		"536fd7011ec59c882"
-	dogePubKeyBytes, err := hex.DecodeString(dogePubKeyHex)
-	require.NoError(t, err, "unable to decode public key")
-	dogePubKey, err := btcec.ParsePubKey(dogePubKeyBytes)
-	require.NoError(t, err, "unable to parse public key from bytes")
-
-	doge := &channeldb.LightningNode{}
-	doge.AddPubKey(dogePubKey)
-	doge.Alias = "doge"
-	copy(doge.PubKeyBytes[:], dogePubKeyBytes)
-	graph.aliasMap["doge"] = doge.PubKeyBytes
-
-	const (
-		chanID          uint64 = 1337
-		finalHtlcExpiry int32  = 0
-	)
-
-	// Create the channel edge going from songoku to doge and later add it
-	// with the mocked size function to the graph data.
-	songokuToDogePolicy := &models.CachedEdgePolicy{
-		ToNodePubKey: func() route.Vertex {
-			return doge.PubKeyBytes
-		},
-		ToNodeFeatures:            lnwire.EmptyFeatureVector(),
-		ChannelID:                 chanID,
-		FeeBaseMSat:               1,
-		FeeProportionalMillionths: 1000,
-		TimeLockDelta:             9,
-	}
-
-	// The route has 2 hops. The exit hop (doge) and the hop
-	// (songoku -> doge). The desired path looks like this:
-	// source -> songoku -> doge
-	tests := []struct {
-		name              string
-		mockedPayloadSize uint64
-		err               error
-	}{
-		{
-			// The final hop payload size needs to be considered
-			// as well and because it's treated differently than the
-			// intermediate hops the following tests choose to use
-			// the legacy payload format to have a constant final
-			// hop payload size.
-			name:              "route max payload size (1300)",
-			mockedPayloadSize: 1300 - sphinx.LegacyHopDataSize,
-		},
-		{
-			// We increase the enrypted data size by one byte.
-			name: "route 1 bytes bigger than max " +
-				"payload",
-			mockedPayloadSize: 1300 - sphinx.LegacyHopDataSize + 1,
-			err:               errNoPathFound,
-		},
-	}
-
-	for _, testCase := range tests {
-		testCase := testCase
-
-		t.Run(testCase.name, func(t *testing.T) {
-			t.Parallel()
-
-			restrictions := *noRestrictions
-			// No tlv payload, this makes sure the final hop uses
-			// the legacy payload.
-			restrictions.DestFeatures = lnwire.EmptyFeatureVector()
-
-			// Create the mocked AdditionalEdge and mock the
-			// corresponding calls.
-			mockedEdge := &mockAdditionalEdge{}
-
-			mockedEdge.On("EdgePolicy").Return(songokuToDogePolicy)
-
-			mockedEdge.On("IntermediatePayloadSize",
-				paymentAmt, uint32(finalHtlcExpiry), true,
-				chanID).Once().
-				Return(testCase.mockedPayloadSize)
-
-			additionalEdges := map[route.Vertex][]AdditionalEdge{
-				graph.aliasMap["songoku"]: {mockedEdge},
-			}
-
-			path, err := dbFindPath(
-				graph.graph, additionalEdges,
-				&mockBandwidthHints{}, &restrictions,
-				testPathFindingConfig, sourceNode.PubKeyBytes,
-				doge.PubKeyBytes, paymentAmt, 0,
-				finalHtlcExpiry,
-			)
-			require.ErrorIs(t, err, testCase.err)
-
-			if err == nil {
-				assertExpectedPath(t, graph.aliasMap, path,
-					"songoku", "doge")
-			}
-
-			mockedEdge.AssertExpectations(t)
-		})
-	}
-}
-
 // runPathFindingWithRedundantAdditionalEdges asserts that we are able to find
 // paths to nodes ignoring additional edges that are already known by self node.
 func runPathFindingWithRedundantAdditionalEdges(t *testing.T, useCache bool) {
@@ -1411,7 +1290,7 @@ func runPathFindingWithRedundantAdditionalEdges(t *testing.T, useCache bool) {
 
 	// Create the channel edge going from alice to bob and include it in
 	// our map of additional edges.
-	aliceToBobPolicy := &models.CachedEdgePolicy{
+	aliceToBob := &models.CachedEdgePolicy{
 		ToNodePubKey: func() route.Vertex {
 			return target
 		},
@@ -1422,10 +1301,8 @@ func runPathFindingWithRedundantAdditionalEdges(t *testing.T, useCache bool) {
 		TimeLockDelta:             9,
 	}
 
-	additionalEdges := map[route.Vertex][]AdditionalEdge{
-		ctx.source: {&PrivateEdge{
-			policy: aliceToBobPolicy,
-		}},
+	additionalEdges := map[route.Vertex][]*models.CachedEdgePolicy{
+		ctx.source: {aliceToBob},
 	}
 
 	path, err := dbFindPath(
@@ -2525,8 +2402,7 @@ func assertExpectedPath(t *testing.T, aliasMap map[string]route.Vertex,
 	path []*models.CachedEdgePolicy, nodeAliases ...string) {
 
 	if len(path) != len(nodeAliases) {
-		t.Fatalf("number of hops=(%v) and number of aliases=(%v) do "+
-			"not match", len(path), len(nodeAliases))
+		t.Fatal("number of hops and number of aliases do not match")
 	}
 
 	for i, hop := range path {
@@ -3196,7 +3072,7 @@ func (c *pathFindingTestContext) assertPath(path []*models.CachedEdgePolicy,
 // dbFindPath calls findPath after getting a db transaction from the database
 // graph.
 func dbFindPath(graph *channeldb.ChannelGraph,
-	additionalEdges map[route.Vertex][]AdditionalEdge,
+	additionalEdges map[route.Vertex][]*models.CachedEdgePolicy,
 	bandwidthHints bandwidthHints,
 	r *RestrictParams, cfg *PathFindingConfig,
 	source, target route.Vertex, amt lnwire.MilliSatoshi, timePref float64,
@@ -3354,8 +3230,8 @@ func TestBlindedRouteConstruction(t *testing.T) {
 	edges := []*models.CachedEdgePolicy{
 		aliceBobEdge,
 		bobCarolEdge,
-		carolDaveEdge.EdgePolicy(),
-		daveEveEdge.EdgePolicy(),
+		carolDaveEdge,
+		daveEveEdge,
 	}
 
 	// Total timelock for the route should include:
@@ -3451,168 +3327,3 @@ func TestBlindedRouteConstruction(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, expectedRoute, route)
 }
-
-// TestLastHopPayloadSize tests the final hop payload size. The final hop
-// payload structure differes from the intermediate hop payload for both the
-// non-blinded and blinded case.
-func TestLastHopPayloadSize(t *testing.T) {
-	t.Parallel()
-
-	var (
-		metadata      = []byte{21, 22}
-		customRecords = map[uint64][]byte{
-			record.CustomTypeStart: {1, 2, 3},
-		}
-		sizeEncryptedData = 100
-		encrypedData      = bytes.Repeat(
-			[]byte{1}, sizeEncryptedData,
-		)
-		_, blindedPoint       = btcec.PrivKeyFromBytes([]byte{5})
-		paymentAddr           = &[32]byte{1}
-		ampOptions            = &AMPOptions{}
-		amtToForward          = lnwire.MilliSatoshi(10000)
-		finalHopExpiry  int32 = 144
-
-		oneHopBlindedPayment = &BlindedPayment{
-			BlindedPath: &sphinx.BlindedPath{
-				BlindedHops: []*sphinx.BlindedHopInfo{
-					{
-						CipherText: encrypedData,
-					},
-				},
-				BlindingPoint: blindedPoint,
-			},
-		}
-		twoHopBlindedPayment = &BlindedPayment{
-			BlindedPath: &sphinx.BlindedPath{
-				BlindedHops: []*sphinx.BlindedHopInfo{
-					{
-						CipherText: encrypedData,
-					},
-					{
-						CipherText: encrypedData,
-					},
-				},
-				BlindingPoint: blindedPoint,
-			},
-		}
-	)
-
-	testCases := []struct {
-		name           string
-		restrictions   *RestrictParams
-		finalHopExpiry int32
-		amount         lnwire.MilliSatoshi
-		legacy         bool
-	}{
-		{
-			name: "Non blinded final hop",
-			restrictions: &RestrictParams{
-				PaymentAddr:       paymentAddr,
-				DestCustomRecords: customRecords,
-				Metadata:          metadata,
-				Amp:               ampOptions,
-			},
-			amount:         amtToForward,
-			finalHopExpiry: finalHopExpiry,
-			legacy:         false,
-		},
-		{
-			name: "Non blinded final hop legacy",
-			restrictions: &RestrictParams{
-				// The legacy encoding has no ability to include
-				// those extra data we expect that this data is
-				// ignored.
-				PaymentAddr:       paymentAddr,
-				DestCustomRecords: customRecords,
-				Metadata:          metadata,
-				Amp:               ampOptions,
-			},
-			amount:         amtToForward,
-			finalHopExpiry: finalHopExpiry,
-			legacy:         true,
-		},
-		{
-			name: "Blinded final hop introduction point",
-			restrictions: &RestrictParams{
-				BlindedPayment: oneHopBlindedPayment,
-			},
-			amount:         amtToForward,
-			finalHopExpiry: finalHopExpiry,
-		},
-		{
-			name: "Blinded final hop of a two hop payment",
-			restrictions: &RestrictParams{
-				BlindedPayment: twoHopBlindedPayment,
-			},
-			amount:         amtToForward,
-			finalHopExpiry: finalHopExpiry,
-		},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-
-			var mpp *record.MPP
-			if tc.restrictions.PaymentAddr != nil {
-				mpp = record.NewMPP(
-					tc.amount, *tc.restrictions.PaymentAddr,
-				)
-			}
-
-			// In case it's an AMP payment we use the max AMP record
-			// size to estimate the final hop size.
-			var amp *record.AMP
-			if tc.restrictions.Amp != nil {
-				amp = &record.MaxAmpPayLoadSize
-			}
-
-			var finalHop route.Hop
-			if tc.restrictions.BlindedPayment != nil {
-				blindedPath := tc.restrictions.BlindedPayment.
-					BlindedPath.BlindedHops
-
-				blindedPoint := tc.restrictions.BlindedPayment.
-					BlindedPath.BlindingPoint
-
-				//nolint:lll
-				finalHop = route.Hop{
-					AmtToForward:     tc.amount,
-					OutgoingTimeLock: uint32(tc.finalHopExpiry),
-					LegacyPayload:    false,
-					EncryptedData:    blindedPath[len(blindedPath)-1].CipherText,
-				}
-				if len(blindedPath) == 1 {
-					finalHop.BlindingPoint = blindedPoint
-				}
-			} else {
-				//nolint:lll
-				finalHop = route.Hop{
-					LegacyPayload:    tc.legacy,
-					AmtToForward:     tc.amount,
-					OutgoingTimeLock: uint32(tc.finalHopExpiry),
-					Metadata:         tc.restrictions.Metadata,
-					MPP:              mpp,
-					AMP:              amp,
-					CustomRecords:    tc.restrictions.DestCustomRecords,
-				}
-			}
-
-			payLoad, err := createHopPayload(finalHop, 0, true)
-			require.NoErrorf(t, err, "failed to create hop payload")
-
-			expectedPayloadSize := lastHopPayloadSize(
-				tc.restrictions, tc.finalHopExpiry,
-				tc.amount, tc.legacy,
-			)
-
-			require.Equal(
-				t, expectedPayloadSize,
-				uint64(payLoad.NumBytes()),
-			)
-		})
-	}
-}
diff --git a/routing/payment_session_test.go b/routing/payment_session_test.go
index 67a285159..1c199ff40 100644
--- a/routing/payment_session_test.go
+++ b/routing/payment_session_test.go
@@ -138,7 +138,7 @@ func TestUpdateAdditionalEdge(t *testing.T) {
 	require.Equal(t, 1, len(policies), "should have 1 edge policy")
 
 	// Check that the policy has been created as expected.
-	policy := policies[0].EdgePolicy()
+	policy := policies[0]
 	require.Equal(t, testChannelID, policy.ChannelID, "channel ID mismatch")
 	require.Equal(t,
 		oldExpiryDelta, policy.TimeLockDelta, "timelock delta mismatch",
diff --git a/routing/router_test.go b/routing/router_test.go
index 12c8ff729..227899c83 100644
--- a/routing/router_test.go
+++ b/routing/router_test.go
@@ -3954,7 +3954,7 @@ func TestNewRouteRequest(t *testing.T) {
 			name:           "hints and blinded",
 			blindedPayment: blindedMultiHop,
 			routeHints: make(
-				map[route.Vertex][]AdditionalEdge,
+				map[route.Vertex][]*models.CachedEdgePolicy,
 			),
 			err: ErrHintsAndBlinded,
 		},
diff --git a/routing/unified_edges_test.go b/routing/unified_edges_test.go
index 043447f52..9b603d78c 100644
--- a/routing/unified_edges_test.go
+++ b/routing/unified_edges_test.go
@@ -41,17 +41,15 @@ func TestNodeEdgeUnifier(t *testing.T) {
 	c2 := btcutil.Amount(8)
 
 	unifierFilled := newNodeEdgeUnifier(source, toNode, nil)
-	unifierFilled.addPolicy(fromNode, &p1, c1, defaultHopPayloadSize)
-	unifierFilled.addPolicy(fromNode, &p2, c2, defaultHopPayloadSize)
+	unifierFilled.addPolicy(fromNode, &p1, c1)
+	unifierFilled.addPolicy(fromNode, &p2, c2)
 
 	unifierNoCapacity := newNodeEdgeUnifier(source, toNode, nil)
-	unifierNoCapacity.addPolicy(fromNode, &p1, 0, defaultHopPayloadSize)
-	unifierNoCapacity.addPolicy(fromNode, &p2, 0, defaultHopPayloadSize)
+	unifierNoCapacity.addPolicy(fromNode, &p1, 0)
+	unifierNoCapacity.addPolicy(fromNode, &p2, 0)
 
 	unifierNoInfo := newNodeEdgeUnifier(source, toNode, nil)
-	unifierNoInfo.addPolicy(
-		fromNode, &models.CachedEdgePolicy{}, 0, defaultHopPayloadSize,
-	)
+	unifierNoInfo.addPolicy(fromNode, &models.CachedEdgePolicy{}, 0)
 
 	tests := []struct {
 		name             string