diff --git a/sqldb/sqlc/amp_invoices.sql.go b/sqldb/sqlc/amp_invoices.sql.go
index 46c368630..3fcfe4b27 100644
--- a/sqldb/sqlc/amp_invoices.sql.go
+++ b/sqldb/sqlc/amp_invoices.sql.go
@@ -11,67 +11,69 @@ import (
 	"time"
 )
 
-const deleteAMPHTLCCustomRecords = `-- name: DeleteAMPHTLCCustomRecords :exec
-WITH htlc_ids AS (
-    SELECT htlc_id
-    FROM amp_invoice_htlcs 
-    WHERE invoice_id = $1
+const fetchAMPSubInvoiceHTLCs = `-- name: FetchAMPSubInvoiceHTLCs :many
+SELECT 
+    amp.set_id, amp.root_share, amp.child_index, amp.hash, amp.preimage, 
+    invoice_htlcs.id, invoice_htlcs.chan_id, invoice_htlcs.htlc_id, invoice_htlcs.amount_msat, invoice_htlcs.total_mpp_msat, invoice_htlcs.accept_height, invoice_htlcs.accept_time, invoice_htlcs.expiry_height, invoice_htlcs.state, invoice_htlcs.resolve_time, invoice_htlcs.invoice_id
+FROM amp_sub_invoice_htlcs amp
+INNER JOIN invoice_htlcs ON amp.htlc_id = invoice_htlcs.id
+WHERE amp.invoice_id = $1
+AND (
+    set_id = $2 OR 
+    $2 IS NULL
 )
-DELETE
-FROM invoice_htlc_custom_records
-WHERE htlc_id IN (SELECT id FROM htlc_ids)
 `
 
-func (q *Queries) DeleteAMPHTLCCustomRecords(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteAMPHTLCCustomRecords, invoiceID)
-	return err
+type FetchAMPSubInvoiceHTLCsParams struct {
+	InvoiceID int64
+	SetID     []byte
 }
 
-const deleteAMPHTLCs = `-- name: DeleteAMPHTLCs :exec
-DELETE 
-FROM amp_invoice_htlcs  
-WHERE invoice_id = $1
-`
-
-func (q *Queries) DeleteAMPHTLCs(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteAMPHTLCs, invoiceID)
-	return err
+type FetchAMPSubInvoiceHTLCsRow struct {
+	SetID        []byte
+	RootShare    []byte
+	ChildIndex   int64
+	Hash         []byte
+	Preimage     []byte
+	ID           int64
+	ChanID       string
+	HtlcID       int64
+	AmountMsat   int64
+	TotalMppMsat sql.NullInt64
+	AcceptHeight int32
+	AcceptTime   time.Time
+	ExpiryHeight int32
+	State        int16
+	ResolveTime  sql.NullTime
+	InvoiceID    int64
 }
 
-const deleteAMPInvoiceHTLC = `-- name: DeleteAMPInvoiceHTLC :exec
-DELETE 
-FROM amp_invoice_htlcs
-WHERE set_id = $1
-`
-
-func (q *Queries) DeleteAMPInvoiceHTLC(ctx context.Context, setID []byte) error {
-	_, err := q.db.ExecContext(ctx, deleteAMPInvoiceHTLC, setID)
-	return err
-}
-
-const getAMPInvoiceHTLCsByInvoiceID = `-- name: GetAMPInvoiceHTLCsByInvoiceID :many
-SELECT set_id, htlc_id, invoice_id, root_share, child_index, hash, preimage
-FROM amp_invoice_htlcs
-WHERE invoice_id = $1
-`
-
-func (q *Queries) GetAMPInvoiceHTLCsByInvoiceID(ctx context.Context, invoiceID int32) ([]AmpInvoiceHtlc, error) {
-	rows, err := q.db.QueryContext(ctx, getAMPInvoiceHTLCsByInvoiceID, invoiceID)
+func (q *Queries) FetchAMPSubInvoiceHTLCs(ctx context.Context, arg FetchAMPSubInvoiceHTLCsParams) ([]FetchAMPSubInvoiceHTLCsRow, error) {
+	rows, err := q.db.QueryContext(ctx, fetchAMPSubInvoiceHTLCs, arg.InvoiceID, arg.SetID)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []AmpInvoiceHtlc
+	var items []FetchAMPSubInvoiceHTLCsRow
 	for rows.Next() {
-		var i AmpInvoiceHtlc
+		var i FetchAMPSubInvoiceHTLCsRow
 		if err := rows.Scan(
 			&i.SetID,
-			&i.HtlcID,
-			&i.InvoiceID,
 			&i.RootShare,
 			&i.ChildIndex,
 			&i.Hash,
 			&i.Preimage,
+			&i.ID,
+			&i.ChanID,
+			&i.HtlcID,
+			&i.AmountMsat,
+			&i.TotalMppMsat,
+			&i.AcceptHeight,
+			&i.AcceptTime,
+			&i.ExpiryHeight,
+			&i.State,
+			&i.ResolveTime,
+			&i.InvoiceID,
 		); err != nil {
 			return nil, err
 		}
@@ -86,29 +88,37 @@ func (q *Queries) GetAMPInvoiceHTLCsByInvoiceID(ctx context.Context, invoiceID i
 	return items, nil
 }
 
-const getAMPInvoiceHTLCsBySetID = `-- name: GetAMPInvoiceHTLCsBySetID :many
-SELECT set_id, htlc_id, invoice_id, root_share, child_index, hash, preimage
-FROM amp_invoice_htlcs
-WHERE set_id = $1
+const fetchAMPSubInvoices = `-- name: FetchAMPSubInvoices :many
+SELECT set_id, state, created_at, settled_at, settle_index, invoice_id
+FROM amp_sub_invoices
+WHERE invoice_id = $1 
+AND (
+    set_id = $2 OR 
+    $2 IS NULL
+)
 `
 
