diff --git a/docs/release-notes/release-notes-0.21.0.md b/docs/release-notes/release-notes-0.21.0.md
index 436c027c169..1057ccc47e4 100644
--- a/docs/release-notes/release-notes-0.21.0.md
+++ b/docs/release-notes/release-notes-0.21.0.md
@@ -83,6 +83,9 @@
   functions](https://github.com/lightningnetwork/lnd/pull/10368)
   * Finalize SQL payments implementation [enabling unit and itests
     for SQL backend](https://github.com/lightningnetwork/lnd/pull/10292)
+  * [Thread context through payment 
+    db functions Part 1](https://github.com/lightningnetwork/lnd/pull/10307)
+
 
 ## Code Health
 
diff --git a/payments/db/interface.go b/payments/db/interface.go
index 7fefad08917..6edaa7f45b5 100644
--- a/payments/db/interface.go
+++ b/payments/db/interface.go
@@ -21,21 +21,24 @@ type PaymentReader interface {
 
 	// FetchPayment fetches the payment corresponding to the given payment
 	// hash.
-	FetchPayment(paymentHash lntypes.Hash) (*MPPayment, error)
+	FetchPayment(ctx context.Context,
+		paymentHash lntypes.Hash) (*MPPayment, error)
 
 	// FetchInFlightPayments returns all payments with status InFlight.
-	FetchInFlightPayments() ([]*MPPayment, error)
+	FetchInFlightPayments(ctx context.Context) ([]*MPPayment, error)
 }
 
 // PaymentWriter represents the interface to write operations to the payments
 // database.
 type PaymentWriter interface {
 	// DeletePayment deletes a payment from the DB given its payment hash.
-	DeletePayment(paymentHash lntypes.Hash, failedAttemptsOnly bool) error
+	DeletePayment(ctx context.Context, paymentHash lntypes.Hash,
+		failedAttemptsOnly bool) error
 
 	// DeletePayments deletes all payments from the DB given the specified
 	// flags.
-	DeletePayments(failedOnly, failedAttemptsOnly bool) (int, error)
+	DeletePayments(ctx context.Context, failedOnly,
+		failedAttemptsOnly bool) (int, error)
 
 	PaymentControl
 }
@@ -58,7 +61,7 @@ type PaymentControl interface {
 	// exists in the database before creating a new payment. However, it
 	// should allow the user making a subsequent payment if the payment is
 	// in a Failed state.
-	InitPayment(lntypes.Hash, *PaymentCreationInfo) error
+	InitPayment(context.Context, lntypes.Hash, *PaymentCreationInfo) error
 
 	// RegisterAttempt atomically records the provided HTLCAttemptInfo.
 	//
@@ -72,7 +75,8 @@ type PaymentControl interface {
 	//   - Result: 1700 sats sent, exceeding the payment amount
 	// The payment router/controller layer is responsible for ensuring
 	// serialized access per payment hash.
-	RegisterAttempt(lntypes.Hash, *HTLCAttemptInfo) (*MPPayment, error)
+	RegisterAttempt(context.Context, lntypes.Hash,
+		*HTLCAttemptInfo) (*MPPayment, error)
 
 	// SettleAttempt marks the given attempt settled with the preimage. If
 	// this is a multi shard payment, this might implicitly mean the
@@ -82,10 +86,12 @@ type PaymentControl interface {
 	// error to prevent us from making duplicate payments to the same
 	// payment hash. The provided preimage is atomically saved to the DB
 	// for record keeping.
-	SettleAttempt(lntypes.Hash, uint64, *HTLCSettleInfo) (*MPPayment, error)
+	SettleAttempt(context.Context, lntypes.Hash, uint64,
+		*HTLCSettleInfo) (*MPPayment, error)
 
 	// FailAttempt marks the given payment attempt failed.
-	FailAttempt(lntypes.Hash, uint64, *HTLCFailInfo) (*MPPayment, error)
+	FailAttempt(context.Context, lntypes.Hash, uint64,
+		*HTLCFailInfo) (*MPPayment, error)
 
 	// Fail transitions a payment into the Failed state, and records
 	// the ultimate reason the payment failed. Note that this should only
@@ -93,12 +99,12 @@ type PaymentControl interface {
 	// invoking this method, InitPayment should return nil on its next call
 	// for this payment hash, allowing the user to make a subsequent
 	// payment.
-	Fail(lntypes.Hash, FailureReason) (*MPPayment, error)
+	Fail(context.Context, lntypes.Hash, FailureReason) (*MPPayment, error)
 
 	// DeleteFailedAttempts removes all failed HTLCs from the db. It should
 	// be called for a given payment whenever all inflight htlcs are
 	// completed, and the payment has reached a final terminal state.
-	DeleteFailedAttempts(lntypes.Hash) error
+	DeleteFailedAttempts(context.Context, lntypes.Hash) error
 }
 
 // DBMPPayment is an interface that represents the payment state during a
diff --git a/payments/db/kv_store.go b/payments/db/kv_store.go
index 84946841b9b..0ce0601e498 100644
--- a/payments/db/kv_store.go
+++ b/payments/db/kv_store.go
@@ -186,7 +186,7 @@ func initKVStore(db kvdb.Backend) error {
 // making sure it does not already exist as an in-flight payment. When this
 // method returns successfully, the payment is guaranteed to be in the InFlight
 // state.
-func (p *KVStore) InitPayment(paymentHash lntypes.Hash,
+func (p *KVStore) InitPayment(_ context.Context, paymentHash lntypes.Hash,
 	info *PaymentCreationInfo) error {
 
 	// Obtain a new sequence number for this payment. This is used
@@ -290,12 +290,14 @@ func (p *KVStore) InitPayment(paymentHash lntypes.Hash,
 
 // DeleteFailedAttempts deletes all failed htlcs for a payment if configured
 // by the KVStore db.
-func (p *KVStore) DeleteFailedAttempts(hash lntypes.Hash) error {
+func (p *KVStore) DeleteFailedAttempts(ctx context.Context,
+	hash lntypes.Hash) error {
+
 	// TODO(ziggie): Refactor to not mix application logic with database
 	// logic. This decision should be made in the application layer.
 	if !p.keepFailedPaymentAttempts {
 		const failedHtlcsOnly = true
-		err := p.DeletePayment(hash, failedHtlcsOnly)
+		err := p.DeletePayment(ctx, hash, failedHtlcsOnly)
 		if err != nil {
 			return err
 		}
@@ -359,7 +361,7 @@ func deserializePaymentIndex(r io.Reader) (lntypes.Hash, error) {
 
 // RegisterAttempt atomically records the provided HTLCAttemptInfo to the
 // DB.
-func (p *KVStore) RegisterAttempt(paymentHash lntypes.Hash,
+func (p *KVStore) RegisterAttempt(_ context.Context, paymentHash lntypes.Hash,
 	attempt *HTLCAttemptInfo) (*MPPayment, error) {
 
 	// Serialize the information before opening the db transaction.
@@ -430,7 +432,7 @@ func (p *KVStore) RegisterAttempt(paymentHash lntypes.Hash,
 // After invoking this method, InitPayment should always return an error to
 // prevent us from making duplicate payments to the same payment hash. The
 // provided preimage is atomically saved to the DB for record keeping.
-func (p *KVStore) SettleAttempt(hash lntypes.Hash,
+func (p *KVStore) SettleAttempt(_ context.Context, hash lntypes.Hash,
 	attemptID uint64, settleInfo *HTLCSettleInfo) (*MPPayment, error) {
 
 	var b bytes.Buffer
@@ -443,7 +445,7 @@ func (p *KVStore) SettleAttempt(hash lntypes.Hash,
 }
 
 // FailAttempt marks the given payment attempt failed.
-func (p *KVStore) FailAttempt(hash lntypes.Hash,
+func (p *KVStore) FailAttempt(_ context.Context, hash lntypes.Hash,
 	attemptID uint64, failInfo *HTLCFailInfo) (*MPPayment, error) {
 
 	var b bytes.Buffer
@@ -528,7 +530,7 @@ func (p *KVStore) updateHtlcKey(paymentHash lntypes.Hash,
 // payment failed. After invoking this method, InitPayment should return nil on
 // its next call for this payment hash, allowing the switch to make a
 // subsequent payment.
-func (p *KVStore) Fail(paymentHash lntypes.Hash,
+func (p *KVStore) Fail(_ context.Context, paymentHash lntypes.Hash,
 	reason FailureReason) (*MPPayment, error) {
 
 	var (
@@ -585,8 +587,8 @@ func (p *KVStore) Fail(paymentHash lntypes.Hash,
 }
 
 // FetchPayment returns information about a payment from the database.
-func (p *KVStore) FetchPayment(paymentHash lntypes.Hash) (
-	*MPPayment, error) {
+func (p *KVStore) FetchPayment(_ context.Context,
+	paymentHash lntypes.Hash) (*MPPayment, error) {
 
 	var payment *MPPayment
 	err := kvdb.View(p.db, func(tx kvdb.RTx) error {
@@ -741,7 +743,9 @@ func fetchPaymentStatus(bucket kvdb.RBucket) (PaymentStatus, error) {
 }
 
 // FetchInFlightPayments returns all payments with status InFlight.
-func (p *KVStore) FetchInFlightPayments() ([]*MPPayment, error) {
+func (p *KVStore) FetchInFlightPayments(_ context.Context) ([]*MPPayment,
+	error) {
+
 	var (
 		inFlights      []*MPPayment
 		start          = time.Now()
@@ -1275,7 +1279,7 @@ func fetchPaymentWithSequenceNumber(tx kvdb.RTx, paymentHash lntypes.Hash,
 // DeletePayment deletes a payment from the DB given its payment hash. If
 // failedHtlcsOnly is set, only failed HTLC attempts of the payment will be
 // deleted.
-func (p *KVStore) DeletePayment(paymentHash lntypes.Hash,
+func (p *KVStore) DeletePayment(_ context.Context, paymentHash lntypes.Hash,
 	failedHtlcsOnly bool) error {
 
 	return kvdb.Update(p.db, func(tx kvdb.RwTx) error {
@@ -1372,7 +1376,7 @@ func (p *KVStore) DeletePayment(paymentHash lntypes.Hash,
 // failedHtlcsOnly is set, the payment itself won't be deleted, only failed HTLC
 // attempts. The method returns the number of deleted payments, which is always
 // 0 if failedHtlcsOnly is set.
-func (p *KVStore) DeletePayments(failedOnly,
+func (p *KVStore) DeletePayments(_ context.Context, failedOnly,
 	failedHtlcsOnly bool) (int, error) {
 
 	var numPayments int
diff --git a/payments/db/kv_store_test.go b/payments/db/kv_store_test.go
index f0c2b148fd0..de3fc4ad24f 100644
--- a/payments/db/kv_store_test.go
+++ b/payments/db/kv_store_test.go
@@ -30,6 +30,8 @@ import (
 func TestKVStoreDeleteNonInFlight(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB := NewKVTestDB(t)
 
 	// Create a sequence number for duplicate payments that will not collide
@@ -78,12 +80,12 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 		require.NoError(t, err)
 
 		// Sends base htlc message which initiate StatusInFlight.
-		err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+		err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 		if err != nil {
 			t.Fatalf("unable to send htlc message: %v", err)
 		}
 		_, err = paymentDB.RegisterAttempt(
-			info.PaymentIdentifier, attempt,
+			ctx, info.PaymentIdentifier, attempt,
 		)
 		if err != nil {
 			t.Fatalf("unable to send htlc message: %v", err)
@@ -98,7 +100,7 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 			// Fail the payment attempt.
 			htlcFailure := HTLCFailUnreadable
 			_, err := paymentDB.FailAttempt(
-				info.PaymentIdentifier, attempt.AttemptID,
+				ctx, info.PaymentIdentifier, attempt.AttemptID,
 				&HTLCFailInfo{
 					Reason: htlcFailure,
 				},
@@ -110,7 +112,7 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 			// Fail the payment, which should moved it to Failed.
 			failReason := FailureReasonNoRoute
 			_, err = paymentDB.Fail(
-				info.PaymentIdentifier, failReason,
+				ctx, info.PaymentIdentifier, failReason,
 			)
 			if err != nil {
 				t.Fatalf("unable to fail payment hash: %v", err)
@@ -131,7 +133,7 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 		case p.success:
 			// Verifies that status was changed to StatusSucceeded.
 			_, err := paymentDB.SettleAttempt(
-				info.PaymentIdentifier, attempt.AttemptID,
+				ctx, info.PaymentIdentifier, attempt.AttemptID,
 				&HTLCSettleInfo{
 					Preimage: preimg,
 				},
@@ -180,7 +182,7 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 	}
 
 	// Delete all failed payments.
-	numPayments, err := paymentDB.DeletePayments(true, false)
+	numPayments, err := paymentDB.DeletePayments(ctx, true, false)
 	require.NoError(t, err)
 	require.EqualValues(t, 1, numPayments)
 
@@ -216,7 +218,7 @@ func TestKVStoreDeleteNonInFlight(t *testing.T) {
 	}
 
 	// Now delete all payments except in-flight.
-	numPayments, err = paymentDB.DeletePayments(false, false)
+	numPayments, err = paymentDB.DeletePayments(ctx, false, false)
 	require.NoError(t, err)
 	require.EqualValues(t, 2, numPayments)
 
@@ -407,19 +409,21 @@ func deletePayment(t *testing.T, db kvdb.Backend, paymentHash lntypes.Hash,
 func TestFetchPaymentWithSequenceNumber(t *testing.T) {
 	paymentDB := NewKVTestDB(t)
 
+	ctx := t.Context()
+
 	// Generate a test payment which does not have duplicates.
 	noDuplicates, _, err := genInfo(t)
 	require.NoError(t, err)
 
 	// Create a new payment entry in the database.
 	err = paymentDB.InitPayment(
-		noDuplicates.PaymentIdentifier, noDuplicates,
+		ctx, noDuplicates.PaymentIdentifier, noDuplicates,
 	)
 	require.NoError(t, err)
 
 	// Fetch the payment so we can get its sequence nr.
 	noDuplicatesPayment, err := paymentDB.FetchPayment(
-		noDuplicates.PaymentIdentifier,
+		ctx, noDuplicates.PaymentIdentifier,
 	)
 	require.NoError(t, err)
 
@@ -429,13 +433,13 @@ func TestFetchPaymentWithSequenceNumber(t *testing.T) {
 
 	// Create a new payment entry in the database.
 	err = paymentDB.InitPayment(
-		hasDuplicates.PaymentIdentifier, hasDuplicates,
+		ctx, hasDuplicates.PaymentIdentifier, hasDuplicates,
 	)
 	require.NoError(t, err)
 
 	// Fetch the payment so we can get its sequence nr.
 	hasDuplicatesPayment, err := paymentDB.FetchPayment(
-		hasDuplicates.PaymentIdentifier,
+		ctx, hasDuplicates.PaymentIdentifier,
 	)
 	require.NoError(t, err)
 
@@ -740,14 +744,14 @@ func TestKVStoreQueryPaymentsDuplicates(t *testing.T) {
 
 				// Create a new payment entry in the database.
 				err = paymentDB.InitPayment(
-					info.PaymentIdentifier, info,
+					ctx, info.PaymentIdentifier, info,
 				)
 				require.NoError(t, err)
 
 				// Immediately delete the payment with index 2.
 				if i == 1 {
 					pmt, err := paymentDB.FetchPayment(
-						info.PaymentIdentifier,
+						ctx, info.PaymentIdentifier,
 					)
 					require.NoError(t, err)
 
@@ -764,7 +768,7 @@ func TestKVStoreQueryPaymentsDuplicates(t *testing.T) {
 				// duplicate payments will always be succeeded.
 				if i == (nonDuplicatePayments - 1) {
 					pmt, err := paymentDB.FetchPayment(
-						info.PaymentIdentifier,
+						ctx, info.PaymentIdentifier,
 					)
 					require.NoError(t, err)
 
diff --git a/payments/db/payment_test.go b/payments/db/payment_test.go
index ddba0e0285c..25aafbb5464 100644
--- a/payments/db/payment_test.go
+++ b/payments/db/payment_test.go
@@ -125,6 +125,8 @@ type payment struct {
 func createTestPayments(t *testing.T, p DB, payments []*payment) {
 	t.Helper()
 
+	ctx := t.Context()
+
 	attemptID := uint64(0)
 
 	for i := 0; i < len(payments); i++ {
@@ -145,16 +147,16 @@ func createTestPayments(t *testing.T, p DB, payments []*payment) {
 		attemptID++
 
 		// Init the payment.
-		err = p.InitPayment(info.PaymentIdentifier, info)
+		err = p.InitPayment(ctx, info.PaymentIdentifier, info)
 		require.NoError(t, err, "unable to send htlc message")
 
 		// Register and fail the first attempt for all payments.
-		_, err = p.RegisterAttempt(info.PaymentIdentifier, attempt)
+		_, err = p.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 		require.NoError(t, err, "unable to send htlc message")
 
 		htlcFailure := HTLCFailUnreadable
 		_, err = p.FailAttempt(
-			info.PaymentIdentifier, attempt.AttemptID,
+			ctx, info.PaymentIdentifier, attempt.AttemptID,
 			&HTLCFailInfo{
 				Reason: htlcFailure,
 			},
@@ -173,7 +175,7 @@ func createTestPayments(t *testing.T, p DB, payments []*payment) {
 		require.NoError(t, err)
 		attemptID++
 
-		_, err = p.RegisterAttempt(info.PaymentIdentifier, attempt)
+		_, err = p.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 		require.NoError(t, err, "unable to send htlc message")
 
 		switch payments[i].status {
@@ -181,7 +183,7 @@ func createTestPayments(t *testing.T, p DB, payments []*payment) {
 		case StatusFailed:
 			htlcFailure := HTLCFailUnreadable
 			_, err = p.FailAttempt(
-				info.PaymentIdentifier, attempt.AttemptID,
+				ctx, info.PaymentIdentifier, attempt.AttemptID,
 				&HTLCFailInfo{
 					Reason: htlcFailure,
 				},
@@ -189,14 +191,15 @@ func createTestPayments(t *testing.T, p DB, payments []*payment) {
 			require.NoError(t, err, "unable to fail htlc")
 
 			failReason := FailureReasonNoRoute
-			_, err = p.Fail(info.PaymentIdentifier,
-				failReason)
+			_, err = p.Fail(
+				ctx, info.PaymentIdentifier, failReason,
+			)
 			require.NoError(t, err, "unable to fail payment hash")
 
 		// Settle the attempt
 		case StatusSucceeded:
 			_, err := p.SettleAttempt(
-				info.PaymentIdentifier, attempt.AttemptID,
+				ctx, info.PaymentIdentifier, attempt.AttemptID,
 				&HTLCSettleInfo{
 					Preimage: preimg,
 				},
@@ -235,7 +238,9 @@ func assertPaymentInfo(t *testing.T, p DB, hash lntypes.Hash,
 
 	t.Helper()
 
-	payment, err := p.FetchPayment(hash)
+	ctx := t.Context()
+
+	payment, err := p.FetchPayment(ctx, hash)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -303,7 +308,9 @@ func assertDBPaymentstatus(t *testing.T, p DB, hash lntypes.Hash,
 
 	t.Helper()
 
-	payment, err := p.FetchPayment(hash)
+	ctx := t.Context()
+
+	payment, err := p.FetchPayment(ctx, hash)
 	if errors.Is(err, ErrPaymentNotInitiated) {
 		return
 	}
@@ -496,7 +503,9 @@ func testDeleteFailedAttempts(t *testing.T, keepFailedPaymentAttempts bool) {
 
 	// Calling DeleteFailedAttempts on a failed payment should delete all
 	// HTLCs.
-	require.NoError(t, paymentDB.DeleteFailedAttempts(payments[0].id))
+	require.NoError(t, paymentDB.DeleteFailedAttempts(
+		t.Context(), payments[0].id,
+	))
 
 	// Expect all HTLCs to be deleted if the config is set to delete them.
 	if !keepFailedPaymentAttempts {
@@ -511,11 +520,15 @@ func testDeleteFailedAttempts(t *testing.T, keepFailedPaymentAttempts bool) {
 	// operation are performed in general therefore we do NOT expect an
 	// error in this case.
 	if keepFailedPaymentAttempts {
-		require.NoError(
-			t, paymentDB.DeleteFailedAttempts(payments[1].id),
+		err := paymentDB.DeleteFailedAttempts(
+			t.Context(), payments[1].id,
 		)
+		require.NoError(t, err)
 	} else {
-		require.Error(t, paymentDB.DeleteFailedAttempts(payments[1].id))
+		err := paymentDB.DeleteFailedAttempts(
+			t.Context(), payments[1].id,
+		)
+		require.Error(t, err)
 	}
 
 	// Since DeleteFailedAttempts returned an error, we should expect the
@@ -523,7 +536,9 @@ func testDeleteFailedAttempts(t *testing.T, keepFailedPaymentAttempts bool) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Cleaning up a successful payment should remove failed htlcs.
-	require.NoError(t, paymentDB.DeleteFailedAttempts(payments[2].id))
+	require.NoError(t, paymentDB.DeleteFailedAttempts(
+		t.Context(), payments[2].id,
+	))
 
 	// Expect all HTLCs except for the settled one to be deleted if the
 	// config is set to delete them.
@@ -540,13 +555,17 @@ func testDeleteFailedAttempts(t *testing.T, keepFailedPaymentAttempts bool) {
 		// payments, if the control tower is configured to keep failed
 		// HTLCs.
 		require.NoError(
-			t, paymentDB.DeleteFailedAttempts(lntypes.ZeroHash),
+			t, paymentDB.DeleteFailedAttempts(
+				t.Context(), lntypes.ZeroHash,
+			),
 		)
 	} else {
 		// Attempting to cleanup a non-existent payment returns an
 		// error.
 		require.Error(
-			t, paymentDB.DeleteFailedAttempts(lntypes.ZeroHash),
+			t, paymentDB.DeleteFailedAttempts(
+				t.Context(), lntypes.ZeroHash,
+			),
 		)
 	}
 }
@@ -555,6 +574,8 @@ func testDeleteFailedAttempts(t *testing.T, keepFailedPaymentAttempts bool) {
 func TestMPPRecordValidation(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, _ := NewTestDB(t)
 
 	preimg, err := genPreimage(t)
@@ -571,7 +592,7 @@ func TestMPPRecordValidation(t *testing.T) {
 	require.NoError(t, err, "unable to generate htlc message")
 
 	// Init the payment.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err, "unable to send htlc message")
 
 	// Create three unique attempts we'll use for the test, and
@@ -584,7 +605,7 @@ func TestMPPRecordValidation(t *testing.T) {
 		info.Value, [32]byte{1},
 	)
 
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt)
+	_, err = paymentDB.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 	require.NoError(t, err, "unable to send htlc message")
 
 	// Now try to register a non-MPP attempt, which should fail.
@@ -596,21 +617,27 @@ func TestMPPRecordValidation(t *testing.T) {
 
 	attempt2.Route.FinalHop().MPP = nil
 
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt2)
+	_, err = paymentDB.RegisterAttempt(
+		ctx, info.PaymentIdentifier, attempt2,
+	)
 	require.ErrorIs(t, err, ErrMPPayment)
 
 	// Try to register attempt one with a different payment address.
 	attempt2.Route.FinalHop().MPP = record.NewMPP(
 		info.Value, [32]byte{2},
 	)
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt2)
+	_, err = paymentDB.RegisterAttempt(
+		ctx, info.PaymentIdentifier, attempt2,
+	)
 	require.ErrorIs(t, err, ErrMPPPaymentAddrMismatch)
 
 	// Try registering one with a different total amount.
 	attempt2.Route.FinalHop().MPP = record.NewMPP(
 		info.Value/2, [32]byte{1},
 	)
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt2)
+	_, err = paymentDB.RegisterAttempt(
+		ctx, info.PaymentIdentifier, attempt2,
+	)
 	require.ErrorIs(t, err, ErrMPPTotalAmountMismatch)
 
 	// Create and init a new payment. This time we'll check that we cannot
@@ -629,11 +656,13 @@ func TestMPPRecordValidation(t *testing.T) {
 
 	require.NoError(t, err, "unable to generate htlc message")
 
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err, "unable to send htlc message")
 
 	attempt.Route.FinalHop().MPP = nil
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt)
+	_, err = paymentDB.RegisterAttempt(
+		ctx, info.PaymentIdentifier, attempt,
+	)
 	require.NoError(t, err, "unable to send htlc message")
 
 	// Attempt to register an MPP attempt, which should fail.
@@ -647,7 +676,9 @@ func TestMPPRecordValidation(t *testing.T) {
 		info.Value, [32]byte{1},
 	)
 
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt2)
+	_, err = paymentDB.RegisterAttempt(
+		ctx, info.PaymentIdentifier, attempt2,
+	)
 	require.ErrorIs(t, err, ErrNonMPPayment)
 }
 
@@ -656,6 +687,8 @@ func TestMPPRecordValidation(t *testing.T) {
 func TestDeleteSinglePayment(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, _ := NewTestDB(t)
 
 	// Register four payments:
@@ -687,7 +720,9 @@ func TestDeleteSinglePayment(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Delete HTLC attempts for first payment only.
-	require.NoError(t, paymentDB.DeletePayment(payments[0].id, true))
+	require.NoError(t, paymentDB.DeletePayment(
+		ctx, payments[0].id, true,
+	))
 
 	// The first payment is the only altered one as its failed HTLC should
 	// have been removed but is still present as payment.
@@ -695,19 +730,25 @@ func TestDeleteSinglePayment(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Delete the first payment completely.
-	require.NoError(t, paymentDB.DeletePayment(payments[0].id, false))
+	require.NoError(t, paymentDB.DeletePayment(
+		ctx, payments[0].id, false,
+	))
 
 	// The first payment should have been deleted.
 	assertDBPayments(t, paymentDB, payments[1:])
 
 	// Now delete the second payment completely.
-	require.NoError(t, paymentDB.DeletePayment(payments[1].id, false))
+	require.NoError(t, paymentDB.DeletePayment(
+		ctx, payments[1].id, false,
+	))
 
 	// The Second payment should have been deleted.
 	assertDBPayments(t, paymentDB, payments[2:])
 
 	// Delete failed HTLC attempts for the third payment.
-	require.NoError(t, paymentDB.DeletePayment(payments[2].id, true))
+	require.NoError(t, paymentDB.DeletePayment(
+		ctx, payments[2].id, true,
+	))
 
 	// Only the successful HTLC attempt should be left for the third
 	// payment.
@@ -715,21 +756,27 @@ func TestDeleteSinglePayment(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments[2:])
 
 	// Now delete the third payment completely.
-	require.NoError(t, paymentDB.DeletePayment(payments[2].id, false))
+	require.NoError(t, paymentDB.DeletePayment(
+		ctx, payments[2].id, false,
+	))
 
 	// Only the last payment should be left.
 	assertDBPayments(t, paymentDB, payments[3:])
 
 	// Deleting HTLC attempts from InFlight payments should not work and an
 	// error returned.
-	require.Error(t, paymentDB.DeletePayment(payments[3].id, true))
+	require.Error(t, paymentDB.DeletePayment(
+		ctx, payments[3].id, true,
+	))
 
 	// The payment is InFlight and therefore should not have been altered.
 	assertDBPayments(t, paymentDB, payments[3:])
 
 	// Finally deleting the InFlight payment should also not work and an
 	// error returned.
-	require.Error(t, paymentDB.DeletePayment(payments[3].id, false))
+	require.Error(t, paymentDB.DeletePayment(
+		ctx, payments[3].id, false,
+	))
 
 	// The payment is InFlight and therefore should not have been altered.
 	assertDBPayments(t, paymentDB, payments[3:])
@@ -1609,6 +1656,7 @@ func TestSuccessesWithoutInFlight(t *testing.T) {
 
 	// Attempt to complete the payment should fail.
 	_, err = paymentDB.SettleAttempt(
+		t.Context(),
 		info.PaymentIdentifier, 0,
 		&HTLCSettleInfo{
 			Preimage: preimg,
@@ -1632,7 +1680,7 @@ func TestFailsWithoutInFlight(t *testing.T) {
 
 	// Calling Fail should return an error.
 	_, err = paymentDB.Fail(
-		info.PaymentIdentifier, FailureReasonNoRoute,
+		t.Context(), info.PaymentIdentifier, FailureReasonNoRoute,
 	)
 	require.ErrorIs(t, err, ErrPaymentNotInitiated)
 }
@@ -1642,6 +1690,8 @@ func TestFailsWithoutInFlight(t *testing.T) {
 func TestDeletePayments(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, _ := NewTestDB(t)
 
 	// Register three payments:
@@ -1662,7 +1712,7 @@ func TestDeletePayments(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Delete HTLC attempts for failed payments only.
-	numPayments, err := paymentDB.DeletePayments(true, true)
+	numPayments, err := paymentDB.DeletePayments(ctx, true, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, numPayments)
 
@@ -1671,7 +1721,7 @@ func TestDeletePayments(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Delete failed attempts for all payments.
-	numPayments, err = paymentDB.DeletePayments(false, true)
+	numPayments, err = paymentDB.DeletePayments(ctx, false, true)
 	require.NoError(t, err)
 	require.EqualValues(t, 0, numPayments)
 
@@ -1681,14 +1731,14 @@ func TestDeletePayments(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Now delete all failed payments.
-	numPayments, err = paymentDB.DeletePayments(true, false)
+	numPayments, err = paymentDB.DeletePayments(ctx, true, false)
 	require.NoError(t, err)
 	require.EqualValues(t, 1, numPayments)
 
 	assertDBPayments(t, paymentDB, payments[1:])
 
 	// Finally delete all completed payments.
-	numPayments, err = paymentDB.DeletePayments(false, false)
+	numPayments, err = paymentDB.DeletePayments(ctx, false, false)
 	require.NoError(t, err)
 	require.EqualValues(t, 1, numPayments)
 
@@ -1700,6 +1750,8 @@ func TestDeletePayments(t *testing.T) {
 func TestSwitchDoubleSend(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, harness := NewTestDB(t)
 
 	preimg, err := genPreimage(t)
@@ -1712,7 +1764,7 @@ func TestSwitchDoubleSend(t *testing.T) {
 
 	// Sends base htlc message which initiate base status and move it to
 	// StatusInFlight and verifies that it was changed.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err, "unable to send htlc message")
 
 	harness.AssertPaymentIndex(t, info.PaymentIdentifier)
@@ -1726,11 +1778,11 @@ func TestSwitchDoubleSend(t *testing.T) {
 	// Try to initiate double sending of htlc message with the same
 	// payment hash, should result in error indicating that payment has
 	// already been sent.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.ErrorIs(t, err, ErrPaymentExists)
 
 	// Record an attempt.
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt)
+	_, err = paymentDB.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 	require.NoError(t, err, "unable to send htlc message")
 	assertDBPaymentstatus(
 		t, paymentDB, info.PaymentIdentifier, StatusInFlight,
@@ -1744,7 +1796,7 @@ func TestSwitchDoubleSend(t *testing.T) {
 	)
 
 	// Sends base htlc message which initiate StatusInFlight.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	if !errors.Is(err, ErrPaymentInFlight) {
 		t.Fatalf("payment control wrong behaviour: " +
 			"double sending must trigger ErrPaymentInFlight error")
@@ -1752,7 +1804,7 @@ func TestSwitchDoubleSend(t *testing.T) {
 
 	// After settling, the error should be ErrAlreadyPaid.
 	_, err = paymentDB.SettleAttempt(
-		info.PaymentIdentifier, attempt.AttemptID,
+		ctx, info.PaymentIdentifier, attempt.AttemptID,
 		&HTLCSettleInfo{
 			Preimage: preimg,
 		},
@@ -1767,7 +1819,7 @@ func TestSwitchDoubleSend(t *testing.T) {
 		t, paymentDB, info.PaymentIdentifier, info, nil, htlc,
 	)
 
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	if !errors.Is(err, ErrAlreadyPaid) {
 		t.Fatalf("unable to send htlc message: %v", err)
 	}
@@ -1778,6 +1830,8 @@ func TestSwitchDoubleSend(t *testing.T) {
 func TestSwitchFail(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, harness := NewTestDB(t)
 
 	preimg, err := genPreimage(t)
@@ -1789,7 +1843,7 @@ func TestSwitchFail(t *testing.T) {
 	require.NoError(t, err)
 
 	// Sends base htlc message which initiate StatusInFlight.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err, "unable to send htlc message")
 
 	harness.AssertPaymentIndex(t, info.PaymentIdentifier)
@@ -1802,7 +1856,7 @@ func TestSwitchFail(t *testing.T) {
 
 	// Fail the payment, which should moved it to Failed.
 	failReason := FailureReasonNoRoute
-	_, err = paymentDB.Fail(info.PaymentIdentifier, failReason)
+	_, err = paymentDB.Fail(ctx, info.PaymentIdentifier, failReason)
 	require.NoError(t, err, "unable to fail payment hash")
 
 	// Verify the status is indeed Failed.
@@ -1816,12 +1870,12 @@ func TestSwitchFail(t *testing.T) {
 
 	// Lookup the payment so we can get its old sequence number before it is
 	// overwritten.
-	payment, err := paymentDB.FetchPayment(info.PaymentIdentifier)
+	payment, err := paymentDB.FetchPayment(ctx, info.PaymentIdentifier)
 	require.NoError(t, err)
 
 	// Sends the htlc again, which should succeed since the prior payment
 	// failed.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err, "unable to send htlc message")
 
 	// Check that our index has been updated, and the old index has been
@@ -1839,12 +1893,12 @@ func TestSwitchFail(t *testing.T) {
 	// Record a new attempt. In this test scenario, the attempt fails.
 	// However, this is not communicated to control tower in the current
 	// implementation. It only registers the initiation of the attempt.
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt)
+	_, err = paymentDB.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 	require.NoError(t, err, "unable to register attempt")
 
 	htlcReason := HTLCFailUnreadable
 	_, err = paymentDB.FailAttempt(
-		info.PaymentIdentifier, attempt.AttemptID,
+		ctx, info.PaymentIdentifier, attempt.AttemptID,
 		&HTLCFailInfo{
 			Reason: htlcReason,
 		},
@@ -1869,7 +1923,7 @@ func TestSwitchFail(t *testing.T) {
 	)
 	require.NoError(t, err)
 
-	_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, attempt)
+	_, err = paymentDB.RegisterAttempt(ctx, info.PaymentIdentifier, attempt)
 	require.NoError(t, err, "unable to send htlc message")
 	assertDBPaymentstatus(
 		t, paymentDB, info.PaymentIdentifier, StatusInFlight,
@@ -1886,7 +1940,7 @@ func TestSwitchFail(t *testing.T) {
 	// Settle the attempt and verify that status was changed to
 	// StatusSucceeded.
 	payment, err = paymentDB.SettleAttempt(
-		info.PaymentIdentifier, attempt.AttemptID,
+		ctx, info.PaymentIdentifier, attempt.AttemptID,
 		&HTLCSettleInfo{
 			Preimage: preimg,
 		},
@@ -1916,7 +1970,7 @@ func TestSwitchFail(t *testing.T) {
 
 	// Attempt a final payment, which should now fail since the prior
 	// payment succeed.
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	if !errors.Is(err, ErrAlreadyPaid) {
 		t.Fatalf("unable to send htlc message: %v", err)
 	}
@@ -1927,6 +1981,8 @@ func TestSwitchFail(t *testing.T) {
 func TestMultiShard(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	// We will register three HTLC attempts, and always fail the second
 	// one. We'll generate all combinations of settling/failing the first
 	// and third HTLC, and assert that the payment status end up as we
@@ -1953,7 +2009,7 @@ func TestMultiShard(t *testing.T) {
 		info := genPaymentCreationInfo(t, rhash)
 
 		// Init the payment, moving it to the StatusInFlight state.
-		err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+		err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 		require.NoError(t, err)
 
 		harness.AssertPaymentIndex(t, info.PaymentIdentifier)
@@ -1985,7 +2041,7 @@ func TestMultiShard(t *testing.T) {
 			attempts = append(attempts, a)
 
 			_, err = paymentDB.RegisterAttempt(
-				info.PaymentIdentifier, a,
+				ctx, info.PaymentIdentifier, a,
 			)
 			if err != nil {
 				t.Fatalf("unable to send htlc message: %v", err)
@@ -2017,14 +2073,16 @@ func TestMultiShard(t *testing.T) {
 			info.Value, [32]byte{1},
 		)
 
-		_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, b)
+		_, err = paymentDB.RegisterAttempt(
+			ctx, info.PaymentIdentifier, b,
+		)
 		require.ErrorIs(t, err, ErrValueExceedsAmt)
 
 		// Fail the second attempt.
 		a := attempts[1]
 		htlcFail := HTLCFailUnreadable
 		_, err = paymentDB.FailAttempt(
-			info.PaymentIdentifier, a.AttemptID,
+			ctx, info.PaymentIdentifier, a.AttemptID,
 			&HTLCFailInfo{
 				Reason: htlcFail,
 			},
@@ -2055,7 +2113,7 @@ func TestMultiShard(t *testing.T) {
 		var firstFailReason *FailureReason
 		if test.settleFirst {
 			_, err := paymentDB.SettleAttempt(
-				info.PaymentIdentifier, a.AttemptID,
+				ctx, info.PaymentIdentifier, a.AttemptID,
 				&HTLCSettleInfo{
 					Preimage: preimg,
 				},
@@ -2073,7 +2131,7 @@ func TestMultiShard(t *testing.T) {
 			)
 		} else {
 			_, err := paymentDB.FailAttempt(
-				info.PaymentIdentifier, a.AttemptID,
+				ctx, info.PaymentIdentifier, a.AttemptID,
 				&HTLCFailInfo{
 					Reason: htlcFail,
 				},
@@ -2094,7 +2152,7 @@ func TestMultiShard(t *testing.T) {
 			// a terminal state.
 			failReason := FailureReasonNoRoute
 			_, err = paymentDB.Fail(
-				info.PaymentIdentifier, failReason,
+				ctx, info.PaymentIdentifier, failReason,
 			)
 			if err != nil {
 				t.Fatalf("unable to fail payment hash: %v", err)
@@ -2124,7 +2182,9 @@ func TestMultiShard(t *testing.T) {
 			info.Value, [32]byte{1},
 		)
 
-		_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, b)
+		_, err = paymentDB.RegisterAttempt(
+			ctx, info.PaymentIdentifier, b,
+		)
 		if test.settleFirst {
 			require.ErrorIs(
 				t, err, ErrPaymentPendingSettled,
@@ -2147,7 +2207,7 @@ func TestMultiShard(t *testing.T) {
 		if test.settleLast {
 			// Settle the last outstanding attempt.
 			_, err = paymentDB.SettleAttempt(
-				info.PaymentIdentifier, a.AttemptID,
+				ctx, info.PaymentIdentifier, a.AttemptID,
 				&HTLCSettleInfo{
 					Preimage: preimg,
 				},
@@ -2162,7 +2222,7 @@ func TestMultiShard(t *testing.T) {
 		} else {
 			// Fail the attempt.
 			_, err := paymentDB.FailAttempt(
-				info.PaymentIdentifier, a.AttemptID,
+				ctx, info.PaymentIdentifier, a.AttemptID,
 				&HTLCFailInfo{
 					Reason: htlcFail,
 				},
@@ -2185,7 +2245,7 @@ func TestMultiShard(t *testing.T) {
 			// syncing.
 			failReason := FailureReasonPaymentDetails
 			_, err = paymentDB.Fail(
-				info.PaymentIdentifier, failReason,
+				ctx, info.PaymentIdentifier, failReason,
 			)
 			require.NoError(t, err, "unable to fail")
 		}
@@ -2223,7 +2283,9 @@ func TestMultiShard(t *testing.T) {
 		)
 
 		// Finally assert we cannot register more attempts.
-		_, err = paymentDB.RegisterAttempt(info.PaymentIdentifier, b)
+		_, err = paymentDB.RegisterAttempt(
+			ctx, info.PaymentIdentifier, b,
+		)
 		require.ErrorIs(t, err, registerErr)
 	}
 
@@ -2583,7 +2645,7 @@ func TestQueryPayments(t *testing.T) {
 
 				// Create a new payment entry in the database.
 				err = paymentDB.InitPayment(
-					info.PaymentIdentifier, info,
+					ctx, info.PaymentIdentifier, info,
 				)
 				require.NoError(t, err)
 			}
@@ -2591,19 +2653,19 @@ func TestQueryPayments(t *testing.T) {
 			// Now delete the payment at index 1 (the second
 			// payment).
 			pmt, err := paymentDB.FetchPayment(
-				paymentInfos[1].PaymentIdentifier,
+				ctx, paymentInfos[1].PaymentIdentifier,
 			)
 			require.NoError(t, err)
 
 			// We delete the whole payment.
 			err = paymentDB.DeletePayment(
-				paymentInfos[1].PaymentIdentifier, false,
+				ctx, paymentInfos[1].PaymentIdentifier, false,
 			)
 			require.NoError(t, err)
 
 			// Verify the payment is deleted.
 			_, err = paymentDB.FetchPayment(
-				paymentInfos[1].PaymentIdentifier,
+				ctx, paymentInfos[1].PaymentIdentifier,
 			)
 			require.ErrorIs(
 				t, err, ErrPaymentNotInitiated,
@@ -2626,7 +2688,7 @@ func TestQueryPayments(t *testing.T) {
 			require.NoError(t, err)
 
 			_, err = paymentDB.RegisterAttempt(
-				lastPaymentInfo.PaymentIdentifier,
+				ctx, lastPaymentInfo.PaymentIdentifier,
 				&attempt.HTLCAttemptInfo,
 			)
 			require.NoError(t, err)
@@ -2635,7 +2697,7 @@ func TestQueryPayments(t *testing.T) {
 			copy(preimg[:], rev[:])
 
 			_, err = paymentDB.SettleAttempt(
-				lastPaymentInfo.PaymentIdentifier,
+				ctx, lastPaymentInfo.PaymentIdentifier,
 				attempt.AttemptID,
 				&HTLCSettleInfo{
 					Preimage: preimg,
@@ -2716,6 +2778,8 @@ func TestQueryPayments(t *testing.T) {
 func TestFetchInFlightPayments(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, _ := NewTestDB(t)
 
 	// Register payments with different statuses:
@@ -2741,7 +2805,7 @@ func TestFetchInFlightPayments(t *testing.T) {
 	assertDBPayments(t, paymentDB, payments)
 
 	// Fetch in-flight payments.
-	inFlightPayments, err := paymentDB.FetchInFlightPayments()
+	inFlightPayments, err := paymentDB.FetchInFlightPayments(ctx)
 	require.NoError(t, err)
 
 	// We should only get the two in-flight payments.
@@ -2763,7 +2827,7 @@ func TestFetchInFlightPayments(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = paymentDB.SettleAttempt(
-		payments[2].id, 5,
+		ctx, payments[2].id, 5,
 		&HTLCSettleInfo{
 			Preimage: preimg,
 		},
@@ -2771,7 +2835,7 @@ func TestFetchInFlightPayments(t *testing.T) {
 	require.NoError(t, err)
 
 	// Fetch in-flight payments again.
-	inFlightPayments, err = paymentDB.FetchInFlightPayments()
+	inFlightPayments, err = paymentDB.FetchInFlightPayments(ctx)
 	require.NoError(t, err)
 
 	// We should now only get one in-flight payment.
@@ -2788,6 +2852,8 @@ func TestFetchInFlightPayments(t *testing.T) {
 func TestFetchInFlightPaymentsMultipleAttempts(t *testing.T) {
 	t.Parallel()
 
+	ctx := t.Context()
+
 	paymentDB, _ := NewTestDB(t)
 
 	preimg, err := genPreimage(t)
@@ -2798,7 +2864,7 @@ func TestFetchInFlightPaymentsMultipleAttempts(t *testing.T) {
 
 	// Init payment with double the amount to allow two attempts.
 	info.Value *= 2
-	err = paymentDB.InitPayment(info.PaymentIdentifier, info)
+	err = paymentDB.InitPayment(ctx, info.PaymentIdentifier, info)
 	require.NoError(t, err)
 
 	// Register two attempts for the same payment.
@@ -2806,7 +2872,7 @@ func TestFetchInFlightPaymentsMultipleAttempts(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = paymentDB.RegisterAttempt(
-		info.PaymentIdentifier, attempt1,
+		ctx, info.PaymentIdentifier, attempt1,
 	)
 	require.NoError(t, err)
 
@@ -2814,12 +2880,12 @@ func TestFetchInFlightPaymentsMultipleAttempts(t *testing.T) {
 	require.NoError(t, err)
 
 	_, err = paymentDB.RegisterAttempt(
-		info.PaymentIdentifier, attempt2,
+		ctx, info.PaymentIdentifier, attempt2,
 	)
 	require.NoError(t, err)
 
 	// Both attempts are in-flight. Fetch in-flight payments.
-	inFlightPayments, err := paymentDB.FetchInFlightPayments()
+	inFlightPayments, err := paymentDB.FetchInFlightPayments(ctx)
 	require.NoError(t, err)
 
 	// We should only get one payment even though it has 2 in-flight
diff --git a/payments/db/sql_store.go b/payments/db/sql_store.go
index 0109ca1afa1..d23e80895f9 100644
--- a/payments/db/sql_store.go
+++ b/payments/db/sql_store.go
@@ -922,8 +922,8 @@ func fetchPaymentByHash(ctx context.Context, db SQLQueries,
 // Returns ErrPaymentNotInitiated if no payment with the given hash exists.
 //
 // This is part of the DB interface.
-func (s *SQLStore) FetchPayment(paymentHash lntypes.Hash) (*MPPayment, error) {
-	ctx := context.TODO()
+func (s *SQLStore) FetchPayment(ctx context.Context,
+	paymentHash lntypes.Hash) (*MPPayment, error) {
 
 	var mpPayment *MPPayment
 
@@ -972,11 +972,9 @@ func (s *SQLStore) FetchPayment(paymentHash lntypes.Hash) (*MPPayment, error) {
 // While inflight payments are typically a small subset, this would improve
 // memory efficiency for nodes with unusually high numbers of concurrent
 // payments and would better leverage the existing pagination infrastructure.
-func (s *SQLStore) FetchInFlightPayments() ([]*MPPayment,
+func (s *SQLStore) FetchInFlightPayments(ctx context.Context) ([]*MPPayment,
 	error) {
 
-	ctx := context.TODO()
-
 	var mpPayments []*MPPayment
 
 	err := s.db.ExecTx(ctx, sqldb.ReadTxOpt(), func(db SQLQueries) error {
@@ -1108,8 +1106,8 @@ func (s *SQLStore) FetchInFlightPayments() ([]*MPPayment,
 // the final step (step 5) in the payment lifecycle control flow and should be
 // called after a payment reaches a terminal state (succeeded or permanently
 // failed) to clean up historical failed attempts.
-func (s *SQLStore) DeleteFailedAttempts(paymentHash lntypes.Hash) error {
-	ctx := context.TODO()
+func (s *SQLStore) DeleteFailedAttempts(ctx context.Context,
+	paymentHash lntypes.Hash) error {
 
 	// In case we are configured to keep failed payment attempts, we exit
 	// early.
@@ -1206,11 +1204,9 @@ func computePaymentStatusFromDB(ctx context.Context, cfg *sqldb.QueryConfig,
 //
 // This method is part of the PaymentWriter interface, which is embedded in
 // the DB interface.
-func (s *SQLStore) DeletePayment(paymentHash lntypes.Hash,
+func (s *SQLStore) DeletePayment(ctx context.Context, paymentHash lntypes.Hash,
 	failedHtlcsOnly bool) error {
 
-	ctx := context.TODO()
-
 	err := s.db.ExecTx(ctx, sqldb.WriteTxOpt(), func(db SQLQueries) error {
 		dbPayment, err := fetchPaymentByHash(ctx, db, paymentHash)
 		if err != nil {
@@ -1269,11 +1265,9 @@ func (s *SQLStore) DeletePayment(paymentHash lntypes.Hash,
 // This method is part of the PaymentControl interface, which is embedded in
 // the PaymentWriter interface and ultimately the DB interface, representing
 // the first step in the payment lifecycle control flow.
-func (s *SQLStore) InitPayment(paymentHash lntypes.Hash,
+func (s *SQLStore) InitPayment(ctx context.Context, paymentHash lntypes.Hash,
 	paymentCreationInfo *PaymentCreationInfo) error {
 
-	ctx := context.TODO()
-
 	// Create the payment in the database.
 	err := s.db.ExecTx(ctx, sqldb.WriteTxOpt(), func(db SQLQueries) error {
 		existingPayment, err := db.FetchPayment(ctx, paymentHash[:])
@@ -1502,10 +1496,9 @@ func (s *SQLStore) insertRouteHops(ctx context.Context, db SQLQueries,
 // the PaymentWriter interface and ultimately the DB interface. It represents
 // step 2 in the payment lifecycle control flow, called after InitPayment and
 // potentially multiple times for multi-path payments.
-func (s *SQLStore) RegisterAttempt(paymentHash lntypes.Hash,
-	attempt *HTLCAttemptInfo) (*MPPayment, error) {
-
-	ctx := context.TODO()
+func (s *SQLStore) RegisterAttempt(ctx context.Context,
+	paymentHash lntypes.Hash, attempt *HTLCAttemptInfo) (*MPPayment,
+	error) {
 
 	var mpPayment *MPPayment
 
@@ -1629,11 +1622,9 @@ func (s *SQLStore) RegisterAttempt(paymentHash lntypes.Hash,
 // the PaymentWriter interface and ultimately the DB interface. It represents
 // step 3a in the payment lifecycle control flow (step 3b is FailAttempt),
 // called after RegisterAttempt when an HTLC successfully completes.
-func (s *SQLStore) SettleAttempt(paymentHash lntypes.Hash,
+func (s *SQLStore) SettleAttempt(ctx context.Context, paymentHash lntypes.Hash,
 	attemptID uint64, settleInfo *HTLCSettleInfo) (*MPPayment, error) {
 
-	ctx := context.TODO()
-
 	var mpPayment *MPPayment
 
 	err := s.db.ExecTx(ctx, sqldb.WriteTxOpt(), func(db SQLQueries) error {
@@ -1704,11 +1695,9 @@ func (s *SQLStore) SettleAttempt(paymentHash lntypes.Hash,
 // the PaymentWriter interface and ultimately the DB interface. It represents
 // step 3b in the payment lifecycle control flow (step 3a is SettleAttempt),
 // called after RegisterAttempt when an HTLC fails.
-func (s *SQLStore) FailAttempt(paymentHash lntypes.Hash,
+func (s *SQLStore) FailAttempt(ctx context.Context, paymentHash lntypes.Hash,
 	attemptID uint64, failInfo *HTLCFailInfo) (*MPPayment, error) {
 
-	ctx := context.TODO()
-
 	var mpPayment *MPPayment
 
 	err := s.db.ExecTx(ctx, sqldb.WriteTxOpt(), func(db SQLQueries) error {
@@ -1793,11 +1782,9 @@ func (s *SQLStore) FailAttempt(paymentHash lntypes.Hash,
 // This method is part of the PaymentControl interface, which is embedded in
 // the PaymentWriter interface and ultimately the DB interface. It represents
 // step 4 in the payment lifecycle control flow.
-func (s *SQLStore) Fail(paymentHash lntypes.Hash,
+func (s *SQLStore) Fail(ctx context.Context, paymentHash lntypes.Hash,
 	reason FailureReason) (*MPPayment, error) {
 
-	ctx := context.TODO()
-
 	var mpPayment *MPPayment
 
 	err := s.db.ExecTx(ctx, sqldb.WriteTxOpt(), func(db SQLQueries) error {
@@ -1876,13 +1863,13 @@ func (s *SQLStore) Fail(paymentHash lntypes.Hash,
 // This method is part of the PaymentWriter interface, which is embedded in
 // the DB interface.
 //
-// TODO(ziggie): batch this call instead in the background so for dbs with
-// many payments it doesn't block the main thread.
-func (s *SQLStore) DeletePayments(failedOnly, failedHtlcsOnly bool) (int,
-	error) {
+// TODO(ziggie): batch and use iterator instead, moreover we dont need to fetch
+// the complete payment data for each payment, we can just fetch the payment ID
+// and the resolution types to decide if the payment is removable.
+func (s *SQLStore) DeletePayments(ctx context.Context, failedOnly,
+	failedHtlcsOnly bool) (int, error) {
 
 	var numPayments int
-	ctx := context.TODO()
 
 	extractCursor := func(row sqlc.FilterPaymentsRow) int64 {
 		return row.Payment.ID
diff --git a/payments/db/test_kvdb.go b/payments/db/test_kvdb.go
index ed1710b14fa..c2de0b43f04 100644
--- a/payments/db/test_kvdb.go
+++ b/payments/db/test_kvdb.go
@@ -57,9 +57,11 @@ func (h *kvTestHarness) AssertPaymentIndex(t *testing.T,
 
 	t.Helper()
 
+	ctx := t.Context()
+
 	// Lookup the payment so that we have its sequence number and check
 	// that it has correctly been indexed in the payment indexes bucket.
-	pmt, err := h.db.FetchPayment(expectedHash)
+	pmt, err := h.db.FetchPayment(ctx, expectedHash)
 	require.NoError(t, err)
 
 	hash, err := h.fetchPaymentIndexEntry(t, pmt.SequenceNum)
diff --git a/routing/control_tower.go b/routing/control_tower.go
index 2b9e7dd9d28..1c246f17d9b 100644
--- a/routing/control_tower.go
+++ b/routing/control_tower.go
@@ -1,6 +1,7 @@
 package routing
 
 import (
+	"context"
 	"sync"
 
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -19,17 +20,19 @@ type ControlTower interface {
 	// also notifies subscribers of the payment creation.
 	//
 	// NOTE: Subscribers should be notified by the new state of the payment.
-	InitPayment(lntypes.Hash, *paymentsdb.PaymentCreationInfo) error
+	InitPayment(context.Context, lntypes.Hash,
+		*paymentsdb.PaymentCreationInfo) error
 
 	// DeleteFailedAttempts removes all failed HTLCs from the db. It should
 	// be called for a given payment whenever all inflight htlcs are
 	// completed, and the payment has reached a final settled state.
-	DeleteFailedAttempts(lntypes.Hash) error
+	DeleteFailedAttempts(context.Context, lntypes.Hash) error
 
 	// RegisterAttempt atomically records the provided HTLCAttemptInfo.
 	//
 	// NOTE: Subscribers should be notified by the new state of the payment.
-	RegisterAttempt(lntypes.Hash, *paymentsdb.HTLCAttemptInfo) error
+	RegisterAttempt(context.Context, lntypes.Hash,
+		*paymentsdb.HTLCAttemptInfo) error
 
 	// SettleAttempt marks the given attempt settled with the preimage. If
 	// this is a multi shard payment, this might implicitly mean the the
@@ -41,18 +44,19 @@ type ControlTower interface {
 	// for record keeping.
 	//
 	// NOTE: Subscribers should be notified by the new state of the payment.
-	SettleAttempt(lntypes.Hash, uint64, *paymentsdb.HTLCSettleInfo) (
-		*paymentsdb.HTLCAttempt, error)
+	SettleAttempt(context.Context, lntypes.Hash, uint64,
+		*paymentsdb.HTLCSettleInfo) (*paymentsdb.HTLCAttempt, error)
 
 	// FailAttempt marks the given payment attempt failed.
 	//
 	// NOTE: Subscribers should be notified by the new state of the payment.
-	FailAttempt(lntypes.Hash, uint64, *paymentsdb.HTLCFailInfo) (
-		*paymentsdb.HTLCAttempt, error)
+	FailAttempt(context.Context, lntypes.Hash, uint64,
+		*paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt, error)
 
 	// FetchPayment fetches the payment corresponding to the given payment
 	// hash.
-	FetchPayment(paymentHash lntypes.Hash) (paymentsdb.DBMPPayment, error)
+	FetchPayment(ctx context.Context,
+		paymentHash lntypes.Hash) (paymentsdb.DBMPPayment, error)
 
 	// FailPayment transitions a payment into the Failed state, and records
 	// the ultimate reason the payment failed. Note that this should only
@@ -62,10 +66,12 @@ type ControlTower interface {
 	// payment.
 	//
 	// NOTE: Subscribers should be notified by the new state of the payment.
-	FailPayment(lntypes.Hash, paymentsdb.FailureReason) error
+	FailPayment(context.Context, lntypes.Hash,
+		paymentsdb.FailureReason) error
 
 	// FetchInFlightPayments returns all payments with status InFlight.
-	FetchInFlightPayments() ([]*paymentsdb.MPPayment, error)
+	FetchInFlightPayments(ctx context.Context) ([]*paymentsdb.MPPayment,
+		error)
 
 	// SubscribePayment subscribes to updates for the payment with the given
 	// hash. A first update with the current state of the payment is always
@@ -161,10 +167,10 @@ func NewControlTower(db paymentsdb.DB) ControlTower {
 // making sure it does not already exist as an in-flight payment. Then this
 // method returns successfully, the payment is guaranteed to be in the
 // Initiated state.
-func (p *controlTower) InitPayment(paymentHash lntypes.Hash,
-	info *paymentsdb.PaymentCreationInfo) error {
+func (p *controlTower) InitPayment(ctx context.Context,
+	paymentHash lntypes.Hash, info *paymentsdb.PaymentCreationInfo) error {
 
-	err := p.db.InitPayment(paymentHash, info)
+	err := p.db.InitPayment(ctx, paymentHash, info)
 	if err != nil {
 		return err
 	}
@@ -174,7 +180,7 @@ func (p *controlTower) InitPayment(paymentHash lntypes.Hash,
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.FetchPayment(paymentHash)
+	payment, err := p.db.FetchPayment(ctx, paymentHash)
 	if err != nil {
 		return err
 	}
@@ -186,19 +192,21 @@ func (p *controlTower) InitPayment(paymentHash lntypes.Hash,
 
 // DeleteFailedAttempts deletes all failed htlcs if the payment was
 // successfully settled.
-func (p *controlTower) DeleteFailedAttempts(paymentHash lntypes.Hash) error {
-	return p.db.DeleteFailedAttempts(paymentHash)
+func (p *controlTower) DeleteFailedAttempts(ctx context.Context,
+	paymentHash lntypes.Hash) error {
+
+	return p.db.DeleteFailedAttempts(ctx, paymentHash)
 }
 
 // RegisterAttempt atomically records the provided HTLCAttemptInfo to the
 // DB.
-func (p *controlTower) RegisterAttempt(paymentHash lntypes.Hash,
-	attempt *paymentsdb.HTLCAttemptInfo) error {
+func (p *controlTower) RegisterAttempt(ctx context.Context,
+	paymentHash lntypes.Hash, attempt *paymentsdb.HTLCAttemptInfo) error {
 
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.RegisterAttempt(paymentHash, attempt)
+	payment, err := p.db.RegisterAttempt(ctx, paymentHash, attempt)
 	if err != nil {
 		return err
 	}
@@ -212,14 +220,17 @@ func (p *controlTower) RegisterAttempt(paymentHash lntypes.Hash,
 // SettleAttempt marks the given attempt settled with the preimage. If
 // this is a multi shard payment, this might implicitly mean the the
 // full payment succeeded.
-func (p *controlTower) SettleAttempt(paymentHash lntypes.Hash,
-	attemptID uint64, settleInfo *paymentsdb.HTLCSettleInfo) (
-	*paymentsdb.HTLCAttempt, error) {
+func (p *controlTower) SettleAttempt(ctx context.Context,
+	paymentHash lntypes.Hash, attemptID uint64,
+	settleInfo *paymentsdb.HTLCSettleInfo) (*paymentsdb.HTLCAttempt,
+	error) {
 
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.SettleAttempt(paymentHash, attemptID, settleInfo)
+	payment, err := p.db.SettleAttempt(
+		ctx, paymentHash, attemptID, settleInfo,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -231,14 +242,14 @@ func (p *controlTower) SettleAttempt(paymentHash lntypes.Hash,
 }
 
 // FailAttempt marks the given payment attempt failed.
-func (p *controlTower) FailAttempt(paymentHash lntypes.Hash,
-	attemptID uint64, failInfo *paymentsdb.HTLCFailInfo) (
-	*paymentsdb.HTLCAttempt, error) {
+func (p *controlTower) FailAttempt(ctx context.Context,
+	paymentHash lntypes.Hash, attemptID uint64,
+	failInfo *paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt, error) {
 
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.FailAttempt(paymentHash, attemptID, failInfo)
+	payment, err := p.db.FailAttempt(ctx, paymentHash, attemptID, failInfo)
 	if err != nil {
 		return nil, err
 	}
@@ -250,10 +261,11 @@ func (p *controlTower) FailAttempt(paymentHash lntypes.Hash,
 }
 
 // FetchPayment fetches the payment corresponding to the given payment hash.
-func (p *controlTower) FetchPayment(paymentHash lntypes.Hash) (
+func (p *controlTower) FetchPayment(ctx context.Context,
+	paymentHash lntypes.Hash) (
 	paymentsdb.DBMPPayment, error) {
 
-	return p.db.FetchPayment(paymentHash)
+	return p.db.FetchPayment(ctx, paymentHash)
 }
 
 // FailPayment transitions a payment into the Failed state, and records the
@@ -263,13 +275,13 @@ func (p *controlTower) FetchPayment(paymentHash lntypes.Hash) (
 //
 // NOTE: This method will overwrite the failure reason if the payment is already
 // failed.
-func (p *controlTower) FailPayment(paymentHash lntypes.Hash,
-	reason paymentsdb.FailureReason) error {
+func (p *controlTower) FailPayment(ctx context.Context,
+	paymentHash lntypes.Hash, reason paymentsdb.FailureReason) error {
 
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.Fail(paymentHash, reason)
+	payment, err := p.db.Fail(ctx, paymentHash, reason)
 	if err != nil {
 		return err
 	}
@@ -281,10 +293,10 @@ func (p *controlTower) FailPayment(paymentHash lntypes.Hash,
 }
 
 // FetchInFlightPayments returns all payments with status InFlight.
-func (p *controlTower) FetchInFlightPayments() ([]*paymentsdb.MPPayment,
-	error) {
+func (p *controlTower) FetchInFlightPayments(
+	ctx context.Context) ([]*paymentsdb.MPPayment, error) {
 
-	return p.db.FetchInFlightPayments()
+	return p.db.FetchInFlightPayments(ctx)
 }
 
 // SubscribePayment subscribes to updates for the payment with the given hash. A
@@ -293,12 +305,14 @@ func (p *controlTower) FetchInFlightPayments() ([]*paymentsdb.MPPayment,
 func (p *controlTower) SubscribePayment(paymentHash lntypes.Hash) (
 	ControlTowerSubscriber, error) {
 
+	ctx := context.TODO()
+
 	// Take lock before querying the db to prevent missing or duplicating an
 	// update.
 	p.paymentsMtx.Lock(paymentHash)
 	defer p.paymentsMtx.Unlock(paymentHash)
 
-	payment, err := p.db.FetchPayment(paymentHash)
+	payment, err := p.db.FetchPayment(ctx, paymentHash)
 	if err != nil {
 		return nil, err
 	}
@@ -335,6 +349,8 @@ func (p *controlTower) SubscribePayment(paymentHash lntypes.Hash) (
 func (p *controlTower) SubscribeAllPayments() (ControlTowerSubscriber, error) {
 	subscriber := newControlTowerSubscriber()
 
+	ctx := context.TODO()
+
 	// Add the subscriber to the list before fetching in-flight payments, so
 	// no events are missed. If a payment attempt update occurs after
 	// appending and before fetching in-flight payments, an out-of-order
@@ -346,7 +362,7 @@ func (p *controlTower) SubscribeAllPayments() (ControlTowerSubscriber, error) {
 	p.subscribersMtx.Unlock()
 
 	log.Debugf("Scanning for inflight payments")
-	inflightPayments, err := p.db.FetchInFlightPayments()
+	inflightPayments, err := p.db.FetchInFlightPayments(ctx)
 	if err != nil {
 		return nil, err
 	}
diff --git a/routing/control_tower_test.go b/routing/control_tower_test.go
index de0aacf880b..c9e8f485733 100644
--- a/routing/control_tower_test.go
+++ b/routing/control_tower_test.go
@@ -81,7 +81,7 @@ func TestControlTowerSubscribeSuccess(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = pControl.InitPayment(info.PaymentIdentifier, info)
+	err = pControl.InitPayment(t.Context(), info.PaymentIdentifier, info)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -92,7 +92,9 @@ func TestControlTowerSubscribeSuccess(t *testing.T) {
 	require.NoError(t, err, "expected subscribe to succeed, but got")
 
 	// Register an attempt.
-	err = pControl.RegisterAttempt(info.PaymentIdentifier, attempt)
+	err = pControl.RegisterAttempt(
+		t.Context(), info.PaymentIdentifier, attempt,
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -106,7 +108,8 @@ func TestControlTowerSubscribeSuccess(t *testing.T) {
 		Preimage: preimg,
 	}
 	htlcAttempt, err := pControl.SettleAttempt(
-		info.PaymentIdentifier, attempt.AttemptID, &settleInfo,
+		t.Context(), info.PaymentIdentifier, attempt.AttemptID,
+		&settleInfo,
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -212,7 +215,7 @@ func TestKVStoreSubscribeAllSuccess(t *testing.T) {
 	info1, attempt1, preimg1, err := genInfo()
 	require.NoError(t, err)
 
-	err = pControl.InitPayment(info1.PaymentIdentifier, info1)
+	err = pControl.InitPayment(t.Context(), info1.PaymentIdentifier, info1)
 	require.NoError(t, err)
 
 	// Subscription should succeed and immediately report the Initiated
@@ -221,18 +224,22 @@ func TestKVStoreSubscribeAllSuccess(t *testing.T) {
 	require.NoError(t, err, "expected subscribe to succeed, but got: %v")
 
 	// Register an attempt.
-	err = pControl.RegisterAttempt(info1.PaymentIdentifier, attempt1)
+	err = pControl.RegisterAttempt(
+		t.Context(), info1.PaymentIdentifier, attempt1,
+	)
 	require.NoError(t, err)
 
 	// Initiate a second payment after the subscription is already active.
 	info2, attempt2, preimg2, err := genInfo()
 	require.NoError(t, err)
 
-	err = pControl.InitPayment(info2.PaymentIdentifier, info2)
+	err = pControl.InitPayment(t.Context(), info2.PaymentIdentifier, info2)
 	require.NoError(t, err)
 
 	// Register an attempt on the second payment.
-	err = pControl.RegisterAttempt(info2.PaymentIdentifier, attempt2)
+	err = pControl.RegisterAttempt(
+		t.Context(), info2.PaymentIdentifier, attempt2,
+	)
 	require.NoError(t, err)
 
 	// Mark the first payment as successful.
@@ -240,7 +247,8 @@ func TestKVStoreSubscribeAllSuccess(t *testing.T) {
 		Preimage: preimg1,
 	}
 	htlcAttempt1, err := pControl.SettleAttempt(
-		info1.PaymentIdentifier, attempt1.AttemptID, &settleInfo1,
+		t.Context(), info1.PaymentIdentifier, attempt1.AttemptID,
+		&settleInfo1,
 	)
 	require.NoError(t, err)
 	require.Equal(
@@ -253,7 +261,8 @@ func TestKVStoreSubscribeAllSuccess(t *testing.T) {
 		Preimage: preimg2,
 	}
 	htlcAttempt2, err := pControl.SettleAttempt(
-		info2.PaymentIdentifier, attempt2.AttemptID, &settleInfo2,
+		t.Context(), info2.PaymentIdentifier, attempt2.AttemptID,
+		&settleInfo2,
 	)
 	require.NoError(t, err)
 	require.Equal(
@@ -337,11 +346,13 @@ func TestKVStoreSubscribeAllImmediate(t *testing.T) {
 	info, attempt, _, err := genInfo()
 	require.NoError(t, err)
 
-	err = pControl.InitPayment(info.PaymentIdentifier, info)
+	err = pControl.InitPayment(t.Context(), info.PaymentIdentifier, info)
 	require.NoError(t, err)
 
 	// Register a payment update.
-	err = pControl.RegisterAttempt(info.PaymentIdentifier, attempt)
+	err = pControl.RegisterAttempt(
+		t.Context(), info.PaymentIdentifier, attempt,
+	)
 	require.NoError(t, err)
 
 	subscription, err := pControl.SubscribeAllPayments()
@@ -392,7 +403,7 @@ func TestKVStoreUnsubscribeSuccess(t *testing.T) {
 	info, attempt, _, err := genInfo()
 	require.NoError(t, err)
 
-	err = pControl.InitPayment(info.PaymentIdentifier, info)
+	err = pControl.InitPayment(t.Context(), info.PaymentIdentifier, info)
 	require.NoError(t, err)
 
 	// Assert all subscriptions receive the update.
@@ -414,7 +425,9 @@ func TestKVStoreUnsubscribeSuccess(t *testing.T) {
 	subscription1.Close()
 
 	// Register a payment update.
-	err = pControl.RegisterAttempt(info.PaymentIdentifier, attempt)
+	err = pControl.RegisterAttempt(
+		t.Context(), info.PaymentIdentifier, attempt,
+	)
 	require.NoError(t, err)
 
 	// Assert only subscription 2 receives the update.
@@ -435,7 +448,8 @@ func TestKVStoreUnsubscribeSuccess(t *testing.T) {
 		Reason: paymentsdb.HTLCFailInternal,
 	}
 	_, err = pControl.FailAttempt(
-		info.PaymentIdentifier, attempt.AttemptID, &failInfo,
+		t.Context(), info.PaymentIdentifier, attempt.AttemptID,
+		&failInfo,
 	)
 	require.NoError(t, err, "unable to fail htlc")
 
@@ -465,7 +479,7 @@ func testKVStoreSubscribeFail(t *testing.T, registerAttempt,
 		t.Fatal(err)
 	}
 
-	err = pControl.InitPayment(info.PaymentIdentifier, info)
+	err = pControl.InitPayment(t.Context(), info.PaymentIdentifier, info)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -479,17 +493,18 @@ func testKVStoreSubscribeFail(t *testing.T, registerAttempt,
 	// making any attempts at all.
 	if registerAttempt {
 		// Register an attempt.
-		err = pControl.RegisterAttempt(info.PaymentIdentifier, attempt)
-		if err != nil {
-			t.Fatal(err)
-		}
+		err = pControl.RegisterAttempt(
+			t.Context(), info.PaymentIdentifier, attempt,
+		)
+		require.NoError(t, err)
 
 		// Fail the payment attempt.
 		failInfo := paymentsdb.HTLCFailInfo{
 			Reason: paymentsdb.HTLCFailInternal,
 		}
 		htlcAttempt, err := pControl.FailAttempt(
-			info.PaymentIdentifier, attempt.AttemptID, &failInfo,
+			t.Context(), info.PaymentIdentifier, attempt.AttemptID,
+			&failInfo,
 		)
 		if err != nil {
 			t.Fatalf("unable to fail htlc: %v", err)
@@ -501,7 +516,8 @@ func testKVStoreSubscribeFail(t *testing.T, registerAttempt,
 
 	// Mark the payment as failed.
 	err = pControl.FailPayment(
-		info.PaymentIdentifier, paymentsdb.FailureReasonTimeout,
+		t.Context(), info.PaymentIdentifier,
+		paymentsdb.FailureReasonTimeout,
 	)
 	if err != nil {
 		t.Fatal(err)
diff --git a/routing/mock_test.go b/routing/mock_test.go
index 19a76ee9010..472f1261623 100644
--- a/routing/mock_test.go
+++ b/routing/mock_test.go
@@ -1,6 +1,7 @@
 package routing
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"sync"
@@ -296,8 +297,8 @@ func makeMockControlTower() *mockControlTowerOld {
 	}
 }
 
-func (m *mockControlTowerOld) InitPayment(phash lntypes.Hash,
-	c *paymentsdb.PaymentCreationInfo) error {
+func (m *mockControlTowerOld) InitPayment(_ context.Context,
+	phash lntypes.Hash, c *paymentsdb.PaymentCreationInfo) error {
 
 	if m.init != nil {
 		m.init <- initArgs{c}
@@ -327,7 +328,9 @@ func (m *mockControlTowerOld) InitPayment(phash lntypes.Hash,
 	return nil
 }
 
-func (m *mockControlTowerOld) DeleteFailedAttempts(phash lntypes.Hash) error {
+func (m *mockControlTowerOld) DeleteFailedAttempts(_ context.Context,
+	phash lntypes.Hash) error {
+
 	p, ok := m.payments[phash]
 	if !ok {
 		return paymentsdb.ErrPaymentNotInitiated
@@ -353,8 +356,8 @@ func (m *mockControlTowerOld) DeleteFailedAttempts(phash lntypes.Hash) error {
 	return nil
 }
 
-func (m *mockControlTowerOld) RegisterAttempt(phash lntypes.Hash,
-	a *paymentsdb.HTLCAttemptInfo) error {
+func (m *mockControlTowerOld) RegisterAttempt(_ context.Context,
+	phash lntypes.Hash, a *paymentsdb.HTLCAttemptInfo) error {
 
 	if m.registerAttempt != nil {
 		m.registerAttempt <- registerAttemptArgs{a}
@@ -407,8 +410,8 @@ func (m *mockControlTowerOld) RegisterAttempt(phash lntypes.Hash,
 	return nil
 }
 
-func (m *mockControlTowerOld) SettleAttempt(phash lntypes.Hash,
-	pid uint64, settleInfo *paymentsdb.HTLCSettleInfo) (
+func (m *mockControlTowerOld) SettleAttempt(_ context.Context,
+	phash lntypes.Hash, pid uint64, settleInfo *paymentsdb.HTLCSettleInfo) (
 	*paymentsdb.HTLCAttempt, error) {
 
 	if m.settleAttempt != nil {
@@ -450,8 +453,9 @@ func (m *mockControlTowerOld) SettleAttempt(phash lntypes.Hash,
 	return nil, fmt.Errorf("pid not found")
 }
 
-func (m *mockControlTowerOld) FailAttempt(phash lntypes.Hash, pid uint64,
-	failInfo *paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt, error) {
+func (m *mockControlTowerOld) FailAttempt(_ context.Context, phash lntypes.Hash,
+	pid uint64, failInfo *paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt,
+	error) {
 
 	if m.failAttempt != nil {
 		m.failAttempt <- failAttemptArgs{failInfo}
@@ -489,7 +493,7 @@ func (m *mockControlTowerOld) FailAttempt(phash lntypes.Hash, pid uint64,
 	return nil, fmt.Errorf("pid not found")
 }
 
-func (m *mockControlTowerOld) FailPayment(phash lntypes.Hash,
+func (m *mockControlTowerOld) FailPayment(_ context.Context, phash lntypes.Hash,
 	reason paymentsdb.FailureReason) error {
 
 	m.Lock()
@@ -509,8 +513,8 @@ func (m *mockControlTowerOld) FailPayment(phash lntypes.Hash,
 	return nil
 }
 
-func (m *mockControlTowerOld) FetchPayment(phash lntypes.Hash) (
-	paymentsdb.DBMPPayment, error) {
+func (m *mockControlTowerOld) FetchPayment(_ context.Context,
+	phash lntypes.Hash) (paymentsdb.DBMPPayment, error) {
 
 	m.Lock()
 	defer m.Unlock()
@@ -545,7 +549,7 @@ func (m *mockControlTowerOld) fetchPayment(phash lntypes.Hash) (
 	return mp, nil
 }
 
-func (m *mockControlTowerOld) FetchInFlightPayments() (
+func (m *mockControlTowerOld) FetchInFlightPayments(_ context.Context) (
 	[]*paymentsdb.MPPayment, error) {
 
 	if m.fetchInFlight != nil {
@@ -733,26 +737,28 @@ type mockControlTower struct {
 
 var _ ControlTower = (*mockControlTower)(nil)
 
-func (m *mockControlTower) InitPayment(phash lntypes.Hash,
+func (m *mockControlTower) InitPayment(_ context.Context, phash lntypes.Hash,
 	c *paymentsdb.PaymentCreationInfo) error {
 
 	args := m.Called(phash, c)
 	return args.Error(0)
 }
 
-func (m *mockControlTower) DeleteFailedAttempts(phash lntypes.Hash) error {
+func (m *mockControlTower) DeleteFailedAttempts(_ context.Context,
+	phash lntypes.Hash) error {
+
 	args := m.Called(phash)
 	return args.Error(0)
 }
 
-func (m *mockControlTower) RegisterAttempt(phash lntypes.Hash,
-	a *paymentsdb.HTLCAttemptInfo) error {
+func (m *mockControlTower) RegisterAttempt(_ context.Context,
+	phash lntypes.Hash, a *paymentsdb.HTLCAttemptInfo) error {
 
 	args := m.Called(phash, a)
 	return args.Error(0)
 }
 
-func (m *mockControlTower) SettleAttempt(phash lntypes.Hash,
+func (m *mockControlTower) SettleAttempt(_ context.Context, phash lntypes.Hash,
 	pid uint64, settleInfo *paymentsdb.HTLCSettleInfo) (
 	*paymentsdb.HTLCAttempt, error) {
 
@@ -766,8 +772,9 @@ func (m *mockControlTower) SettleAttempt(phash lntypes.Hash,
 	return attempt.(*paymentsdb.HTLCAttempt), args.Error(1)
 }
 
-func (m *mockControlTower) FailAttempt(phash lntypes.Hash, pid uint64,
-	failInfo *paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt, error) {
+func (m *mockControlTower) FailAttempt(_ context.Context, phash lntypes.Hash,
+	pid uint64, failInfo *paymentsdb.HTLCFailInfo) (*paymentsdb.HTLCAttempt,
+	error) {
 
 	args := m.Called(phash, pid, failInfo)
 
@@ -779,15 +786,15 @@ func (m *mockControlTower) FailAttempt(phash lntypes.Hash, pid uint64,
 	return attempt.(*paymentsdb.HTLCAttempt), args.Error(1)
 }
 
-func (m *mockControlTower) FailPayment(phash lntypes.Hash,
+func (m *mockControlTower) FailPayment(_ context.Context, phash lntypes.Hash,
 	reason paymentsdb.FailureReason) error {
 
 	args := m.Called(phash, reason)
 	return args.Error(0)
 }
 
-func (m *mockControlTower) FetchPayment(phash lntypes.Hash) (
-	paymentsdb.DBMPPayment, error) {
+func (m *mockControlTower) FetchPayment(_ context.Context,
+	phash lntypes.Hash) (paymentsdb.DBMPPayment, error) {
 
 	args := m.Called(phash)
 
@@ -800,7 +807,7 @@ func (m *mockControlTower) FetchPayment(phash lntypes.Hash) (
 	return payment, args.Error(1)
 }
 
-func (m *mockControlTower) FetchInFlightPayments() (
+func (m *mockControlTower) FetchInFlightPayments(_ context.Context) (
 	[]*paymentsdb.MPPayment, error) {
 
 	args := m.Called()
diff --git a/routing/payment_lifecycle.go b/routing/payment_lifecycle.go
index 8353cba157f..6405e850687 100644
--- a/routing/payment_lifecycle.go
+++ b/routing/payment_lifecycle.go
@@ -190,6 +190,10 @@ func (p *paymentLifecycle) decideNextStep(
 func (p *paymentLifecycle) resumePayment(ctx context.Context) ([32]byte,
 	*route.Route, error) {
 
+	// We need to make sure we can still do db operations after the context
+	// is cancelled.
+	cleanupCtx := context.WithoutCancel(ctx)
+
 	// When the payment lifecycle loop exits, we make sure to signal any
 	// sub goroutine of the HTLC attempt to exit, then wait for them to
 	// return.
@@ -328,7 +332,9 @@ lifecycle:
 	// Optionally delete the failed attempts from the database. Depends on
 	// the database options deleting attempts is not allowed so this will
 	// just be a no-op.
-	err = p.router.cfg.Control.DeleteFailedAttempts(p.identifier)
+	err = p.router.cfg.Control.DeleteFailedAttempts(
+		cleanupCtx, p.identifier,
+	)
 	if err != nil {
 		log.Errorf("Error deleting failed htlc attempts for payment "+
 			"%v: %v", p.identifier, err)
@@ -364,11 +370,18 @@ func (p *paymentLifecycle) checkContext(ctx context.Context) error {
 				p.identifier.String())
 		}
 
+		// The context is already cancelled at this point, so we create
+		// a new context so the payment can successfully be marked as
+		// failed.
+		cleanupCtx := context.WithoutCancel(ctx)
+
 		// By marking the payment failed, depending on whether it has
 		// inflight HTLCs or not, its status will now either be
 		// `StatusInflight` or `StatusFailed`. In either case, no more
 		// HTLCs will be attempted.
-		err := p.router.cfg.Control.FailPayment(p.identifier, reason)
+		err := p.router.cfg.Control.FailPayment(
+			cleanupCtx, p.identifier, reason,
+		)
 		if err != nil {
 			return fmt.Errorf("FailPayment got %w", err)
 		}
@@ -389,6 +402,8 @@ func (p *paymentLifecycle) checkContext(ctx context.Context) error {
 func (p *paymentLifecycle) requestRoute(
 	ps *paymentsdb.MPPaymentState) (*route.Route, error) {
 
+	ctx := context.TODO()
+
 	remainingFees := p.calcFeeBudget(ps.FeesPaid)
 
 	// Query our payment session to construct a route.
@@ -430,7 +445,9 @@ func (p *paymentLifecycle) requestRoute(
 	log.Warnf("Marking payment %v permanently failed with no route: %v",
 		p.identifier, failureCode)
 
-	err = p.router.cfg.Control.FailPayment(p.identifier, failureCode)
+	err = p.router.cfg.Control.FailPayment(
+		ctx, p.identifier, failureCode,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("FailPayment got: %w", err)
 	}
@@ -584,6 +601,8 @@ func (p *paymentLifecycle) collectResult(
 func (p *paymentLifecycle) registerAttempt(rt *route.Route,
 	remainingAmt lnwire.MilliSatoshi) (*paymentsdb.HTLCAttempt, error) {
 
+	ctx := context.TODO()
+
 	// If this route will consume the last remaining amount to send
 	// to the receiver, this will be our last shard (for now).
 	isLastAttempt := rt.ReceiverAmt() == remainingAmt
@@ -601,7 +620,7 @@ func (p *paymentLifecycle) registerAttempt(rt *route.Route,
 	// Switch for its whereabouts. The route is needed to handle the result
 	// when it eventually comes back.
 	err = p.router.cfg.Control.RegisterAttempt(
-		p.identifier, &attempt.HTLCAttemptInfo,
+		ctx, p.identifier, &attempt.HTLCAttemptInfo,
 	)
 
 	return attempt, err
@@ -798,6 +817,8 @@ func (p *paymentLifecycle) failPaymentAndAttempt(
 	attemptID uint64, reason *paymentsdb.FailureReason,
 	sendErr error) (*attemptResult, error) {
 
+	ctx := context.TODO()
+
 	log.Errorf("Payment %v failed: final_outcome=%v, raw_err=%v",
 		p.identifier, *reason, sendErr)
 
@@ -806,7 +827,9 @@ func (p *paymentLifecycle) failPaymentAndAttempt(
 	// NOTE: we must fail the payment first before failing the attempt.
 	// Otherwise, once the attempt is marked as failed, another goroutine
 	// might make another attempt while we are failing the payment.
-	err := p.router.cfg.Control.FailPayment(p.identifier, *reason)
+	err := p.router.cfg.Control.FailPayment(
+		ctx, p.identifier, *reason,
+	)
 	if err != nil {
 		log.Errorf("Unable to fail payment: %v", err)
 		return nil, err
@@ -1001,6 +1024,8 @@ func (p *paymentLifecycle) handleFailureMessage(rt *route.Route,
 func (p *paymentLifecycle) failAttempt(attemptID uint64,
 	sendError error) (*attemptResult, error) {
 
+	ctx := context.TODO()
+
 	log.Warnf("Attempt %v for payment %v failed: %v", attemptID,
 		p.identifier, sendError)
 
@@ -1017,7 +1042,7 @@ func (p *paymentLifecycle) failAttempt(attemptID uint64,
 	}
 
 	attempt, err := p.router.cfg.Control.FailAttempt(
-		p.identifier, attemptID, failInfo,
+		ctx, p.identifier, attemptID, failInfo,
 	)
 	if err != nil {
 		return nil, err
@@ -1114,7 +1139,9 @@ func (p *paymentLifecycle) patchLegacyPaymentHash(
 func (p *paymentLifecycle) reloadInflightAttempts() (paymentsdb.DBMPPayment,
 	error) {
 
-	payment, err := p.router.cfg.Control.FetchPayment(p.identifier)
+	ctx := context.TODO()
+
+	payment, err := p.router.cfg.Control.FetchPayment(ctx, p.identifier)
 	if err != nil {
 		return nil, err
 	}
@@ -1139,8 +1166,10 @@ func (p *paymentLifecycle) reloadInflightAttempts() (paymentsdb.DBMPPayment,
 func (p *paymentLifecycle) reloadPayment() (paymentsdb.DBMPPayment,
 	*paymentsdb.MPPaymentState, error) {
 
+	ctx := context.TODO()
+
 	// Read the db to get the latest state of the payment.
-	payment, err := p.router.cfg.Control.FetchPayment(p.identifier)
+	payment, err := p.router.cfg.Control.FetchPayment(ctx, p.identifier)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -1160,6 +1189,8 @@ func (p *paymentLifecycle) reloadPayment() (paymentsdb.DBMPPayment,
 func (p *paymentLifecycle) handleAttemptResult(attempt *paymentsdb.HTLCAttempt,
 	result *htlcswitch.PaymentResult) (*attemptResult, error) {
 
+	ctx := context.TODO()
+
 	// If the result has an error, we need to further process it by failing
 	// the attempt and maybe fail the payment.
 	if result.Error != nil {
@@ -1181,7 +1212,7 @@ func (p *paymentLifecycle) handleAttemptResult(attempt *paymentsdb.HTLCAttempt,
 	// In case of success we atomically store settle result to the DB and
 	// move the shard to the settled state.
 	htlcAttempt, err := p.router.cfg.Control.SettleAttempt(
-		p.identifier, attempt.AttemptID,
+		ctx, p.identifier, attempt.AttemptID,
 		&paymentsdb.HTLCSettleInfo{
 			Preimage:   result.Preimage,
 			SettleTime: p.router.cfg.Clock.Now(),
diff --git a/routing/router.go b/routing/router.go
index 3c35b7c52cc..acd572e6380 100644
--- a/routing/router.go
+++ b/routing/router.go
@@ -967,6 +967,8 @@ func spewPayment(payment *LightningPayment) lnutils.LogClosure {
 func (r *ChannelRouter) PreparePayment(payment *LightningPayment) (
 	PaymentSession, shards.ShardTracker, error) {
 
+	ctx := context.TODO()
+
 	// Assemble any custom data we want to send to the first hop only.
 	var firstHopData fn.Option[tlv.Blob]
 	if len(payment.FirstHopCustomRecords) > 0 {
@@ -1026,7 +1028,7 @@ func (r *ChannelRouter) PreparePayment(payment *LightningPayment) (
 		)
 	}
 
-	err = r.cfg.Control.InitPayment(payment.Identifier(), info)
+	err = r.cfg.Control.InitPayment(ctx, payment.Identifier(), info)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -1064,13 +1066,15 @@ func (r *ChannelRouter) sendToRoute(htlcHash lntypes.Hash, rt *route.Route,
 	firstHopCustomRecords lnwire.CustomRecords) (*paymentsdb.HTLCAttempt,
 	error) {
 
+	ctx := context.TODO()
+
 	// Helper function to fail a payment. It makes sure the payment is only
 	// failed once so that the failure reason is not overwritten.
 	failPayment := func(paymentIdentifier lntypes.Hash,
 		reason paymentsdb.FailureReason) error {
 
 		payment, fetchErr := r.cfg.Control.FetchPayment(
-			paymentIdentifier,
+			ctx, paymentIdentifier,
 		)
 		if fetchErr != nil {
 			return fetchErr
@@ -1084,7 +1088,9 @@ func (r *ChannelRouter) sendToRoute(htlcHash lntypes.Hash, rt *route.Route,
 			return nil
 		}
 
-		return r.cfg.Control.FailPayment(paymentIdentifier, reason)
+		return r.cfg.Control.FailPayment(
+			ctx, paymentIdentifier, reason,
+		)
 	}
 
 	log.Debugf("SendToRoute for payment %v with skipTempErr=%v",
@@ -1129,7 +1135,7 @@ func (r *ChannelRouter) sendToRoute(htlcHash lntypes.Hash, rt *route.Route,
 		FirstHopCustomRecords: firstHopCustomRecords,
 	}
 
-	err := r.cfg.Control.InitPayment(paymentIdentifier, info)
+	err := r.cfg.Control.InitPayment(ctx, paymentIdentifier, info)
 	switch {
 	// If this is an MPP attempt and the hash is already registered with
 	// the database, we can go on to launch the shard.
@@ -1415,9 +1421,11 @@ func (r *ChannelRouter) BuildRoute(amt fn.Option[lnwire.MilliSatoshi],
 // resumePayments fetches inflight payments and resumes their payment
 // lifecycles.
 func (r *ChannelRouter) resumePayments() error {
+	ctx := context.TODO()
+
 	// Get all payments that are inflight.
 	log.Debugf("Scanning for inflight payments")
-	payments, err := r.cfg.Control.FetchInFlightPayments()
+	payments, err := r.cfg.Control.FetchInFlightPayments(ctx)
 	if err != nil {
 		return err
 	}
@@ -1525,6 +1533,8 @@ func (r *ChannelRouter) resumePayments() error {
 func (r *ChannelRouter) failStaleAttempt(a paymentsdb.HTLCAttempt,
 	payHash lntypes.Hash) {
 
+	ctx := context.TODO()
+
 	// We can only fail inflight HTLCs so we skip the settled/failed ones.
 	if a.Failure != nil || a.Settle != nil {
 		return
@@ -1608,7 +1618,7 @@ func (r *ChannelRouter) failStaleAttempt(a paymentsdb.HTLCAttempt,
 		Reason:   paymentsdb.HTLCFailUnknown,
 		FailTime: r.cfg.Clock.Now(),
 	}
-	_, err = r.cfg.Control.FailAttempt(payHash, a.AttemptID, failInfo)
+	_, err = r.cfg.Control.FailAttempt(ctx, payHash, a.AttemptID, failInfo)
 	if err != nil {
 		log.Errorf("Fail attempt=%v got error: %v", a.AttemptID, err)
 	}
diff --git a/routing/router_test.go b/routing/router_test.go
index 9f088917daf..a20b1b75dd2 100644
--- a/routing/router_test.go
+++ b/routing/router_test.go
@@ -1093,7 +1093,9 @@ func TestSendPaymentErrorPathPruning(t *testing.T) {
 	require.Equal(t, paymentsdb.FailureReasonNoRoute, err)
 
 	// Inspect the two attempts that were made before the payment failed.
-	p, err := ctx.router.cfg.Control.FetchPayment(*payment.paymentHash)
+	p, err := ctx.router.cfg.Control.FetchPayment(
+		t.Context(), *payment.paymentHash,
+	)
 	require.NoError(t, err)
 
 	htlcs := p.GetHTLCs()
diff --git a/rpcserver.go b/rpcserver.go
index ee810d1e1ef..e75e0dcd15a 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -7678,7 +7678,7 @@ func (r *rpcServer) DeletePayment(ctx context.Context,
 	rpcsLog.Infof("[DeletePayment] payment_identifier=%v, "+
 		"failed_htlcs_only=%v", hash, req.FailedHtlcsOnly)
 
-	err = r.server.paymentsDB.DeletePayment(hash, req.FailedHtlcsOnly)
+	err = r.server.paymentsDB.DeletePayment(ctx, hash, req.FailedHtlcsOnly)
 	if err != nil {
 		return nil, err
 	}
@@ -7719,7 +7719,7 @@ func (r *rpcServer) DeleteAllPayments(ctx context.Context,
 		req.FailedHtlcsOnly)
 
 	numDeletedPayments, err := r.server.paymentsDB.DeletePayments(
-		req.FailedPaymentsOnly, req.FailedHtlcsOnly,
+		ctx, req.FailedPaymentsOnly, req.FailedHtlcsOnly,
 	)
 	if err != nil {
 		return nil, err