-func (q *Queries) GetAMPInvoiceHTLCsBySetID(ctx context.Context, setID []byte) ([]AmpInvoiceHtlc, error) {
-	rows, err := q.db.QueryContext(ctx, getAMPInvoiceHTLCsBySetID, setID)
+type FetchAMPSubInvoicesParams struct {
+	InvoiceID int64
+	SetID     []byte
+}
+
+func (q *Queries) FetchAMPSubInvoices(ctx context.Context, arg FetchAMPSubInvoicesParams) ([]AmpSubInvoice, error) {
+	rows, err := q.db.QueryContext(ctx, fetchAMPSubInvoices, arg.InvoiceID, arg.SetID)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []AmpInvoiceHtlc
+	var items []AmpSubInvoice
 	for rows.Next() {
-		var i AmpInvoiceHtlc
+		var i AmpSubInvoice
 		if err := rows.Scan(
 			&i.SetID,
-			&i.HtlcID,
+			&i.State,
+			&i.CreatedAt,
+			&i.SettledAt,
+			&i.SettleIndex,
 			&i.InvoiceID,
-			&i.RootShare,
-			&i.ChildIndex,
-			&i.Hash,
-			&i.Preimage,
 		); err != nil {
 			return nil, err
 		}
@@ -123,28 +133,84 @@ func (q *Queries) GetAMPInvoiceHTLCsBySetID(ctx context.Context, setID []byte) (
 	return items, nil
 }
 
-const getSetIDHTLCsCustomRecords = `-- name: GetSetIDHTLCsCustomRecords :many
-SELECT ihcr.htlc_id, key, value
-FROM amp_invoice_htlcs aih JOIN invoice_htlc_custom_records ihcr ON aih.id=ihcr.htlc_id 
-WHERE aih.set_id = $1
+const fetchSettledAMPSubInvoices = `-- name: FetchSettledAMPSubInvoices :many
+SELECT 
+    a.set_id, 
+    a.settle_index as amp_settle_index, 
+    a.settled_at as amp_settled_at,
+    i.id, i.hash, i.preimage, i.settle_index, i.settled_at, i.memo, i.amount_msat, i.cltv_delta, i.expiry, i.payment_addr, i.payment_request, i.payment_request_hash, i.state, i.amount_paid_msat, i.is_amp, i.is_hodl, i.is_keysend, i.created_at
+FROM amp_sub_invoices a
+INNER JOIN invoices i ON a.invoice_id = i.id
+WHERE (
+    a.settle_index >= $1 OR
+    $1 IS NULL
+) AND (
+    a.settle_index <= $2 OR
+    $2 IS NULL
+)
 `
 
-type GetSetIDHTLCsCustomRecordsRow struct {
-	HtlcID int64
-	Key    int64
-	Value  []byte
+type FetchSettledAMPSubInvoicesParams struct {
+	SettleIndexGet sql.NullInt64
+	SettleIndexLet sql.NullInt64
 }
 
-func (q *Queries) GetSetIDHTLCsCustomRecords(ctx context.Context, setID []byte) ([]GetSetIDHTLCsCustomRecordsRow, error) {
-	rows, err := q.db.QueryContext(ctx, getSetIDHTLCsCustomRecords, setID)
+type FetchSettledAMPSubInvoicesRow struct {
+	SetID              []byte
+	AmpSettleIndex     sql.NullInt64
+	AmpSettledAt       sql.NullTime
+	ID                 int64
+	Hash               []byte
+	Preimage           []byte
+	SettleIndex        sql.NullInt64
+	SettledAt          sql.NullTime
+	Memo               sql.NullString
+	AmountMsat         int64
+	CltvDelta          sql.NullInt32
+	Expiry             int32
+	PaymentAddr        []byte
+	PaymentRequest     sql.NullString
+	PaymentRequestHash []byte
+	State              int16
+	AmountPaidMsat     int64
+	IsAmp              bool
+	IsHodl             bool
+	IsKeysend          bool
+	CreatedAt          time.Time
+}
+
+func (q *Queries) FetchSettledAMPSubInvoices(ctx context.Context, arg FetchSettledAMPSubInvoicesParams) ([]FetchSettledAMPSubInvoicesRow, error) {
+	rows, err := q.db.QueryContext(ctx, fetchSettledAMPSubInvoices, arg.SettleIndexGet, arg.SettleIndexLet)
 	if err != nil {
 		return nil, err
 	}
 	defer rows.Close()
-	var items []GetSetIDHTLCsCustomRecordsRow
+	var items []FetchSettledAMPSubInvoicesRow
 	for rows.Next() {
-		var i GetSetIDHTLCsCustomRecordsRow
-		if err := rows.Scan(&i.HtlcID, &i.Key, &i.Value); err != nil {
+		var i FetchSettledAMPSubInvoicesRow
+		if err := rows.Scan(
+			&i.SetID,
+			&i.AmpSettleIndex,
+			&i.AmpSettledAt,
+			&i.ID,
+			&i.Hash,
+			&i.Preimage,
+			&i.SettleIndex,
+			&i.SettledAt,
+			&i.Memo,
+			&i.AmountMsat,
+			&i.CltvDelta,
+			&i.Expiry,
+			&i.PaymentAddr,
+			&i.PaymentRequest,
+			&i.PaymentRequestHash,
+			&i.State,
+			&i.AmountPaidMsat,
+			&i.IsAmp,
+			&i.IsHodl,
+			&i.IsKeysend,
+			&i.CreatedAt,
+		); err != nil {
 			return nil, err
 		}
 		items = append(items, i)
@@ -158,15 +224,27 @@ func (q *Queries) GetSetIDHTLCsCustomRecords(ctx context.Context, setID []byte)
 	return items, nil
 }
 
-const insertAMPInvoiceHTLC = `-- name: InsertAMPInvoiceHTLC :exec
-INSERT INTO amp_invoice_htlcs (
-    set_id, htlc_id, root_share, child_index, hash, preimage
+const getAMPInvoiceID = `-- name: GetAMPInvoiceID :one
+SELECT invoice_id FROM amp_sub_invoices WHERE set_id = $1
+`
+
+func (q *Queries) GetAMPInvoiceID(ctx context.Context, setID []byte) (int64, error) {
+	row := q.db.QueryRowContext(ctx, getAMPInvoiceID, setID)
+	var invoice_id int64
+	err := row.Scan(&invoice_id)
+	return invoice_id, err
+}
+
+const insertAMPSubInvoiceHTLC = `-- name: InsertAMPSubInvoiceHTLC :exec
+INSERT INTO amp_sub_invoice_htlcs (
+    invoice_id, set_id, htlc_id, root_share, child_index, hash, preimage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6
+    $1, $2, $3, $4, $5, $6, $7
 )
 `
 
-type InsertAMPInvoiceHTLCParams struct {
+type InsertAMPSubInvoiceHTLCParams struct {
+	InvoiceID  int64
 	SetID      []byte
 	HtlcID     int64
 	RootShare  []byte
@@ -175,8 +253,9 @@ type InsertAMPInvoiceHTLCParams struct {
 	Preimage   []byte
 }
 
-func (q *Queries) InsertAMPInvoiceHTLC(ctx context.Context, arg InsertAMPInvoiceHTLCParams) error {
-	_, err := q.db.ExecContext(ctx, insertAMPInvoiceHTLC,
+func (q *Queries) InsertAMPSubInvoiceHTLC(ctx context.Context, arg InsertAMPSubInvoiceHTLCParams) error {
+	_, err := q.db.ExecContext(ctx, insertAMPSubInvoiceHTLC,
+		arg.InvoiceID,
 		arg.SetID,
 		arg.HtlcID,
 		arg.RootShare,
@@ -187,140 +266,75 @@ func (q *Queries) InsertAMPInvoiceHTLC(ctx context.Context, arg InsertAMPInvoice
 	return err
 }
 
-const insertAMPInvoicePayment = `-- name: InsertAMPInvoicePayment :exec
-INSERT INTO amp_invoice_payments (
-    set_id, state, created_at, settled_index, invoice_id
-) VALUES (
-    $1, $2, $3, $4, $5
+const updateAMPSubInvoiceHTLCPreimage = `-- name: UpdateAMPSubInvoiceHTLCPreimage :execresult
+UPDATE amp_sub_invoice_htlcs AS a
+SET preimage = $4
+WHERE a.invoice_id = $1 AND a.set_id = $2 AND a.htlc_id = (
+    SELECT id FROM invoice_htlcs AS i WHERE i.htlc_id = $3
 )
 `
 
-type InsertAMPInvoicePaymentParams struct {
-	SetID        []byte
-	State        int16
-	CreatedAt    time.Time
-	SettledIndex sql.NullInt32
-	InvoiceID    int32
+type UpdateAMPSubInvoiceHTLCPreimageParams struct {
+	InvoiceID int64
+	SetID     []byte
+	HtlcID    int64
+	Preimage  []byte
 }
 
-func (q *Queries) InsertAMPInvoicePayment(ctx context.Context, arg InsertAMPInvoicePaymentParams) error {
-	_, err := q.db.ExecContext(ctx, insertAMPInvoicePayment,
+func (q *Queries) UpdateAMPSubInvoiceHTLCPreimage(ctx context.Context, arg UpdateAMPSubInvoiceHTLCPreimageParams) (sql.Result, error) {
+	return q.db.ExecContext(ctx, updateAMPSubInvoiceHTLCPreimage,
+		arg.InvoiceID,
+		arg.SetID,
+		arg.HtlcID,
+		arg.Preimage,
+	)
+}
+
+const updateAMPSubInvoiceState = `-- name: UpdateAMPSubInvoiceState :exec
+UPDATE amp_sub_invoices
+SET state = $2, 
+    settle_index = COALESCE(settle_index, $3),
+    settled_at = COALESCE(settled_at, $4)
+WHERE set_id = $1
+`
+
+type UpdateAMPSubInvoiceStateParams struct {
+	SetID       []byte
+	State       int16
+	SettleIndex sql.NullInt64
+	SettledAt   sql.NullTime
+}
+
+func (q *Queries) UpdateAMPSubInvoiceState(ctx context.Context, arg UpdateAMPSubInvoiceStateParams) error {
+	_, err := q.db.ExecContext(ctx, updateAMPSubInvoiceState,
+		arg.SetID,
+		arg.State,
+		arg.SettleIndex,
+		arg.SettledAt,
+	)
+	return err
+}
+
+const upsertAMPSubInvoice = `-- name: UpsertAMPSubInvoice :execresult
+INSERT INTO amp_sub_invoices (
+    set_id, state, created_at, invoice_id
+) VALUES (
+    $1, $2, $3, $4
+) ON CONFLICT (set_id, invoice_id) DO NOTHING
+`
+
+type UpsertAMPSubInvoiceParams struct {
+	SetID     []byte
+	State     int16
+	CreatedAt time.Time
+	InvoiceID int64
+}
+
+func (q *Queries) UpsertAMPSubInvoice(ctx context.Context, arg UpsertAMPSubInvoiceParams) (sql.Result, error) {
+	return q.db.ExecContext(ctx, upsertAMPSubInvoice,
 		arg.SetID,
 		arg.State,
 		arg.CreatedAt,
-		arg.SettledIndex,
 		arg.InvoiceID,
 	)
-	return err
-}
-
-const selectAMPInvoicePayments = `-- name: SelectAMPInvoicePayments :many
-SELECT aip.set_id, aip.state, aip.created_at, aip.settled_index, aip.invoice_id, ip.id, ip.settled_at, ip.amount_paid_msat, ip.invoice_id
-FROM amp_invoice_payments aip LEFT JOIN invoice_payments ip ON aip.settled_index = ip.id
-WHERE (
-    set_id = $1 OR 
-    $1 IS NULL
-) AND (
-    aip.settled_index = $2 OR 
-    $2 IS NULL
-) AND (
-    aip.invoice_id = $3 OR 
-    $3 IS NULL
-)
-`
-
-type SelectAMPInvoicePaymentsParams struct {
-	SetID        []byte
-	SettledIndex sql.NullInt32
-	InvoiceID    sql.NullInt32
-}
-
-type SelectAMPInvoicePaymentsRow struct {
-	SetID          []byte
-	State          int16
-	CreatedAt      time.Time
-	SettledIndex   sql.NullInt32
-	InvoiceID      int32
-	ID             sql.NullInt32
-	SettledAt      sql.NullTime
-	AmountPaidMsat sql.NullInt64
-	InvoiceID_2    sql.NullInt32
-}
-
-func (q *Queries) SelectAMPInvoicePayments(ctx context.Context, arg SelectAMPInvoicePaymentsParams) ([]SelectAMPInvoicePaymentsRow, error) {
-	rows, err := q.db.QueryContext(ctx, selectAMPInvoicePayments, arg.SetID, arg.SettledIndex, arg.InvoiceID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []SelectAMPInvoicePaymentsRow
-	for rows.Next() {
-		var i SelectAMPInvoicePaymentsRow
-		if err := rows.Scan(
-			&i.SetID,
-			&i.State,
-			&i.CreatedAt,
-			&i.SettledIndex,
-			&i.InvoiceID,
-			&i.ID,
-			&i.SettledAt,
-			&i.AmountPaidMsat,
-			&i.InvoiceID_2,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const updateAMPInvoiceHTLC = `-- name: UpdateAMPInvoiceHTLC :exec
-UPDATE amp_invoice_htlcs
-SET preimage = $1
-WHERE htlc_id = $2
-`
-
-type UpdateAMPInvoiceHTLCParams struct {
-	Preimage []byte
-	HtlcID   int64
-}
-
-func (q *Queries) UpdateAMPInvoiceHTLC(ctx context.Context, arg UpdateAMPInvoiceHTLCParams) error {
-	_, err := q.db.ExecContext(ctx, updateAMPInvoiceHTLC, arg.Preimage, arg.HtlcID)
-	return err
-}
-
-const updateAMPPayment = `-- name: UpdateAMPPayment :exec
-UPDATE amp_invoice_payments
-SET state = $1, settled_index = $2
-WHERE state = 0 AND (
-    set_id = $3 OR 
-    $3 IS NULL
-) AND (
-    invoice_id = $4 OR 
-    $4 IS NULL
-)
-`
-
-type UpdateAMPPaymentParams struct {
-	State        int16
-	SettledIndex sql.NullInt32
-	SetID        []byte
-	InvoiceID    sql.NullInt32
-}
-
-func (q *Queries) UpdateAMPPayment(ctx context.Context, arg UpdateAMPPaymentParams) error {
-	_, err := q.db.ExecContext(ctx, updateAMPPayment,
-		arg.State,
-		arg.SettledIndex,
-		arg.SetID,
-		arg.InvoiceID,
-	)
-	return err
 }
diff --git a/sqldb/sqlc/invoice_events.sql.go b/sqldb/sqlc/invoice_events.sql.go
index b0623fc1e..983dfbb15 100644
--- a/sqldb/sqlc/invoice_events.sql.go
+++ b/sqldb/sqlc/invoice_events.sql.go
@@ -7,122 +7,116 @@ package sqlc
 
 import (
 	"context"
-	"database/sql"
 	"time"
 )
 
-const deleteInvoiceEvents = `-- name: DeleteInvoiceEvents :exec
-DELETE
-FROM invoice_events
-WHERE invoice_id = $1
-`
-
-func (q *Queries) DeleteInvoiceEvents(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoiceEvents, invoiceID)
-	return err
-}
-
-const insertInvoiceEvent = `-- name: InsertInvoiceEvent :exec
+const onAMPSubInvoiceCanceled = `-- name: OnAMPSubInvoiceCanceled :exec
 INSERT INTO invoice_events (
-    created_at, invoice_id, htlc_id, set_id, event_type, event_metadata
+    added_at, event_type, invoice_id, set_id
 ) VALUES (
-    $1, $2, $3, $4, $5, $6
+    $1, 4, $2, $3
 )
 `
 
-type InsertInvoiceEventParams struct {
-	CreatedAt     time.Time
-	InvoiceID     int32
-	HtlcID        sql.NullInt64
-	SetID         []byte
-	EventType     int32
-	EventMetadata []byte
+type OnAMPSubInvoiceCanceledParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+	SetID     []byte
 }
 
-func (q *Queries) InsertInvoiceEvent(ctx context.Context, arg InsertInvoiceEventParams) error {
-	_, err := q.db.ExecContext(ctx, insertInvoiceEvent,
-		arg.CreatedAt,
-		arg.InvoiceID,
-		arg.HtlcID,
-		arg.SetID,
-		arg.EventType,
-		arg.EventMetadata,
-	)
+func (q *Queries) OnAMPSubInvoiceCanceled(ctx context.Context, arg OnAMPSubInvoiceCanceledParams) error {
+	_, err := q.db.ExecContext(ctx, onAMPSubInvoiceCanceled, arg.AddedAt, arg.InvoiceID, arg.SetID)
 	return err
 }
 
-const selectInvoiceEvents = `-- name: SelectInvoiceEvents :many
-SELECT id, created_at, invoice_id, htlc_id, set_id, event_type, event_metadata
-FROM invoice_events
-WHERE (
-    invoice_id = $1 OR 
-    $1 IS NULL
-) AND (
-    htlc_id = $2 OR 
-    $2 IS NULL
-) AND (
-    set_id = $3 OR 
-    $3 IS NULL
-) AND (
-    event_type = $4 OR 
-    $4 IS NULL
-) AND (
-    created_at >= $5 OR 
-    $5 IS NULL
-) AND (
-    created_at <= $6 OR 
-    $6 IS NULL
-) 
-LIMIT $8 OFFSET $7
+const onAMPSubInvoiceCreated = `-- name: OnAMPSubInvoiceCreated :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id, set_id
+) VALUES (
+    $1, 3, $2, $3
+)
 `
 
-type SelectInvoiceEventsParams struct {
-	InvoiceID     sql.NullInt32
-	HtlcID        sql.NullInt64
-	SetID         []byte
-	EventType     sql.NullInt32
-	CreatedAfter  sql.NullTime
-	CreatedBefore sql.NullTime
-	NumOffset     int32
-	NumLimit      int32
+type OnAMPSubInvoiceCreatedParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+	SetID     []byte
 }
 
-func (q *Queries) SelectInvoiceEvents(ctx context.Context, arg SelectInvoiceEventsParams) ([]InvoiceEvent, error) {
-	rows, err := q.db.QueryContext(ctx, selectInvoiceEvents,
-		arg.InvoiceID,
-		arg.HtlcID,
-		arg.SetID,
-		arg.EventType,
-		arg.CreatedAfter,
-		arg.CreatedBefore,
-		arg.NumOffset,
-		arg.NumLimit,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []InvoiceEvent
-	for rows.Next() {
-		var i InvoiceEvent
-		if err := rows.Scan(
-			&i.ID,
-			&i.CreatedAt,
-			&i.InvoiceID,
-			&i.HtlcID,
-			&i.SetID,
-			&i.EventType,
-			&i.EventMetadata,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
+func (q *Queries) OnAMPSubInvoiceCreated(ctx context.Context, arg OnAMPSubInvoiceCreatedParams) error {
+	_, err := q.db.ExecContext(ctx, onAMPSubInvoiceCreated, arg.AddedAt, arg.InvoiceID, arg.SetID)
+	return err
+}
+
+const onAMPSubInvoiceSettled = `-- name: OnAMPSubInvoiceSettled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id, set_id
+) VALUES (
+    $1, 5, $2, $3
+)
+`
+
+type OnAMPSubInvoiceSettledParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+	SetID     []byte
+}
+
+func (q *Queries) OnAMPSubInvoiceSettled(ctx context.Context, arg OnAMPSubInvoiceSettledParams) error {
+	_, err := q.db.ExecContext(ctx, onAMPSubInvoiceSettled, arg.AddedAt, arg.InvoiceID, arg.SetID)
+	return err
+}
+
+const onInvoiceCanceled = `-- name: OnInvoiceCanceled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id
+) VALUES (
+    $1, 1, $2
+)
+`
+
+type OnInvoiceCanceledParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+}
+
+func (q *Queries) OnInvoiceCanceled(ctx context.Context, arg OnInvoiceCanceledParams) error {
+	_, err := q.db.ExecContext(ctx, onInvoiceCanceled, arg.AddedAt, arg.InvoiceID)
+	return err
+}
+
+const onInvoiceCreated = `-- name: OnInvoiceCreated :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id
+) VALUES (
+    $1, 0, $2
+)
+`
+
+type OnInvoiceCreatedParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+}
+
+func (q *Queries) OnInvoiceCreated(ctx context.Context, arg OnInvoiceCreatedParams) error {
+	_, err := q.db.ExecContext(ctx, onInvoiceCreated, arg.AddedAt, arg.InvoiceID)
+	return err
+}
+
+const onInvoiceSettled = `-- name: OnInvoiceSettled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id
+) VALUES (
+    $1, 2, $2
+)
+`
+
+type OnInvoiceSettledParams struct {
+	AddedAt   time.Time
+	InvoiceID int64
+}
+
+func (q *Queries) OnInvoiceSettled(ctx context.Context, arg OnInvoiceSettledParams) error {
+	_, err := q.db.ExecContext(ctx, onInvoiceSettled, arg.AddedAt, arg.InvoiceID)
+	return err
 }
diff --git a/sqldb/sqlc/invoices.sql.go b/sqldb/sqlc/invoices.sql.go
index 927905c96..09ca1a1e2 100644
--- a/sqldb/sqlc/invoices.sql.go
+++ b/sqldb/sqlc/invoices.sql.go
@@ -11,7 +11,17 @@ import (
 	"time"
 )
 
-const deleteInvoice = `-- name: DeleteInvoice :exec
+const deleteCanceledInvoices = `-- name: DeleteCanceledInvoices :execresult
+DELETE
+FROM invoices
+WHERE state = 2
+`
+
+func (q *Queries) DeleteCanceledInvoices(ctx context.Context) (sql.Result, error) {
+	return q.db.ExecContext(ctx, deleteCanceledInvoices)
+}
+
+const deleteInvoice = `-- name: DeleteInvoice :execresult
 DELETE 
 FROM invoices 
 WHERE (
@@ -21,7 +31,7 @@ WHERE (
     hash = $2 OR 
     $2 IS NULL
 ) AND (
-    preimage = $3 OR 
+    settle_index = $3 OR 
     $3 IS NULL
 ) AND (
     payment_addr = $4 OR
@@ -30,174 +40,24 @@ WHERE (
 `
 
 type DeleteInvoiceParams struct {
-	AddIndex    sql.NullInt32
+	AddIndex    sql.NullInt64
 	Hash        []byte
-	Preimage    []byte
+	SettleIndex sql.NullInt64
 	PaymentAddr []byte
 }
 
-func (q *Queries) DeleteInvoice(ctx context.Context, arg DeleteInvoiceParams) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoice,
+func (q *Queries) DeleteInvoice(ctx context.Context, arg DeleteInvoiceParams) (sql.Result, error) {
+	return q.db.ExecContext(ctx, deleteInvoice,
 		arg.AddIndex,
 		arg.Hash,
-		arg.Preimage,
+		arg.SettleIndex,
 		arg.PaymentAddr,
 	)
-	return err
-}
-
-const deleteInvoiceFeatures = `-- name: DeleteInvoiceFeatures :exec
-DELETE 
-FROM invoice_features
-WHERE invoice_id = $1
-`
-
-func (q *Queries) DeleteInvoiceFeatures(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoiceFeatures, invoiceID)
-	return err
-}
-
-const deleteInvoiceHTLC = `-- name: DeleteInvoiceHTLC :exec
-DELETE
-FROM invoice_htlcs
-WHERE htlc_id = $1
-`
-
-func (q *Queries) DeleteInvoiceHTLC(ctx context.Context, htlcID int64) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoiceHTLC, htlcID)
-	return err
-}
-
-const deleteInvoiceHTLCCustomRecords = `-- name: DeleteInvoiceHTLCCustomRecords :exec
-WITH htlc_ids AS (
-    SELECT ih.id
-    FROM invoice_htlcs ih JOIN invoice_htlc_custom_records ihcr ON ih.id=ihcr.htlc_id 
-    WHERE ih.invoice_id = $1
-)
-DELETE
-FROM invoice_htlc_custom_records
-WHERE htlc_id IN (SELECT id FROM htlc_ids)
-`
-
-func (q *Queries) DeleteInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoiceHTLCCustomRecords, invoiceID)
-	return err
-}
-
-const deleteInvoiceHTLCs = `-- name: DeleteInvoiceHTLCs :exec
-DELETE
-FROM invoice_htlcs
-WHERE invoice_id = $1
-`
-
-func (q *Queries) DeleteInvoiceHTLCs(ctx context.Context, invoiceID int32) error {
-	_, err := q.db.ExecContext(ctx, deleteInvoiceHTLCs, invoiceID)
-	return err
-}
-
-const filterInvoicePayments = `-- name: FilterInvoicePayments :many
-SELECT  
-    ip.id AS settle_index, ip.amount_paid_msat, ip.settled_at AS settle_date, 
-    i.id, i.hash, i.preimage, i.memo, i.amount_msat, i.cltv_delta, i.expiry, i.payment_addr, i.payment_request, i.state, i.amount_paid_msat, i.is_amp, i.is_hodl, i.is_keysend, i.created_at 
-FROM invoice_payments ip JOIN invoices i ON ip.invoice_id = i.id
-WHERE (
-    ip.id >= $1 OR 
-    $1 IS NULL
-) AND (
-    ip.settled_at >= $2 OR 
-    $2 IS NULL
-)
-ORDER BY
-    CASE
-        WHEN $3 = FALSE THEN ip.id  
-        ELSE NULL
-    END ASC,
-    CASE
-        WHEN $3 = TRUE THEN ip.id  
-        ELSE NULL
-    END DESC
-LIMIT $5 OFFSET $4
-`
-
-type FilterInvoicePaymentsParams struct {
-	SettleIndexGet sql.NullInt32
-	SettledAfter   sql.NullTime
-	Reverse        interface{}
-	NumOffset      int32
-	NumLimit       int32
-}
-
-type FilterInvoicePaymentsRow struct {
-	SettleIndex      int32
-	AmountPaidMsat   int64
-	SettleDate       time.Time
-	ID               int32
-	Hash             []byte
-	Preimage         []byte
-	Memo             sql.NullString
-	AmountMsat       int64
-	CltvDelta        sql.NullInt32
-	Expiry           int32
-	PaymentAddr      []byte
-	PaymentRequest   sql.NullString
-	State            int16
-	AmountPaidMsat_2 int64
-	IsAmp            bool
-	IsHodl           bool
-	IsKeysend        bool
-	CreatedAt        time.Time
-}
-
-func (q *Queries) FilterInvoicePayments(ctx context.Context, arg FilterInvoicePaymentsParams) ([]FilterInvoicePaymentsRow, error) {
-	rows, err := q.db.QueryContext(ctx, filterInvoicePayments,
-		arg.SettleIndexGet,
-		arg.SettledAfter,
-		arg.Reverse,
-		arg.NumOffset,
-		arg.NumLimit,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []FilterInvoicePaymentsRow
-	for rows.Next() {
-		var i FilterInvoicePaymentsRow
-		if err := rows.Scan(
-			&i.SettleIndex,
-			&i.AmountPaidMsat,
-			&i.SettleDate,
-			&i.ID,
-			&i.Hash,
-			&i.Preimage,
-			&i.Memo,
-			&i.AmountMsat,
-			&i.CltvDelta,
-			&i.Expiry,
-			&i.PaymentAddr,
-			&i.PaymentRequest,
-			&i.State,
-			&i.AmountPaidMsat_2,
-			&i.IsAmp,
-			&i.IsHodl,
-			&i.IsKeysend,
-			&i.CreatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
 }
 
 const filterInvoices = `-- name: FilterInvoices :many
-SELECT id, hash, preimage, memo, amount_msat, cltv_delta, expiry, payment_addr, payment_request, state, amount_paid_msat, is_amp, is_hodl, is_keysend, created_at 
+SELECT
+    invoices.id, invoices.hash, invoices.preimage, invoices.settle_index, invoices.settled_at, invoices.memo, invoices.amount_msat, invoices.cltv_delta, invoices.expiry, invoices.payment_addr, invoices.payment_request, invoices.payment_request_hash, invoices.state, invoices.amount_paid_msat, invoices.is_amp, invoices.is_hodl, invoices.is_keysend, invoices.created_at
 FROM invoices
 WHERE (
     id >= $1 OR 
@@ -206,48 +66,58 @@ WHERE (
     id <= $2 OR 
     $2 IS NULL
 ) AND (
-    state = $3 OR 
+    settle_index >= $3 OR
     $3 IS NULL
 ) AND (
-    created_at >= $4 OR
+    settle_index <= $4 OR
     $4 IS NULL
 ) AND (
-    created_at <= $5 OR 
+    state = $5 OR 
     $5 IS NULL
+) AND (
+    created_at >= $6 OR
+    $6 IS NULL
+) AND (
+    created_at <= $7 OR 
+    $7 IS NULL
 ) AND (
     CASE
-        WHEN $6=TRUE THEN (state = 0 OR state = 3)
+        WHEN $8=TRUE THEN (state = 0 OR state = 3)
         ELSE TRUE 
     END
 )
 ORDER BY
     CASE
-        WHEN $7 = FALSE THEN id  
+        WHEN $9 = FALSE THEN id  
         ELSE NULL
     END ASC,
     CASE
-        WHEN $7 = TRUE  THEN id  
+        WHEN $9 = TRUE  THEN id  
         ELSE NULL
     END DESC
-LIMIT $9 OFFSET $8
+LIMIT $11 OFFSET $10
 `
 
 type FilterInvoicesParams struct {
-	AddIndexGet   sql.NullInt32
-	AddIndexLet   sql.NullInt32
-	State         sql.NullInt16
-	CreatedAfter  sql.NullTime
-	CreatedBefore sql.NullTime
-	PendingOnly   interface{}
-	Reverse       interface{}
-	NumOffset     int32
-	NumLimit      int32
+	AddIndexGet    sql.NullInt64
+	AddIndexLet    sql.NullInt64
+	SettleIndexGet sql.NullInt64
+	SettleIndexLet sql.NullInt64
+	State          sql.NullInt16
+	CreatedAfter   sql.NullTime
+	CreatedBefore  sql.NullTime
+	PendingOnly    interface{}
+	Reverse        interface{}
+	NumOffset      int32
+	NumLimit       int32
 }
 
 func (q *Queries) FilterInvoices(ctx context.Context, arg FilterInvoicesParams) ([]Invoice, error) {
 	rows, err := q.db.QueryContext(ctx, filterInvoices,
 		arg.AddIndexGet,
 		arg.AddIndexLet,
+		arg.SettleIndexGet,
+		arg.SettleIndexLet,
 		arg.State,
 		arg.CreatedAfter,
 		arg.CreatedBefore,
@@ -267,12 +137,15 @@ func (q *Queries) FilterInvoices(ctx context.Context, arg FilterInvoicesParams)
 			&i.ID,
 			&i.Hash,
 			&i.Preimage,
+			&i.SettleIndex,
+			&i.SettledAt,
 			&i.Memo,
 			&i.AmountMsat,
 			&i.CltvDelta,
 			&i.Expiry,
 			&i.PaymentAddr,
 			&i.PaymentRequest,
+			&i.PaymentRequestHash,
 			&i.State,
 			&i.AmountPaidMsat,
 			&i.IsAmp,
@@ -295,29 +168,35 @@ func (q *Queries) FilterInvoices(ctx context.Context, arg FilterInvoicesParams)
 
 const getInvoice = `-- name: GetInvoice :many
 
-SELECT id, hash, preimage, memo, amount_msat, cltv_delta, expiry, payment_addr, payment_request, state, amount_paid_msat, is_amp, is_hodl, is_keysend, created_at
-FROM invoices
+SELECT i.id, i.hash, i.preimage, i.settle_index, i.settled_at, i.memo, i.amount_msat, i.cltv_delta, i.expiry, i.payment_addr, i.payment_request, i.payment_request_hash, i.state, i.amount_paid_msat, i.is_amp, i.is_hodl, i.is_keysend, i.created_at
+FROM invoices i
+LEFT JOIN amp_sub_invoices a on i.id = a.invoice_id
 WHERE (
-    id = $1 OR 
+    i.id = $1 OR 
     $1 IS NULL
 ) AND (
-    hash = $2 OR 
+    i.hash = $2 OR 
     $2 IS NULL
 ) AND (
-    preimage = $3 OR 
+    i.preimage = $3 OR 
     $3 IS NULL
 ) AND (
-    payment_addr = $4 OR 
+    i.payment_addr = $4 OR 
     $4 IS NULL
+) AND (
+    a.set_id = $5 OR
+    $5 IS NULL
 )
+GROUP BY i.id
 LIMIT 2
 `
 
 type GetInvoiceParams struct {
-	AddIndex    sql.NullInt32
+	AddIndex    sql.NullInt64
 	Hash        []byte
 	Preimage    []byte
 	PaymentAddr []byte
+	SetID       []byte
 }
 
 // This method may return more than one invoice if filter using multiple fields
@@ -329,6 +208,7 @@ func (q *Queries) GetInvoice(ctx context.Context, arg GetInvoiceParams) ([]Invoi
 		arg.Hash,
 		arg.Preimage,
 		arg.PaymentAddr,
+		arg.SetID,
 	)
 	if err != nil {
 		return nil, err
@@ -341,12 +221,15 @@ func (q *Queries) GetInvoice(ctx context.Context, arg GetInvoiceParams) ([]Invoi
 			&i.ID,
 			&i.Hash,
 			&i.Preimage,
+			&i.SettleIndex,
+			&i.SettledAt,
 			&i.Memo,
 			&i.AmountMsat,
 			&i.CltvDelta,
 			&i.Expiry,
 			&i.PaymentAddr,
 			&i.PaymentRequest,
+			&i.PaymentRequestHash,
 			&i.State,
 			&i.AmountPaidMsat,
 			&i.IsAmp,
@@ -373,7 +256,7 @@ FROM invoice_features
 WHERE invoice_id = $1
 `
 
-func (q *Queries) GetInvoiceFeatures(ctx context.Context, invoiceID int32) ([]InvoiceFeature, error) {
+func (q *Queries) GetInvoiceFeatures(ctx context.Context, invoiceID int64) ([]InvoiceFeature, error) {
 	rows, err := q.db.QueryContext(ctx, getInvoiceFeatures, invoiceID)
 	if err != nil {
 		return nil, err
@@ -408,7 +291,7 @@ type GetInvoiceHTLCCustomRecordsRow struct {
 	Value  []byte
 }
 
-func (q *Queries) GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int32) ([]GetInvoiceHTLCCustomRecordsRow, error) {
+func (q *Queries) GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int64) ([]GetInvoiceHTLCCustomRecordsRow, error) {
 	rows, err := q.db.QueryContext(ctx, getInvoiceHTLCCustomRecords, invoiceID)
 	if err != nil {
 		return nil, err
@@ -432,12 +315,12 @@ func (q *Queries) GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int
 }
 
 const getInvoiceHTLCs = `-- name: GetInvoiceHTLCs :many
-SELECT id, htlc_id, chan_id, amount_msat, total_mpp_msat, accept_height, accept_time, expiry_height, state, resolve_time, invoice_id
+SELECT id, chan_id, htlc_id, amount_msat, total_mpp_msat, accept_height, accept_time, expiry_height, state, resolve_time, invoice_id
 FROM invoice_htlcs
 WHERE invoice_id = $1
 `
 
-func (q *Queries) GetInvoiceHTLCs(ctx context.Context, invoiceID int32) ([]InvoiceHtlc, error) {
+func (q *Queries) GetInvoiceHTLCs(ctx context.Context, invoiceID int64) ([]InvoiceHtlc, error) {
 	rows, err := q.db.QueryContext(ctx, getInvoiceHTLCs, invoiceID)
 	if err != nil {
 		return nil, err
@@ -448,8 +331,8 @@ func (q *Queries) GetInvoiceHTLCs(ctx context.Context, invoiceID int32) ([]Invoi
 		var i InvoiceHtlc
 		if err := rows.Scan(
 			&i.ID,
-			&i.HtlcID,
 			&i.ChanID,
+			&i.HtlcID,
 			&i.AmountMsat,
 			&i.TotalMppMsat,
 			&i.AcceptHeight,
@@ -472,68 +355,35 @@ func (q *Queries) GetInvoiceHTLCs(ctx context.Context, invoiceID int32) ([]Invoi
 	return items, nil
 }
 
-const getInvoicePayments = `-- name: GetInvoicePayments :many
-SELECT id, settled_at, amount_paid_msat, invoice_id
-FROM invoice_payments
-WHERE invoice_id = $1
-`
-
-func (q *Queries) GetInvoicePayments(ctx context.Context, invoiceID int32) ([]InvoicePayment, error) {
-	rows, err := q.db.QueryContext(ctx, getInvoicePayments, invoiceID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	var items []InvoicePayment
-	for rows.Next() {
-		var i InvoicePayment
-		if err := rows.Scan(
-			&i.ID,
-			&i.SettledAt,
-			&i.AmountPaidMsat,
-			&i.InvoiceID,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
 const insertInvoice = `-- name: InsertInvoice :one
 INSERT INTO invoices (
     hash, preimage, memo, amount_msat, cltv_delta, expiry, payment_addr, 
-    payment_request, state, amount_paid_msat, is_amp, is_hodl, is_keysend, 
-    created_at
+    payment_request, payment_request_hash, state, amount_paid_msat, is_amp,
+    is_hodl, is_keysend, created_at
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
 ) RETURNING id
 `
 
 type InsertInvoiceParams struct {
-	Hash           []byte
-	Preimage       []byte
-	Memo           sql.NullString
-	AmountMsat     int64
-	CltvDelta      sql.NullInt32
-	Expiry         int32
-	PaymentAddr    []byte
-	PaymentRequest sql.NullString
-	State          int16
-	AmountPaidMsat int64
-	IsAmp          bool
-	IsHodl         bool
-	IsKeysend      bool
-	CreatedAt      time.Time
+	Hash               []byte
+	Preimage           []byte
+	Memo               sql.NullString
+	AmountMsat         int64
+	CltvDelta          sql.NullInt32
+	Expiry             int32
+	PaymentAddr        []byte
+	PaymentRequest     sql.NullString
+	PaymentRequestHash []byte
+	State              int16
+	AmountPaidMsat     int64
+	IsAmp              bool
+	IsHodl             bool
+	IsKeysend          bool
+	CreatedAt          time.Time
 }
 
-func (q *Queries) InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (int32, error) {
+func (q *Queries) InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (int64, error) {
 	row := q.db.QueryRowContext(ctx, insertInvoice,
 		arg.Hash,
 		arg.Preimage,
@@ -543,6 +393,7 @@ func (q *Queries) InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (i
 		arg.Expiry,
 		arg.PaymentAddr,
 		arg.PaymentRequest,
+		arg.PaymentRequestHash,
 		arg.State,
 		arg.AmountPaidMsat,
 		arg.IsAmp,
@@ -550,7 +401,7 @@ func (q *Queries) InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (i
 		arg.IsKeysend,
 		arg.CreatedAt,
 	)
-	var id int32
+	var id int64
 	err := row.Scan(&id)
 	return id, err
 }
@@ -564,7 +415,7 @@ INSERT INTO invoice_features (
 `
 
 type InsertInvoiceFeatureParams struct {
-	InvoiceID int32
+	InvoiceID int64
 	Feature   int32
 }
 
@@ -573,13 +424,13 @@ func (q *Queries) InsertInvoiceFeature(ctx context.Context, arg InsertInvoiceFea
 	return err
 }
 
-const insertInvoiceHTLC = `-- name: InsertInvoiceHTLC :exec
+const insertInvoiceHTLC = `-- name: InsertInvoiceHTLC :one
 INSERT INTO invoice_htlcs (
     htlc_id, chan_id, amount_msat, total_mpp_msat, accept_height, accept_time,
     expiry_height, state, resolve_time, invoice_id
 ) VALUES (
     $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
-)
+) RETURNING id
 `
 
 type InsertInvoiceHTLCParams struct {
@@ -592,11 +443,11 @@ type InsertInvoiceHTLCParams struct {
 	ExpiryHeight int32
 	State        int16
 	ResolveTime  sql.NullTime
-	InvoiceID    int32
+	InvoiceID    int64
 }
 
-func (q *Queries) InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCParams) error {
-	_, err := q.db.ExecContext(ctx, insertInvoiceHTLC,
+func (q *Queries) InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCParams) (int64, error) {
+	row := q.db.QueryRowContext(ctx, insertInvoiceHTLC,
 		arg.HtlcID,
 		arg.ChanID,
 		arg.AmountMsat,
@@ -608,7 +459,9 @@ func (q *Queries) InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCPa
 		arg.ResolveTime,
 		arg.InvoiceID,
 	)
-	return err
+	var id int64
+	err := row.Scan(&id)
+	return id, err
 }
 
 const insertInvoiceHTLCCustomRecord = `-- name: InsertInvoiceHTLCCustomRecord :exec
@@ -630,64 +483,56 @@ func (q *Queries) InsertInvoiceHTLCCustomRecord(ctx context.Context, arg InsertI
 	return err
 }
 
-const insertInvoicePayment = `-- name: InsertInvoicePayment :one
-INSERT INTO invoice_payments (
-    invoice_id, amount_paid_msat, settled_at 
-) VALUES (
-    $1, $2, $3
-) RETURNING id
+const nextInvoiceSettleIndex = `-- name: NextInvoiceSettleIndex :one
+UPDATE invoice_sequences SET current_value = current_value + 1
+WHERE name = 'settle_index'
+RETURNING current_value
 `
 
-type InsertInvoicePaymentParams struct {
-	InvoiceID      int32
-	AmountPaidMsat int64
-	SettledAt      time.Time
+func (q *Queries) NextInvoiceSettleIndex(ctx context.Context) (int64, error) {
+	row := q.db.QueryRowContext(ctx, nextInvoiceSettleIndex)
+	var current_value int64
+	err := row.Scan(&current_value)
+	return current_value, err
 }
 
-func (q *Queries) InsertInvoicePayment(ctx context.Context, arg InsertInvoicePaymentParams) (int32, error) {
-	row := q.db.QueryRowContext(ctx, insertInvoicePayment, arg.InvoiceID, arg.AmountPaidMsat, arg.SettledAt)
-	var id int32
-	err := row.Scan(&id)
-	return id, err
-}
-
-const updateInvoice = `-- name: UpdateInvoice :exec
-UPDATE invoices 
-SET preimage=$2, state=$3, amount_paid_msat=$4
-WHERE id=$1
+const updateInvoiceAmountPaid = `-- name: UpdateInvoiceAmountPaid :execresult
+UPDATE invoices
+SET amount_paid_msat = $2
+WHERE id = $1
 `
 
-type UpdateInvoiceParams struct {
-	ID             int32
-	Preimage       []byte
-	State          int16
+type UpdateInvoiceAmountPaidParams struct {
+	ID             int64
 	AmountPaidMsat int64
 }
 
-func (q *Queries) UpdateInvoice(ctx context.Context, arg UpdateInvoiceParams) error {
-	_, err := q.db.ExecContext(ctx, updateInvoice,
-		arg.ID,
-		arg.Preimage,
-		arg.State,
-		arg.AmountPaidMsat,
-	)
-	return err
+func (q *Queries) UpdateInvoiceAmountPaid(ctx context.Context, arg UpdateInvoiceAmountPaidParams) (sql.Result, error) {
+	return q.db.ExecContext(ctx, updateInvoiceAmountPaid, arg.ID, arg.AmountPaidMsat)
 }
 
 const updateInvoiceHTLC = `-- name: UpdateInvoiceHTLC :exec
 UPDATE invoice_htlcs 
-SET state=$2, resolve_time=$3
-WHERE id = $1
+SET state=$4, resolve_time=$5
+WHERE htlc_id = $1 AND chan_id = $2 AND invoice_id = $3
 `
 
 type UpdateInvoiceHTLCParams struct {
-	ID          int32
+	HtlcID      int64
+	ChanID      string
+	InvoiceID   int64
 	State       int16
 	ResolveTime sql.NullTime
 }
 
 func (q *Queries) UpdateInvoiceHTLC(ctx context.Context, arg UpdateInvoiceHTLCParams) error {
-	_, err := q.db.ExecContext(ctx, updateInvoiceHTLC, arg.ID, arg.State, arg.ResolveTime)
+	_, err := q.db.ExecContext(ctx, updateInvoiceHTLC,
+		arg.HtlcID,
+		arg.ChanID,
+		arg.InvoiceID,
+		arg.State,
+		arg.ResolveTime,
+	)
 	return err
 }
 
@@ -698,7 +543,7 @@ WHERE invoice_id = $1 AND resolve_time IS NULL
 `
 
 type UpdateInvoiceHTLCsParams struct {
-	InvoiceID   int32
+	InvoiceID   int64
 	State       int16
 	ResolveTime sql.NullTime
 }
@@ -707,3 +552,30 @@ func (q *Queries) UpdateInvoiceHTLCs(ctx context.Context, arg UpdateInvoiceHTLCs
 	_, err := q.db.ExecContext(ctx, updateInvoiceHTLCs, arg.InvoiceID, arg.State, arg.ResolveTime)
 	return err
 }
+
+const updateInvoiceState = `-- name: UpdateInvoiceState :execresult
+UPDATE invoices
+SET state = $2,
+    preimage = COALESCE(preimage, $3),
+    settle_index = COALESCE(settle_index, $4),
+    settled_at = COALESCE(settled_at, $5)
+WHERE id = $1
+`
+
+type UpdateInvoiceStateParams struct {
+	ID          int64
+	State       int16
+	Preimage    []byte
+	SettleIndex sql.NullInt64
+	SettledAt   sql.NullTime
+}
+
+func (q *Queries) UpdateInvoiceState(ctx context.Context, arg UpdateInvoiceStateParams) (sql.Result, error) {
+	return q.db.ExecContext(ctx, updateInvoiceState,
+		arg.ID,
+		arg.State,
+		arg.Preimage,
+		arg.SettleIndex,
+		arg.SettledAt,
+	)
+}
diff --git a/sqldb/sqlc/migrations/000001_invoices.up.sql b/sqldb/sqlc/migrations/000001_invoices.up.sql
index 32b70b9fa..e4c80a26f 100644
--- a/sqldb/sqlc/migrations/000001_invoices.up.sql
+++ b/sqldb/sqlc/migrations/000001_invoices.up.sql
@@ -1,7 +1,17 @@
+-- sequences contains all sequences used for invoices.
+CREATE TABLE invoice_sequences (
+    name TEXT PRIMARY KEY,
+    current_value BIGINT NOT NULL
+);
+
+-- Initialize a sequence for the settled index used to track invoice settlement
+-- to remain compatible with the legacy channeldb implementation.
+INSERT INTO invoice_sequences(name, current_value) VALUES ('settle_index', 0);
+
 -- invoices table contains all the information shared by all the invoice types. 
 CREATE TABLE IF NOT EXISTS invoices (
     -- The id of the invoice. Translates to the AddIndex.
-    id INTEGER PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
 
     -- The hash for this invoice. The invoice hash will always identify that 
     -- invoice.
@@ -10,6 +20,14 @@ CREATE TABLE IF NOT EXISTS invoices (
     -- The preimage for the hash in this invoice. Some invoices may have this 
     -- field empty, like unsettled hodl invoices or AMP invoices.
     preimage BLOB,
+    
+    -- If settled, the index is set to the current_value+1 of the settle_index
+    -- seuqence in the invoice_sequences table. If not settled, then it is set
+    -- to NULL.
+    settle_index BIGINT,
+
+    -- When the invoice was settled.
+    settled_at TIMESTAMP,
 
     -- An optional memo to attach along with the invoice. 
     memo TEXT,
@@ -31,7 +49,12 @@ CREATE TABLE IF NOT EXISTS invoices (
 
     -- The encoded payment request for this invoice. Some invoice types may 
     -- not have leave this empty, like Keysends.
-    payment_request TEXT UNIQUE, 
+    payment_request TEXT,
+
+    -- Holds the hash of the payment request. This field is used to ensure that
+    -- there are no duplicates in the database. This trick is needed because
+    -- PostgreSQL has a limitiation of 2712 bytes for unique index rows.
+    payment_request_hash BLOB UNIQUE,
 
     -- The invoice state.
     state SMALLINT NOT NULL,
@@ -58,6 +81,7 @@ CREATE INDEX IF NOT EXISTS invoices_preimage_idx ON invoices(preimage);
 CREATE INDEX IF NOT EXISTS invoices_payment_addr_idx ON invoices(payment_addr);
 CREATE INDEX IF NOT EXISTS invoices_state_idx ON invoices(state);
 CREATE INDEX IF NOT EXISTS invoices_created_at_idx ON invoices(created_at);
+CREATE INDEX IF NOT EXISTS invoices_settled_at_idx ON invoices(settled_at);
 
 -- invoice_features contains the feature bits of an invoice.
 CREATE TABLE IF NOT EXISTS invoice_features (
@@ -65,7 +89,7 @@ CREATE TABLE IF NOT EXISTS invoice_features (
     feature INTEGER NOT NULL,
 
     -- The invoice id this feature belongs to.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id),
+    invoice_id BIGINT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
 
     -- The feature bit is unique per invoice.
     UNIQUE (feature, invoice_id)
@@ -78,15 +102,15 @@ CREATE INDEX IF NOT EXISTS invoice_feature_invoice_id_idx ON invoice_features(in
 CREATE TABLE IF NOT EXISTS invoice_htlcs (
     -- The id for this htlc. Used in foreign keys instead of the 
     -- htlc_id/chan_id combination.
-    id INTEGER PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
+    
+    -- Short chan id indicating the htlc's origin. uint64 stored as text.
+    chan_id TEXT NOT NULL, 
 
     -- The uint64 htlc id. This field is a counter so it is safe to store it as 
     -- int64 in the database. The application layer must check that there is no 
     -- overflow when storing/loading this column.
     htlc_id BIGINT NOT NULL,
-
-    -- Short chan id indicating the htlc's origin. uint64 stored as text.
-    chan_id TEXT NOT NULL, 
     
     -- The htlc's amount in millisatoshis.
     amount_msat BIGINT NOT NULL,
@@ -110,10 +134,10 @@ CREATE TABLE IF NOT EXISTS invoice_htlcs (
     resolve_time TIMESTAMP,
 
     -- The id of the invoice this htlc belongs to.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id),
+    invoice_id BIGINT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
 
     -- The htlc_id and chan_id identify the htlc.
-    UNIQUE (htlc_id, chan_id)
+    UNIQUE (chan_id, htlc_id)
 );
 
 CREATE INDEX IF NOT EXISTS invoice_htlc_invoice_id_idx ON invoice_htlcs(invoice_id);
@@ -129,26 +153,8 @@ CREATE TABLE IF NOT EXISTS invoice_htlc_custom_records (
     value BLOB NOT NULL,
 
     -- The htlc id this record belongs to. 
-    htlc_id BIGINT NOT NULL REFERENCES invoice_htlcs(id)
+    htlc_id BIGINT NOT NULL REFERENCES invoice_htlcs(id) ON DELETE CASCADE
 );
 
 CREATE INDEX IF NOT EXISTS invoice_htlc_custom_records_htlc_id_idx ON invoice_htlc_custom_records(htlc_id);
 
--- invoice_payments contains the information of a settled invoice payment. 
-CREATE TABLE IF NOT EXISTS invoice_payments (
-    -- The id for this invoice payment. Translates to SettleIndex.
-    id INTEGER PRIMARY KEY,
-    
-    -- When the payment was settled.
-    settled_at TIMESTAMP NOT NULL,
-
-    -- The amount of the payment in millisatoshis. This is the sum of all the 
-    -- the htlcs settled for this payment.
-    amount_paid_msat BIGINT NOT NULL,
-
-    -- The invoice id this payment is for.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id)
-);
-
-CREATE INDEX IF NOT EXISTS invoice_payments_settled_at_idx ON invoice_payments(settled_at);
-CREATE INDEX IF NOT EXISTS invoice_payments_invoice_id_idx ON invoice_payments(invoice_id);
diff --git a/sqldb/sqlc/migrations/000002_amp_invoices.up.sql b/sqldb/sqlc/migrations/000002_amp_invoices.up.sql
index a4daa8c30..7204e775b 100644
--- a/sqldb/sqlc/migrations/000002_amp_invoices.up.sql
+++ b/sqldb/sqlc/migrations/000002_amp_invoices.up.sql
@@ -1,5 +1,6 @@
--- amp_invoices_payments  
-CREATE TABLE IF NOT EXISTS amp_invoice_payments (
+-- amp_sub_invoices holds all AMP sub-invoices that belong to a given parent
+-- invoice.
+CREATE TABLE IF NOT EXISTS amp_sub_invoices (
     -- The set id identifying the payment. 
     set_id BLOB PRIMARY KEY,
 
@@ -10,26 +11,35 @@ CREATE TABLE IF NOT EXISTS amp_invoice_payments (
     -- Timestamp of when the first htlc for this payment was accepted.
     created_at TIMESTAMP NOT NULL,
 
-    -- If settled, the invoice payment related to this set id.
-    settled_index INTEGER REFERENCES invoice_payments(id),
+    -- When the invoice was settled.
+    settled_at TIMESTAMP,
 
-    -- The invoice id this set id is related to.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id)
+    -- If settled, the index is set to the current_value+1 of the settle_index
+    -- seuqence in the invoice_sequences table. If not settled, then it is set
+    -- to NULL.
+    settle_index BIGINT,
+
+    -- The id of the parent invoice this AMP invoice belongs to.
+    invoice_id BIGINT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
+
+    -- A unique constraint on the set_id and invoice_id is needed to ensure that
+    -- we don't have two AMP invoices for the same invoice.
+    UNIQUE (set_id, invoice_id)
 );
 
-CREATE INDEX IF NOT EXISTS amp_invoice_payments_invoice_id_idx ON amp_invoice_payments(invoice_id);
+CREATE INDEX IF NOT EXISTS amp_sub_invoices_invoice_id_idx ON amp_sub_invoices(invoice_id);
 
 -- amp_invoice_htlcs contains the complementary information for an htlc related 
 -- to an AMP invoice.
-CREATE TABLE IF NOT EXISTS amp_invoice_htlcs (
+CREATE TABLE IF NOT EXISTS amp_sub_invoice_htlcs (
+    -- The invoice id this entry is related to.
+    invoice_id BIGINT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
+
     -- The set id identifying the payment this htlc belongs to.
-    set_id BLOB NOT NULL REFERENCES amp_invoice_payments(set_id),
+    set_id BLOB NOT NULL REFERENCES amp_sub_invoices(set_id) ON DELETE CASCADE,
 
     -- The id of the htlc this entry blongs to.
-    htlc_id BIGINT NOT NULL REFERENCES invoice_htlcs(id),
-
-    -- The invoice id this entry is related to.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id),
+    htlc_id BIGINT NOT NULL REFERENCES invoice_htlcs(id) ON DELETE CASCADE,
 
     -- The root share for this amp htlc.
     root_share BLOB NOT NULL,
@@ -48,7 +58,7 @@ CREATE TABLE IF NOT EXISTS amp_invoice_htlcs (
     preimage BLOB 
 );
 
-CREATE INDEX IF NOT EXISTS amp_htlcs_set_id_idx ON amp_invoice_htlcs(set_id);
-CREATE INDEX IF NOT EXISTS amp_htlcs_invoice_id_idx ON amp_invoice_htlcs(invoice_id);
-CREATE INDEX IF NOT EXISTS amp_htlcs_htlc_id_idx ON amp_invoice_htlcs(htlc_id);
+CREATE INDEX IF NOT EXISTS amp_htlcs_invoice_id_idx ON amp_sub_invoice_htlcs(invoice_id);
+CREATE INDEX IF NOT EXISTS amp_htlcs_set_id_idx ON amp_sub_invoice_htlcs(set_id);
+CREATE INDEX IF NOT EXISTS amp_htlcs_htlc_id_idx ON amp_sub_invoice_htlcs(htlc_id);
 
diff --git a/sqldb/sqlc/migrations/000003_invoice_events.down.sql b/sqldb/sqlc/migrations/000003_invoice_events.down.sql
index 66e554e24..3f447dfa8 100644
--- a/sqldb/sqlc/migrations/000003_invoice_events.down.sql
+++ b/sqldb/sqlc/migrations/000003_invoice_events.down.sql
@@ -1,9 +1,6 @@
 DROP TABLE IF EXISTS invoice_events;
-
-DROP INDEX IF EXISTS invoice_events_created_at_idx;
-DROP INDEX IF EXISTS invoice_events_invoice_id_idx;
-DROP INDEX IF EXISTS invoice_events_htlc_id_idx;
-DROP INDEX IF EXISTS invoice_events_set_id_idx;
+DROP INDEX IF EXISTS invoice_events_added_at_idx;
 DROP INDEX IF EXISTS invoice_events_event_type_idx;
-
+DROP INDEX IF EXISTS invoice_events_invoice_id_idx;
+DROP INDEX IF EXISTS invoice_events_set_id_idx;
 DROP TABLE IF EXISTS invoice_event_types;
diff --git a/sqldb/sqlc/migrations/000003_invoice_events.up.sql b/sqldb/sqlc/migrations/000003_invoice_events.up.sql
index 47d2a91d0..a3718c0eb 100644
--- a/sqldb/sqlc/migrations/000003_invoice_events.up.sql
+++ b/sqldb/sqlc/migrations/000003_invoice_events.up.sql
@@ -1,59 +1,51 @@
--- invoice_event_types stores the different types of events that can be emitted 
--- for invoices.
+-- invoice_event_types stores the different types of invoice events. 
 CREATE TABLE IF NOT EXISTS invoice_event_types(
     id INTEGER PRIMARY KEY,
 
     description TEXT NOT NULL
 );
 
--- invoice_events stores all events related to the node invoices.
-CREATE TABLE IF NOT EXISTS invoice_events (
-    id INTEGER PRIMARY KEY,
-
-    -- created_at is the creation time of this event.
-    created_at TIMESTAMP NOT NULL,
-
-    -- invoice_id is the reference to the invoice this event was emitted for.
-    invoice_id INTEGER NOT NULL REFERENCES invoices(id),
-
-    -- htlc_id is the reference to the htlc this event was emitted for, may be 
-    -- null.
-    htlc_id BIGINT REFERENCES invoice_htlcs(htlc_id),
-
-    -- set_id is the reference to the set_id this event was emitted for, may be
-    -- null.
-    set_id BLOB NOT NULL REFERENCES amp_invoice_payments(set_id),
-
-    -- event_type is the type of this event.
-    event_type INTEGER NOT NULL REFERENCES invoice_event_types(id),
-
-    -- event_metadata is a TLV encoding any relevant information for this kind 
-    -- of events.
-    event_metadata BLOB
-);
-
-CREATE INDEX IF NOT EXISTS invoice_events_created_at_idx ON invoice_events(created_at);
-CREATE INDEX IF NOT EXISTS invoice_events_invoice_id_idx ON invoice_events(invoice_id);
-CREATE INDEX IF NOT EXISTS invoice_events_htlc_id_idx ON invoice_events(htlc_id);
-CREATE INDEX IF NOT EXISTS invoice_events_set_id_idx ON invoice_events(set_id);
-CREATE INDEX IF NOT EXISTS invoice_events_event_type_idx ON invoice_events(event_type);
-
-
--- invoice_event_types defines the different types of events that can be emitted
--- for an invoice.
+-- invoice_event_types defines the different types of invoice events.
 INSERT INTO invoice_event_types (id, description) 
 VALUES 
-    -- invoice_created is the event emitted when an invoice is created.
+    -- invoice_created is the event type used when an invoice is created.
     (0, 'invoice_created'), 
-    -- invoice_canceled is the event emitted when an invoice is canceled.
-    (1, "invoice_canceled"), 
-    -- invoice_settled is the event emitted when an invoice is settled.
-    (2, "invoice_settled"),
-    -- setid_created is the event emitted when the first htlc for the set_id is 
-    -- received. 
-    (3, "setid_created"),
-    -- setid_canceled is the event emitted when the set_id is canceled.
-    (4, "setid_canceled"),
-    -- setid_settled is the event emitted when the set_id is settled.
-    (5, "setid_settled");
+    -- invoice_canceled is the event type used when an invoice is canceled.
+    (1, 'invoice_canceled'), 
+    -- invoice_settled is the event type used when an invoice is settled.
+    (2, 'invoice_settled'),
+    -- setid_created is the event type used when an AMP sub invoice
+    -- corresponding to the set_id is created.
+    (3, 'setid_created'),
+    -- setid_canceled is the event type used when an AMP sub invoice
+    -- corresponding to the set_id is canceled.
+    (4, 'setid_canceled'),
+    -- setid_settled is the event type used when an AMP sub invoice 
+    -- corresponding to the set_id is settled.
+    (5, 'setid_settled');
 
+
+-- invoice_events stores all major events related to the node's invoices and
+-- AMP sub invoices. This table can be used to create a historical view of what
+-- happened to the node's invoices.
+CREATE TABLE IF NOT EXISTS invoice_events (
+    id BIGINT PRIMARY KEY,
+
+    -- added_at is the timestamp when this event was added.
+    added_at TIMESTAMP NOT NULL,
+
+    -- event_type is the type of this event.
+    event_type INTEGER NOT NULL REFERENCES invoice_event_types(id) ON DELETE CASCADE,
+
+    -- invoice_id is the reference to the invoice this event was added for.
+    invoice_id BIGINT NOT NULL REFERENCES invoices(id) ON DELETE CASCADE,
+
+    -- set_id is the reference to the AMP sub invoice this event was added for.
+    -- May be NULL if the event is not related to an AMP sub invoice.
+    set_id BLOB REFERENCES amp_sub_invoices(set_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS invoice_events_added_at_idx ON invoice_events(added_at);
+CREATE INDEX IF NOT EXISTS invoice_events_event_type_idx ON invoice_events(event_type);
+CREATE INDEX IF NOT EXISTS invoice_events_invoice_id_idx ON invoice_events(invoice_id);
+CREATE INDEX IF NOT EXISTS invoice_events_set_id_idx ON invoice_events(set_id);
diff --git a/sqldb/sqlc/models.go b/sqldb/sqlc/models.go
index 9a72ae2ce..83be5a708 100644
--- a/sqldb/sqlc/models.go
+++ b/sqldb/sqlc/models.go
@@ -9,50 +9,52 @@ import (
 	"time"
 )
 
-type AmpInvoiceHtlc struct {
+type AmpSubInvoice struct {
+	SetID       []byte
+	State       int16
+	CreatedAt   time.Time
+	SettledAt   sql.NullTime
+	SettleIndex sql.NullInt64
+	InvoiceID   int64
+}
+
+type AmpSubInvoiceHtlc struct {
+	InvoiceID  int64
 	SetID      []byte
 	HtlcID     int64
-	InvoiceID  int32
 	RootShare  []byte
 	ChildIndex int64
 	Hash       []byte
 	Preimage   []byte
 }
 
-type AmpInvoicePayment struct {
-	SetID        []byte
-	State        int16
-	CreatedAt    time.Time
-	SettledIndex sql.NullInt32
-	InvoiceID    int32
-}
-
 type Invoice struct {
-	ID             int32
-	Hash           []byte
-	Preimage       []byte
-	Memo           sql.NullString
-	AmountMsat     int64
-	CltvDelta      sql.NullInt32
-	Expiry         int32
-	PaymentAddr    []byte
-	PaymentRequest sql.NullString
-	State          int16
-	AmountPaidMsat int64
-	IsAmp          bool
-	IsHodl         bool
-	IsKeysend      bool
-	CreatedAt      time.Time
+	ID                 int64
+	Hash               []byte
+	Preimage           []byte
+	SettleIndex        sql.NullInt64
+	SettledAt          sql.NullTime
+	Memo               sql.NullString
+	AmountMsat         int64
+	CltvDelta          sql.NullInt32
+	Expiry             int32
+	PaymentAddr        []byte
+	PaymentRequest     sql.NullString
+	PaymentRequestHash []byte
+	State              int16
+	AmountPaidMsat     int64
+	IsAmp              bool
+	IsHodl             bool
+	IsKeysend          bool
+	CreatedAt          time.Time
 }
 
 type InvoiceEvent struct {
-	ID            int32
-	CreatedAt     time.Time
-	InvoiceID     int32
-	HtlcID        sql.NullInt64
-	SetID         []byte
-	EventType     int32
-	EventMetadata []byte
+	ID        int64
+	AddedAt   time.Time
+	EventType int32
+	InvoiceID int64
+	SetID     []byte
 }
 
 type InvoiceEventType struct {
@@ -62,13 +64,13 @@ type InvoiceEventType struct {
 
 type InvoiceFeature struct {
 	Feature   int32
-	InvoiceID int32
+	InvoiceID int64
 }
 
 type InvoiceHtlc struct {
-	ID           int32
-	HtlcID       int64
+	ID           int64
 	ChanID       string
+	HtlcID       int64
 	AmountMsat   int64
 	TotalMppMsat sql.NullInt64
 	AcceptHeight int32
@@ -76,7 +78,7 @@ type InvoiceHtlc struct {
 	ExpiryHeight int32
 	State        int16
 	ResolveTime  sql.NullTime
-	InvoiceID    int32
+	InvoiceID    int64
 }
 
 type InvoiceHtlcCustomRecord struct {
@@ -85,9 +87,7 @@ type InvoiceHtlcCustomRecord struct {
 	HtlcID int64
 }
 
-type InvoicePayment struct {
-	ID             int32
-	SettledAt      time.Time
-	AmountPaidMsat int64
-	InvoiceID      int32
+type InvoiceSequence struct {
+	Name         string
+	CurrentValue int64
 }
diff --git a/sqldb/sqlc/querier.go b/sqldb/sqlc/querier.go
index b879f06d3..d55d8090a 100644
--- a/sqldb/sqlc/querier.go
+++ b/sqldb/sqlc/querier.go
@@ -6,46 +6,43 @@ package sqlc
 
 import (
 	"context"
+	"database/sql"
 )
 
 type Querier interface {
-	DeleteAMPHTLCCustomRecords(ctx context.Context, invoiceID int32) error
-	DeleteAMPHTLCs(ctx context.Context, invoiceID int32) error
-	DeleteAMPInvoiceHTLC(ctx context.Context, setID []byte) error
-	DeleteInvoice(ctx context.Context, arg DeleteInvoiceParams) error
-	DeleteInvoiceEvents(ctx context.Context, invoiceID int32) error
-	DeleteInvoiceFeatures(ctx context.Context, invoiceID int32) error
-	DeleteInvoiceHTLC(ctx context.Context, htlcID int64) error
-	DeleteInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int32) error
-	DeleteInvoiceHTLCs(ctx context.Context, invoiceID int32) error
-	FilterInvoicePayments(ctx context.Context, arg FilterInvoicePaymentsParams) ([]FilterInvoicePaymentsRow, error)
+	DeleteCanceledInvoices(ctx context.Context) (sql.Result, error)
+	DeleteInvoice(ctx context.Context, arg DeleteInvoiceParams) (sql.Result, error)
+	FetchAMPSubInvoiceHTLCs(ctx context.Context, arg FetchAMPSubInvoiceHTLCsParams) ([]FetchAMPSubInvoiceHTLCsRow, error)
+	FetchAMPSubInvoices(ctx context.Context, arg FetchAMPSubInvoicesParams) ([]AmpSubInvoice, error)
+	FetchSettledAMPSubInvoices(ctx context.Context, arg FetchSettledAMPSubInvoicesParams) ([]FetchSettledAMPSubInvoicesRow, error)
 	FilterInvoices(ctx context.Context, arg FilterInvoicesParams) ([]Invoice, error)
-	GetAMPInvoiceHTLCsByInvoiceID(ctx context.Context, invoiceID int32) ([]AmpInvoiceHtlc, error)
-	GetAMPInvoiceHTLCsBySetID(ctx context.Context, setID []byte) ([]AmpInvoiceHtlc, error)
+	GetAMPInvoiceID(ctx context.Context, setID []byte) (int64, error)
 	// This method may return more than one invoice if filter using multiple fields
 	// from different invoices. It is the caller's responsibility to ensure that
 	// we bubble up an error in those cases.
 	GetInvoice(ctx context.Context, arg GetInvoiceParams) ([]Invoice, error)
-	GetInvoiceFeatures(ctx context.Context, invoiceID int32) ([]InvoiceFeature, error)
-	GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int32) ([]GetInvoiceHTLCCustomRecordsRow, error)
-	GetInvoiceHTLCs(ctx context.Context, invoiceID int32) ([]InvoiceHtlc, error)
-	GetInvoicePayments(ctx context.Context, invoiceID int32) ([]InvoicePayment, error)
-	GetSetIDHTLCsCustomRecords(ctx context.Context, setID []byte) ([]GetSetIDHTLCsCustomRecordsRow, error)
-	InsertAMPInvoiceHTLC(ctx context.Context, arg InsertAMPInvoiceHTLCParams) error
-	InsertAMPInvoicePayment(ctx context.Context, arg InsertAMPInvoicePaymentParams) error
-	InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (int32, error)
-	InsertInvoiceEvent(ctx context.Context, arg InsertInvoiceEventParams) error
+	GetInvoiceFeatures(ctx context.Context, invoiceID int64) ([]InvoiceFeature, error)
+	GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int64) ([]GetInvoiceHTLCCustomRecordsRow, error)
+	GetInvoiceHTLCs(ctx context.Context, invoiceID int64) ([]InvoiceHtlc, error)
+	InsertAMPSubInvoiceHTLC(ctx context.Context, arg InsertAMPSubInvoiceHTLCParams) error
+	InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (int64, error)
 	InsertInvoiceFeature(ctx context.Context, arg InsertInvoiceFeatureParams) error
-	InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCParams) error
+	InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCParams) (int64, error)
 	InsertInvoiceHTLCCustomRecord(ctx context.Context, arg InsertInvoiceHTLCCustomRecordParams) error
-	InsertInvoicePayment(ctx context.Context, arg InsertInvoicePaymentParams) (int32, error)
-	SelectAMPInvoicePayments(ctx context.Context, arg SelectAMPInvoicePaymentsParams) ([]SelectAMPInvoicePaymentsRow, error)
-	SelectInvoiceEvents(ctx context.Context, arg SelectInvoiceEventsParams) ([]InvoiceEvent, error)
-	UpdateAMPInvoiceHTLC(ctx context.Context, arg UpdateAMPInvoiceHTLCParams) error
-	UpdateAMPPayment(ctx context.Context, arg UpdateAMPPaymentParams) error
-	UpdateInvoice(ctx context.Context, arg UpdateInvoiceParams) error
+	NextInvoiceSettleIndex(ctx context.Context) (int64, error)
+	OnAMPSubInvoiceCanceled(ctx context.Context, arg OnAMPSubInvoiceCanceledParams) error
+	OnAMPSubInvoiceCreated(ctx context.Context, arg OnAMPSubInvoiceCreatedParams) error
+	OnAMPSubInvoiceSettled(ctx context.Context, arg OnAMPSubInvoiceSettledParams) error
+	OnInvoiceCanceled(ctx context.Context, arg OnInvoiceCanceledParams) error
+	OnInvoiceCreated(ctx context.Context, arg OnInvoiceCreatedParams) error
+	OnInvoiceSettled(ctx context.Context, arg OnInvoiceSettledParams) error
+	UpdateAMPSubInvoiceHTLCPreimage(ctx context.Context, arg UpdateAMPSubInvoiceHTLCPreimageParams) (sql.Result, error)
+	UpdateAMPSubInvoiceState(ctx context.Context, arg UpdateAMPSubInvoiceStateParams) error
+	UpdateInvoiceAmountPaid(ctx context.Context, arg UpdateInvoiceAmountPaidParams) (sql.Result, error)
 	UpdateInvoiceHTLC(ctx context.Context, arg UpdateInvoiceHTLCParams) error
 	UpdateInvoiceHTLCs(ctx context.Context, arg UpdateInvoiceHTLCsParams) error
+	UpdateInvoiceState(ctx context.Context, arg UpdateInvoiceStateParams) (sql.Result, error)
+	UpsertAMPSubInvoice(ctx context.Context, arg UpsertAMPSubInvoiceParams) (sql.Result, error)
 }
 
 var _ Querier = (*Queries)(nil)
diff --git a/sqldb/sqlc/queries/amp_invoices.sql b/sqldb/sqlc/queries/amp_invoices.sql
index d965de768..3b6ee76ac 100644
--- a/sqldb/sqlc/queries/amp_invoices.sql
+++ b/sqldb/sqlc/queries/amp_invoices.sql
@@ -1,79 +1,67 @@
--- name: InsertAMPInvoicePayment :exec
-INSERT INTO amp_invoice_payments (
-    set_id, state, created_at, settled_index, invoice_id
+-- name: UpsertAMPSubInvoice :execresult
+INSERT INTO amp_sub_invoices (
+    set_id, state, created_at, invoice_id
 ) VALUES (
-    $1, $2, $3, $4, $5
-); 
+    $1, $2, $3, $4
+) ON CONFLICT (set_id, invoice_id) DO NOTHING;
 
--- name: SelectAMPInvoicePayments :many
-SELECT aip.*, ip.*
-FROM amp_invoice_payments aip LEFT JOIN invoice_payments ip ON aip.settled_index = ip.id
-WHERE (
-    set_id = sqlc.narg('set_id') OR 
-    sqlc.narg('set_id') IS NULL
-) AND (
-    aip.settled_index = sqlc.narg('settled_index') OR 
-    sqlc.narg('settled_index') IS NULL
-) AND (
-    aip.invoice_id = sqlc.narg('invoice_id') OR 
-    sqlc.narg('invoice_id') IS NULL
-); 
+-- name: GetAMPInvoiceID :one
+SELECT invoice_id FROM amp_sub_invoices WHERE set_id = $1;
 
--- name: UpdateAMPPayment :exec
-UPDATE amp_invoice_payments
-SET state = $1, settled_index = $2
-WHERE state = 0 AND (
-    set_id = sqlc.narg('set_id') OR 
-    sqlc.narg('set_id') IS NULL
-) AND (
-    invoice_id = sqlc.narg('invoice_id') OR 
-    sqlc.narg('invoice_id') IS NULL
-); 
+-- name: UpdateAMPSubInvoiceState :exec
+UPDATE amp_sub_invoices
+SET state = $2, 
+    settle_index = COALESCE(settle_index, $3),
+    settled_at = COALESCE(settled_at, $4)
+WHERE set_id = $1; 
 
--- name: InsertAMPInvoiceHTLC :exec
-INSERT INTO amp_invoice_htlcs (
-    set_id, htlc_id, root_share, child_index, hash, preimage
+-- name: InsertAMPSubInvoiceHTLC :exec
+INSERT INTO amp_sub_invoice_htlcs (
+    invoice_id, set_id, htlc_id, root_share, child_index, hash, preimage
 ) VALUES (
-    $1, $2, $3, $4, $5, $6
+    $1, $2, $3, $4, $5, $6, $7
 );
 
--- name: GetAMPInvoiceHTLCsBySetID :many
+-- name: FetchAMPSubInvoices :many
 SELECT *
-FROM amp_invoice_htlcs
-WHERE set_id = $1;
+FROM amp_sub_invoices
+WHERE invoice_id = $1 
+AND (
+    set_id = sqlc.narg('set_id') OR 
+    sqlc.narg('set_id') IS NULL
+);
 
--- name: GetAMPInvoiceHTLCsByInvoiceID :many
-SELECT *
-FROM amp_invoice_htlcs
-WHERE invoice_id = $1;
+-- name: FetchAMPSubInvoiceHTLCs :many
+SELECT 
+    amp.set_id, amp.root_share, amp.child_index, amp.hash, amp.preimage, 
+    invoice_htlcs.*
+FROM amp_sub_invoice_htlcs amp
+INNER JOIN invoice_htlcs ON amp.htlc_id = invoice_htlcs.id
+WHERE amp.invoice_id = $1
+AND (
+    set_id = sqlc.narg('set_id') OR 
+    sqlc.narg('set_id') IS NULL
+);
 
--- name: GetSetIDHTLCsCustomRecords :many
-SELECT ihcr.htlc_id, key, value
-FROM amp_invoice_htlcs aih JOIN invoice_htlc_custom_records ihcr ON aih.id=ihcr.htlc_id 
-WHERE aih.set_id = $1;
-
--- name: UpdateAMPInvoiceHTLC :exec
-UPDATE amp_invoice_htlcs
-SET preimage = $1
-WHERE htlc_id = $2;
-
--- name: DeleteAMPHTLCCustomRecords :exec
-WITH htlc_ids AS (
-    SELECT htlc_id
-    FROM amp_invoice_htlcs 
-    WHERE invoice_id = $1
-)
-DELETE
-FROM invoice_htlc_custom_records
-WHERE htlc_id IN (SELECT id FROM htlc_ids);
-
--- name: DeleteAMPHTLCs :exec
-DELETE 
-FROM amp_invoice_htlcs  
-WHERE invoice_id = $1;
-
--- name: DeleteAMPInvoiceHTLC :exec
-DELETE 
-FROM amp_invoice_htlcs
-WHERE set_id = $1;
+-- name: FetchSettledAMPSubInvoices :many
+SELECT 
+    a.set_id, 
+    a.settle_index as amp_settle_index, 
+    a.settled_at as amp_settled_at,
+    i.*
+FROM amp_sub_invoices a
+INNER JOIN invoices i ON a.invoice_id = i.id
+WHERE (
+    a.settle_index >= sqlc.narg('settle_index_get') OR
+    sqlc.narg('settle_index_get') IS NULL
+) AND (
+    a.settle_index <= sqlc.narg('settle_index_let') OR
+    sqlc.narg('settle_index_let') IS NULL
+);
 
+-- name: UpdateAMPSubInvoiceHTLCPreimage :execresult
+UPDATE amp_sub_invoice_htlcs AS a
+SET preimage = $4
+WHERE a.invoice_id = $1 AND a.set_id = $2 AND a.htlc_id = (
+    SELECT id FROM invoice_htlcs AS i WHERE i.htlc_id = $3
+);
diff --git a/sqldb/sqlc/queries/invoice_events.sql b/sqldb/sqlc/queries/invoice_events.sql
index 4216a2513..4192c466b 100644
--- a/sqldb/sqlc/queries/invoice_events.sql
+++ b/sqldb/sqlc/queries/invoice_events.sql
@@ -1,35 +1,41 @@
--- name: InsertInvoiceEvent :exec
+-- name: OnInvoiceCreated :exec
 INSERT INTO invoice_events (
-    created_at, invoice_id, htlc_id, set_id, event_type, event_metadata
+    added_at, event_type, invoice_id
 ) VALUES (
-    $1, $2, $3, $4, $5, $6
+    $1, 0, $2
 );
 
--- name: SelectInvoiceEvents :many
-SELECT *
-FROM invoice_events
-WHERE (
-    invoice_id = sqlc.narg('invoice_id') OR 
-    sqlc.narg('invoice_id') IS NULL
-) AND (
-    htlc_id = sqlc.narg('htlc_id') OR 
-    sqlc.narg('htlc_id') IS NULL
-) AND (
-    set_id = sqlc.narg('set_id') OR 
-    sqlc.narg('set_id') IS NULL
-) AND (
-    event_type = sqlc.narg('event_type') OR 
-    sqlc.narg('event_type') IS NULL
-) AND (
-    created_at >= sqlc.narg('created_after') OR 
-    sqlc.narg('created_after') IS NULL
-) AND (
-    created_at <= sqlc.narg('created_before') OR 
-    sqlc.narg('created_before') IS NULL
-) 
-LIMIT @num_limit OFFSET @num_offset;
+-- name: OnInvoiceCanceled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id
+) VALUES (
+    $1, 1, $2
+);
 
--- name: DeleteInvoiceEvents :exec
-DELETE
-FROM invoice_events
-WHERE invoice_id = $1;
+-- name: OnInvoiceSettled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id
+) VALUES (
+    $1, 2, $2
+);
+
+-- name: OnAMPSubInvoiceCreated :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id, set_id
+) VALUES (
+    $1, 3, $2, $3
+);
+
+-- name: OnAMPSubInvoiceCanceled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id, set_id
+) VALUES (
+    $1, 4, $2, $3
+);
+
+-- name: OnAMPSubInvoiceSettled :exec
+INSERT INTO invoice_events (
+    added_at, event_type, invoice_id, set_id
+) VALUES (
+    $1, 5, $2, $3
+);
diff --git a/sqldb/sqlc/queries/invoices.sql b/sqldb/sqlc/queries/invoices.sql
index 335929e05..c36976a25 100644
--- a/sqldb/sqlc/queries/invoices.sql
+++ b/sqldb/sqlc/queries/invoices.sql
@@ -1,10 +1,10 @@
 -- name: InsertInvoice :one
 INSERT INTO invoices (
     hash, preimage, memo, amount_msat, cltv_delta, expiry, payment_addr, 
-    payment_request, state, amount_paid_msat, is_amp, is_hodl, is_keysend, 
-    created_at
+    payment_request, payment_request_hash, state, amount_paid_msat, is_amp,
+    is_hodl, is_keysend, created_at
 ) VALUES (
-    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14
+    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
 ) RETURNING id;
 
 -- name: InsertInvoiceFeature :exec
@@ -19,35 +19,36 @@ SELECT *
 FROM invoice_features
 WHERE invoice_id = $1;
 
--- name: DeleteInvoiceFeatures :exec
-DELETE 
-FROM invoice_features
-WHERE invoice_id = $1;
-
 -- This method may return more than one invoice if filter using multiple fields
 -- from different invoices. It is the caller's responsibility to ensure that 
 -- we bubble up an error in those cases.
 
 -- name: GetInvoice :many
-SELECT *
-FROM invoices
+SELECT i.*
+FROM invoices i
+LEFT JOIN amp_sub_invoices a on i.id = a.invoice_id
 WHERE (
-    id = sqlc.narg('add_index') OR 
+    i.id = sqlc.narg('add_index') OR 
     sqlc.narg('add_index') IS NULL
 ) AND (
-    hash = sqlc.narg('hash') OR 
+    i.hash = sqlc.narg('hash') OR 
     sqlc.narg('hash') IS NULL
 ) AND (
-    preimage = sqlc.narg('preimage') OR 
+    i.preimage = sqlc.narg('preimage') OR 
     sqlc.narg('preimage') IS NULL
 ) AND (
-    payment_addr = sqlc.narg('payment_addr') OR 
+    i.payment_addr = sqlc.narg('payment_addr') OR 
     sqlc.narg('payment_addr') IS NULL
+) AND (
+    a.set_id = sqlc.narg('set_id') OR
+    sqlc.narg('set_id') IS NULL
 )
+GROUP BY i.id
 LIMIT 2;
 
 -- name: FilterInvoices :many
-SELECT * 
+SELECT
+    invoices.*
 FROM invoices
 WHERE (
     id >= sqlc.narg('add_index_get') OR 
@@ -55,6 +56,12 @@ WHERE (
 ) AND (
     id <= sqlc.narg('add_index_let') OR 
     sqlc.narg('add_index_let') IS NULL
+) AND (
+    settle_index >= sqlc.narg('settle_index_get') OR
+    sqlc.narg('settle_index_get') IS NULL
+) AND (
+    settle_index <= sqlc.narg('settle_index_let') OR
+    sqlc.narg('settle_index_let') IS NULL
 ) AND (
     state = sqlc.narg('state') OR 
     sqlc.narg('state') IS NULL
@@ -81,12 +88,25 @@ ORDER BY
     END DESC
 LIMIT @num_limit OFFSET @num_offset;
 
--- name: UpdateInvoice :exec 
-UPDATE invoices 
-SET preimage=$2, state=$3, amount_paid_msat=$4
-WHERE id=$1;
+-- name: UpdateInvoiceState :execresult
+UPDATE invoices
+SET state = $2,
+    preimage = COALESCE(preimage, $3),
+    settle_index = COALESCE(settle_index, $4),
+    settled_at = COALESCE(settled_at, $5)
+WHERE id = $1;
 
--- name: DeleteInvoice :exec
+-- name: UpdateInvoiceAmountPaid :execresult
+UPDATE invoices
+SET amount_paid_msat = $2
+WHERE id = $1;
+
+-- name: NextInvoiceSettleIndex :one
+UPDATE invoice_sequences SET current_value = current_value + 1
+WHERE name = 'settle_index'
+RETURNING current_value;
+
+-- name: DeleteInvoice :execresult
 DELETE 
 FROM invoices 
 WHERE (
@@ -96,20 +116,25 @@ WHERE (
     hash = sqlc.narg('hash') OR 
     sqlc.narg('hash') IS NULL
 ) AND (
-    preimage = sqlc.narg('preimage') OR 
-    sqlc.narg('preimage') IS NULL
+    settle_index = sqlc.narg('settle_index') OR 
+    sqlc.narg('settle_index') IS NULL
 ) AND (
     payment_addr = sqlc.narg('payment_addr') OR
     sqlc.narg('payment_addr') IS NULL
 );
 
--- name: InsertInvoiceHTLC :exec
+-- name: DeleteCanceledInvoices :execresult
+DELETE
+FROM invoices
+WHERE state = 2;
+
+-- name: InsertInvoiceHTLC :one
 INSERT INTO invoice_htlcs (
     htlc_id, chan_id, amount_msat, total_mpp_msat, accept_height, accept_time,
     expiry_height, state, resolve_time, invoice_id
 ) VALUES (
     $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
-);
+) RETURNING id;
 
 -- name: GetInvoiceHTLCs :many
 SELECT *
@@ -118,25 +143,14 @@ WHERE invoice_id = $1;
 
 -- name: UpdateInvoiceHTLC :exec
 UPDATE invoice_htlcs 
-SET state=$2, resolve_time=$3
-WHERE id = $1;
+SET state=$4, resolve_time=$5
+WHERE htlc_id = $1 AND chan_id = $2 AND invoice_id = $3;
 
 -- name: UpdateInvoiceHTLCs :exec
 UPDATE invoice_htlcs 
 SET state=$2, resolve_time=$3
 WHERE invoice_id = $1 AND resolve_time IS NULL;
 
-
--- name: DeleteInvoiceHTLC :exec
-DELETE
-FROM invoice_htlcs
-WHERE htlc_id = $1;
-
--- name: DeleteInvoiceHTLCs :exec
-DELETE
-FROM invoice_htlcs
-WHERE invoice_id = $1;
-
 -- name: InsertInvoiceHTLCCustomRecord :exec
 INSERT INTO invoice_htlc_custom_records (
     key, value, htlc_id 
@@ -148,49 +162,3 @@ INSERT INTO invoice_htlc_custom_records (
 SELECT ihcr.htlc_id, key, value
 FROM invoice_htlcs ih JOIN invoice_htlc_custom_records ihcr ON ih.id=ihcr.htlc_id 
 WHERE ih.invoice_id = $1;
-
--- name: DeleteInvoiceHTLCCustomRecords :exec
-WITH htlc_ids AS (
-    SELECT ih.id
-    FROM invoice_htlcs ih JOIN invoice_htlc_custom_records ihcr ON ih.id=ihcr.htlc_id 
-    WHERE ih.invoice_id = $1
-)
-DELETE
-FROM invoice_htlc_custom_records
-WHERE htlc_id IN (SELECT id FROM htlc_ids);
-
--- name: InsertInvoicePayment :one
-INSERT INTO invoice_payments (
-    invoice_id, amount_paid_msat, settled_at 
-) VALUES (
-    $1, $2, $3
-) RETURNING id;
-
--- name: GetInvoicePayments :many
-SELECT *
-FROM invoice_payments
-WHERE invoice_id = $1;
-
--- name: FilterInvoicePayments :many
-SELECT  
-    ip.id AS settle_index, ip.amount_paid_msat, ip.settled_at AS settle_date, 
-    i.* 
-FROM invoice_payments ip JOIN invoices i ON ip.invoice_id = i.id
-WHERE (
-    ip.id >= sqlc.narg('settle_index_get') OR 
-    sqlc.narg('settle_index_get') IS NULL
-) AND (
-    ip.settled_at >= sqlc.narg('settled_after') OR 
-    sqlc.narg('settled_after') IS NULL
-)
-ORDER BY
-    CASE
-        WHEN sqlc.narg('reverse') = FALSE THEN ip.id  
-        ELSE NULL
-    END ASC,
-    CASE
-        WHEN sqlc.narg('reverse') = TRUE THEN ip.id  
-        ELSE NULL
-    END DESC
-LIMIT @num_limit OFFSET @num_offset;
-