24081604890

Committed 07 Apr 2026 12:35PM UTC coverage: 62.163% (+0.06%) from 62.104%

Build # 24081604890

Build Type

Pull #10721

github

Committed by

web-flow

Commit Message

Merge 95e447f23 into 167f03bb3

Pull Request Pull Request #10721: paymentsdb: restore sql payment store parity with kv

Coverage Stats

0 of 72 new or added lines in 3 files covered. (0.0%)

39 existing lines in 14 files now uncovered.

142843 of 229786 relevant lines covered (62.16%)

19225.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/sqldb/sqlc/payments.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: payments.sql

package sqlc

import (
        "context"
        "database/sql"
        "strings"
        "time"
)

const countPayments = `-- name: CountPayments :one
SELECT COUNT(*) FROM payments
`

func (q *Queries) CountPayments(ctx context.Context) (int64, error) {
        row := q.db.QueryRowContext(ctx, countPayments)
        var count int64
        err := row.Scan(&count)
        return count, err
}

const deleteFailedAttempts = `-- name: DeleteFailedAttempts :exec
DELETE FROM payment_htlc_attempts
WHERE payment_id = $1
AND EXISTS (
    SELECT 1 FROM payment_htlc_attempt_resolutions hr
    WHERE hr.attempt_index = payment_htlc_attempts.attempt_index
    AND hr.resolution_type = 2
)
`

// Delete all failed HTLC attempts for the given payment. Resolution type 2
// indicates a failed attempt. Uses EXISTS to scope the resolution lookup to
// only this payment's attempts, avoiding an O(N) scan of all failed
// resolutions across all payments.
func (q *Queries) DeleteFailedAttempts(ctx context.Context, paymentID int64) error {
        _, err := q.db.ExecContext(ctx, deleteFailedAttempts, paymentID)
        return err
}

const deletePayment = `-- name: DeletePayment :exec
DELETE FROM payments WHERE id = $1
`

func (q *Queries) DeletePayment(ctx context.Context, id int64) error {
        _, err := q.db.ExecContext(ctx, deletePayment, id)
        return err
}

const failAttempt = `-- name: FailAttempt :exec
INSERT INTO payment_htlc_attempt_resolutions (
    attempt_index,
    resolution_time,
    resolution_type,
    failure_source_index,
    htlc_fail_reason,
    failure_msg
)
VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6
)
`

type FailAttemptParams struct {
        AttemptIndex       int64
        ResolutionTime     time.Time
        ResolutionType     int32
        FailureSourceIndex sql.NullInt32
        HtlcFailReason     sql.NullInt32
        FailureMsg         []byte
}

func (q *Queries) FailAttempt(ctx context.Context, arg FailAttemptParams) error {
        _, err := q.db.ExecContext(ctx, failAttempt,
                arg.AttemptIndex,
                arg.ResolutionTime,
                arg.ResolutionType,
                arg.FailureSourceIndex,
                arg.HtlcFailReason,
                arg.FailureMsg,
        )
        return err
}

const failPayment = `-- name: FailPayment :execresult
UPDATE payments SET fail_reason = $1 WHERE payment_identifier = $2
`

type FailPaymentParams struct {
        FailReason        sql.NullInt32
        PaymentIdentifier []byte
}

func (q *Queries) FailPayment(ctx context.Context, arg FailPaymentParams) (sql.Result, error) {
        return q.db.ExecContext(ctx, failPayment, arg.FailReason, arg.PaymentIdentifier)
}

const fetchHopLevelCustomRecords = `-- name: FetchHopLevelCustomRecords :many
SELECT
    l.id,
    l.hop_id,
    l.key,
    l.value
FROM payment_hop_custom_records l
WHERE l.hop_id IN (/*SLICE:hop_ids*/?)
ORDER BY l.hop_id ASC, l.key ASC
`

func (q *Queries) FetchHopLevelCustomRecords(ctx context.Context, hopIds []int64) ([]PaymentHopCustomRecord, error) {
        query := fetchHopLevelCustomRecords
        var queryParams []interface{}
        if len(hopIds) > 0 {
                for _, v := range hopIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:hop_ids*/?", makeQueryParams(len(queryParams), len(hopIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:hop_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentHopCustomRecord
        for rows.Next() {
                var i PaymentHopCustomRecord
                if err := rows.Scan(
                        &i.ID,
                        &i.HopID,
                        &i.Key,
                        &i.Value,
                ); 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 fetchHopsForAttempts = `-- name: FetchHopsForAttempts :many
SELECT
    h.id,
    h.htlc_attempt_index,
    h.hop_index,
    h.pub_key,
    h.scid,
    h.outgoing_time_lock,
    h.amt_to_forward,
    h.meta_data,
    m.payment_addr AS mpp_payment_addr,
    m.total_msat AS mpp_total_msat,
    a.root_share AS amp_root_share,
    a.set_id AS amp_set_id,
    a.child_index AS amp_child_index,
    b.encrypted_data,
    b.blinding_point,
    b.blinded_path_total_amt
FROM payment_route_hops h
LEFT JOIN payment_route_hop_mpp m ON m.hop_id = h.id
LEFT JOIN payment_route_hop_amp a ON a.hop_id = h.id
LEFT JOIN payment_route_hop_blinded b ON b.hop_id = h.id
WHERE h.htlc_attempt_index IN (/*SLICE:htlc_attempt_indices*/?)
ORDER BY h.htlc_attempt_index ASC, h.hop_index ASC
`

type FetchHopsForAttemptsRow struct {
        ID                  int64
        HtlcAttemptIndex    int64
        HopIndex            int32
        PubKey              []byte
        Scid                string
        OutgoingTimeLock    int32
        AmtToForward        int64
        MetaData            []byte
        MppPaymentAddr      []byte
        MppTotalMsat        sql.NullInt64
        AmpRootShare        []byte
        AmpSetID            []byte
        AmpChildIndex       sql.NullInt32
        EncryptedData       []byte
        BlindingPoint       []byte
        BlindedPathTotalAmt sql.NullInt64
}

func (q *Queries) FetchHopsForAttempts(ctx context.Context, htlcAttemptIndices []int64) ([]FetchHopsForAttemptsRow, error) {
        query := fetchHopsForAttempts
        var queryParams []interface{}
        if len(htlcAttemptIndices) > 0 {
                for _, v := range htlcAttemptIndices {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:htlc_attempt_indices*/?", makeQueryParams(len(queryParams), len(htlcAttemptIndices)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:htlc_attempt_indices*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchHopsForAttemptsRow
        for rows.Next() {
                var i FetchHopsForAttemptsRow
                if err := rows.Scan(
                        &i.ID,
                        &i.HtlcAttemptIndex,
                        &i.HopIndex,
                        &i.PubKey,
                        &i.Scid,
                        &i.OutgoingTimeLock,
                        &i.AmtToForward,
                        &i.MetaData,
                        &i.MppPaymentAddr,
                        &i.MppTotalMsat,
                        &i.AmpRootShare,
                        &i.AmpSetID,
                        &i.AmpChildIndex,
                        &i.EncryptedData,
                        &i.BlindingPoint,
                        &i.BlindedPathTotalAmt,
                ); 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 fetchHtlcAttemptResolutionsForPayments = `-- name: FetchHtlcAttemptResolutionsForPayments :many
SELECT
    ha.payment_id,
    hr.resolution_type
FROM payment_htlc_attempts ha
LEFT JOIN payment_htlc_attempt_resolutions hr ON hr.attempt_index = ha.attempt_index
WHERE ha.payment_id IN (/*SLICE:payment_ids*/?)
`

type FetchHtlcAttemptResolutionsForPaymentsRow struct {
        PaymentID      int64
        ResolutionType sql.NullInt32
}

// Batch query to fetch only HTLC resolution status for multiple payments.
// We don't need to order by payment_id and attempt_time because we will
// group the resolutions by payment_id in the background.
func (q *Queries) FetchHtlcAttemptResolutionsForPayments(ctx context.Context, paymentIds []int64) ([]FetchHtlcAttemptResolutionsForPaymentsRow, error) {
        query := fetchHtlcAttemptResolutionsForPayments
        var queryParams []interface{}
        if len(paymentIds) > 0 {
                for _, v := range paymentIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", makeQueryParams(len(queryParams), len(paymentIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchHtlcAttemptResolutionsForPaymentsRow
        for rows.Next() {
                var i FetchHtlcAttemptResolutionsForPaymentsRow
                if err := rows.Scan(&i.PaymentID, &i.ResolutionType); 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 fetchHtlcAttemptsForPayments = `-- name: FetchHtlcAttemptsForPayments :many
SELECT
    ha.id,
    ha.attempt_index,
    ha.payment_id,
    ha.session_key,
    ha.attempt_time,
    ha.payment_hash,
    ha.first_hop_amount_msat,
    ha.route_total_time_lock,
    ha.route_total_amount,
    ha.route_source_key,
    hr.resolution_type,
    hr.resolution_time,
    hr.failure_source_index,
    hr.htlc_fail_reason,
    hr.failure_msg,
    hr.settle_preimage
FROM payment_htlc_attempts ha
LEFT JOIN payment_htlc_attempt_resolutions hr ON hr.attempt_index = ha.attempt_index
WHERE ha.payment_id IN (/*SLICE:payment_ids*/?)
ORDER BY ha.payment_id ASC, ha.attempt_time ASC
`

type FetchHtlcAttemptsForPaymentsRow struct {
        ID                 int64
        AttemptIndex       int64
        PaymentID          int64
        SessionKey         []byte
        AttemptTime        time.Time
        PaymentHash        []byte
        FirstHopAmountMsat int64
        RouteTotalTimeLock int32
        RouteTotalAmount   int64
        RouteSourceKey     []byte
        ResolutionType     sql.NullInt32
        ResolutionTime     sql.NullTime
        FailureSourceIndex sql.NullInt32
        HtlcFailReason     sql.NullInt32
        FailureMsg         []byte
        SettlePreimage     []byte
}

func (q *Queries) FetchHtlcAttemptsForPayments(ctx context.Context, paymentIds []int64) ([]FetchHtlcAttemptsForPaymentsRow, error) {
        query := fetchHtlcAttemptsForPayments
        var queryParams []interface{}
        if len(paymentIds) > 0 {
                for _, v := range paymentIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", makeQueryParams(len(queryParams), len(paymentIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchHtlcAttemptsForPaymentsRow
        for rows.Next() {
                var i FetchHtlcAttemptsForPaymentsRow
                if err := rows.Scan(
                        &i.ID,
                        &i.AttemptIndex,
                        &i.PaymentID,
                        &i.SessionKey,
                        &i.AttemptTime,
                        &i.PaymentHash,
                        &i.FirstHopAmountMsat,
                        &i.RouteTotalTimeLock,
                        &i.RouteTotalAmount,
                        &i.RouteSourceKey,
                        &i.ResolutionType,
                        &i.ResolutionTime,
                        &i.FailureSourceIndex,
                        &i.HtlcFailReason,
                        &i.FailureMsg,
                        &i.SettlePreimage,
                ); 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 fetchNonTerminalPayments = `-- name: FetchNonTerminalPayments :many
WITH non_terminal_ids AS (
    SELECT ha.payment_id AS id
    FROM payment_htlc_attempts ha
    WHERE NOT EXISTS (
        SELECT 1 FROM payment_htlc_attempt_resolutions hr
        WHERE hr.attempt_index = ha.attempt_index
    )

    UNION

    SELECT p.id
    FROM payments p
    WHERE p.fail_reason IS NULL
    AND NOT EXISTS (
        SELECT 1 FROM payment_htlc_attempts ha
        WHERE ha.payment_id = p.id
    )

    UNION

    SELECT DISTINCT ha.payment_id AS id
    FROM payment_htlc_attempts ha
    JOIN payment_htlc_attempt_resolutions hr
        ON hr.attempt_index = ha.attempt_index
    JOIN payments p
        ON p.id = ha.payment_id
    WHERE p.fail_reason IS NULL
    AND hr.resolution_type = 2
    AND NOT EXISTS (
        SELECT 1 FROM payment_htlc_attempts ha2
        JOIN payment_htlc_attempt_resolutions hr2
            ON hr2.attempt_index = ha2.attempt_index
        WHERE ha2.payment_id = ha.payment_id
        AND hr2.resolution_type = 1
    )
)
SELECT
    p.id,
    p.amount_msat,
    p.created_at,
    p.payment_identifier,
    p.fail_reason,
    pi.intent_type,
    pi.intent_payload
FROM non_terminal_ids n
JOIN payments p
    ON p.id = n.id
LEFT JOIN payment_intents pi
    ON pi.payment_id = p.id
WHERE p.id > $1
ORDER BY p.id ASC
LIMIT $2
`

type FetchNonTerminalPaymentsParams struct {
        ID    int64
        Limit int32
}

type FetchNonTerminalPaymentsRow struct {
        ID                int64
        AmountMsat        int64
        CreatedAt         time.Time
        PaymentIdentifier []byte
        FailReason        sql.NullInt32
        IntentType        sql.NullInt16
        IntentPayload     []byte
}

// Fetch all non-terminal payments using pagination. A payment is
// non-terminal if it has an unresolved attempt, or if it has not been
// permanently failed and has no settled attempt yet.
func (q *Queries) FetchNonTerminalPayments(ctx context.Context, arg FetchNonTerminalPaymentsParams) ([]FetchNonTerminalPaymentsRow, error) {
        rows, err := q.db.QueryContext(ctx, fetchNonTerminalPayments, arg.ID, arg.Limit)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchNonTerminalPaymentsRow
        for rows.Next() {
                var i FetchNonTerminalPaymentsRow
                if err := rows.Scan(
                        &i.ID,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.PaymentIdentifier,
                        &i.FailReason,
                        &i.IntentType,
                        &i.IntentPayload,
                ); 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 fetchPayment = `-- name: FetchPayment :one
SELECT
    p.id, p.amount_msat, p.created_at, p.payment_identifier, p.fail_reason,
    i.intent_type AS "intent_type",
    i.intent_payload AS "intent_payload"
FROM payments p
LEFT JOIN payment_intents i ON i.payment_id = p.id
WHERE p.payment_identifier = $1
`

type FetchPaymentRow struct {
        Payment       Payment
        IntentType    sql.NullInt16
        IntentPayload []byte
}

func (q *Queries) FetchPayment(ctx context.Context, paymentIdentifier []byte) (FetchPaymentRow, error) {
        row := q.db.QueryRowContext(ctx, fetchPayment, paymentIdentifier)
        var i FetchPaymentRow
        err := row.Scan(
                &i.Payment.ID,
                &i.Payment.AmountMsat,
                &i.Payment.CreatedAt,
                &i.Payment.PaymentIdentifier,
                &i.Payment.FailReason,
                &i.IntentType,
                &i.IntentPayload,
        )
        return i, err
}

const fetchPaymentDuplicates = `-- name: FetchPaymentDuplicates :many
SELECT
    id,
    payment_id,
    amount_msat,
    created_at,
    fail_reason,
    settle_preimage,
    settle_time
FROM payment_duplicates
WHERE payment_id = $1
ORDER BY id ASC
`

// Fetch all duplicate payment records from the payment_duplicates table for
// a given payment ID.
func (q *Queries) FetchPaymentDuplicates(ctx context.Context, paymentID int64) ([]PaymentDuplicate, error) {
        rows, err := q.db.QueryContext(ctx, fetchPaymentDuplicates, paymentID)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentDuplicate
        for rows.Next() {
                var i PaymentDuplicate
                if err := rows.Scan(
                        &i.ID,
                        &i.PaymentID,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.FailReason,
                        &i.SettlePreimage,
                        &i.SettleTime,
                ); 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 fetchPaymentLevelFirstHopCustomRecords = `-- name: FetchPaymentLevelFirstHopCustomRecords :many
SELECT
    l.id,
    l.payment_id,
    l.key,
    l.value
FROM payment_first_hop_custom_records l
WHERE l.payment_id IN (/*SLICE:payment_ids*/?)
ORDER BY l.payment_id ASC, l.key ASC
`

func (q *Queries) FetchPaymentLevelFirstHopCustomRecords(ctx context.Context, paymentIds []int64) ([]PaymentFirstHopCustomRecord, error) {
        query := fetchPaymentLevelFirstHopCustomRecords
        var queryParams []interface{}
        if len(paymentIds) > 0 {
                for _, v := range paymentIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", makeQueryParams(len(queryParams), len(paymentIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentFirstHopCustomRecord
        for rows.Next() {
                var i PaymentFirstHopCustomRecord
                if err := rows.Scan(
                        &i.ID,
                        &i.PaymentID,
                        &i.Key,
                        &i.Value,
                ); 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 fetchPaymentsByIDs = `-- name: FetchPaymentsByIDs :many
SELECT
    p.id,
    p.amount_msat,
    p.created_at,
    p.payment_identifier,
    p.fail_reason,
    pi.intent_type,
    pi.intent_payload
FROM payments p
LEFT JOIN payment_intents pi ON pi.payment_id = p.id
WHERE p.id IN (/*SLICE:payment_ids*/?)
ORDER BY p.id ASC
`

type FetchPaymentsByIDsRow struct {
        ID                int64
        AmountMsat        int64
        CreatedAt         time.Time
        PaymentIdentifier []byte
        FailReason        sql.NullInt32
        IntentType        sql.NullInt16
        IntentPayload     []byte
}

// Batch fetch payment and intent data for a set of payment IDs.
// Used to avoid fetching redundant payment data when processing multiple
// attempts for the same payment.
func (q *Queries) FetchPaymentsByIDs(ctx context.Context, paymentIds []int64) ([]FetchPaymentsByIDsRow, error) {
        query := fetchPaymentsByIDs
        var queryParams []interface{}
        if len(paymentIds) > 0 {
                for _, v := range paymentIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", makeQueryParams(len(queryParams), len(paymentIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchPaymentsByIDsRow
        for rows.Next() {
                var i FetchPaymentsByIDsRow
                if err := rows.Scan(
                        &i.ID,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.PaymentIdentifier,
                        &i.FailReason,
                        &i.IntentType,
                        &i.IntentPayload,
                ); 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 fetchPaymentsByIDsMig = `-- name: FetchPaymentsByIDsMig :many
SELECT
    p.id,
    p.amount_msat,
    p.created_at,
    p.payment_identifier,
    p.fail_reason,
    COUNT(ha.id) AS htlc_attempt_count
FROM payments p
LEFT JOIN payment_htlc_attempts ha ON ha.payment_id = p.id
WHERE p.id IN (/*SLICE:payment_ids*/?)
GROUP BY p.id, p.amount_msat, p.created_at, p.payment_identifier, p.fail_reason
ORDER BY p.id ASC
`

type FetchPaymentsByIDsMigRow struct {
        ID                int64
        AmountMsat        int64
        CreatedAt         time.Time
        PaymentIdentifier []byte
        FailReason        sql.NullInt32
        HtlcAttemptCount  int64
}

// Migration-specific batch fetch that returns payment data along with HTLC
// attempt counts for structural validation during KV to SQL migration.
func (q *Queries) FetchPaymentsByIDsMig(ctx context.Context, paymentIds []int64) ([]FetchPaymentsByIDsMigRow, error) {
        query := fetchPaymentsByIDsMig
        var queryParams []interface{}
        if len(paymentIds) > 0 {
                for _, v := range paymentIds {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", makeQueryParams(len(queryParams), len(paymentIds)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_ids*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FetchPaymentsByIDsMigRow
        for rows.Next() {
                var i FetchPaymentsByIDsMigRow
                if err := rows.Scan(
                        &i.ID,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.PaymentIdentifier,
                        &i.FailReason,
                        &i.HtlcAttemptCount,
                ); 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 fetchRouteLevelFirstHopCustomRecords = `-- name: FetchRouteLevelFirstHopCustomRecords :many
SELECT
    l.id,
    l.htlc_attempt_index,
    l.key,
    l.value
FROM payment_attempt_first_hop_custom_records l
WHERE l.htlc_attempt_index IN (/*SLICE:htlc_attempt_indices*/?)
ORDER BY l.htlc_attempt_index ASC, l.key ASC
`

func (q *Queries) FetchRouteLevelFirstHopCustomRecords(ctx context.Context, htlcAttemptIndices []int64) ([]PaymentAttemptFirstHopCustomRecord, error) {
        query := fetchRouteLevelFirstHopCustomRecords
        var queryParams []interface{}
        if len(htlcAttemptIndices) > 0 {
                for _, v := range htlcAttemptIndices {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:htlc_attempt_indices*/?", makeQueryParams(len(queryParams), len(htlcAttemptIndices)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:htlc_attempt_indices*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentAttemptFirstHopCustomRecord
        for rows.Next() {
                var i PaymentAttemptFirstHopCustomRecord
                if err := rows.Scan(
                        &i.ID,
                        &i.HtlcAttemptIndex,
                        &i.Key,
                        &i.Value,
                ); 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 filterPayments = `-- name: FilterPayments :many
/* ─────────────────────────────────────────────
   fetch queries
   ─────────────────────────────────────────────
*/

SELECT
    p.id, p.amount_msat, p.created_at, p.payment_identifier, p.fail_reason,
    i.intent_type AS "intent_type",
    i.intent_payload AS "intent_payload"
FROM payments p
LEFT JOIN payment_intents i ON i.payment_id = p.id
WHERE p.id > COALESCE($1, -1)
  AND p.id < COALESCE($2, 9223372036854775807)
  -- NOTE: We use non-nullable time params with Go-side defaults instead of
  -- COALESCE, because COALESCE with text fallback causes type mismatch on
  -- Postgres (timestamp vs text), and OR-based optional filters can prevent
  -- the planner from using the created_at index.
  AND p.created_at >= $3
  AND p.created_at <= $4
  AND (
      i.intent_type = $5 OR
      $5 IS NULL OR i.intent_type IS NULL
  )
ORDER BY p.id ASC
LIMIT $6
`

type FilterPaymentsParams struct {
        IndexOffsetGet sql.NullInt64
        IndexOffsetLet sql.NullInt64
        CreatedAfter   time.Time
        CreatedBefore  time.Time
        IntentType     sql.NullInt16
        NumLimit       int32
}

type FilterPaymentsRow struct {
        Payment       Payment
        IntentType    sql.NullInt16
        IntentPayload []byte
}

func (q *Queries) FilterPayments(ctx context.Context, arg FilterPaymentsParams) ([]FilterPaymentsRow, error) {
        rows, err := q.db.QueryContext(ctx, filterPayments,
                arg.IndexOffsetGet,
                arg.IndexOffsetLet,
                arg.CreatedAfter,
                arg.CreatedBefore,
                arg.IntentType,
                arg.NumLimit,
        )
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FilterPaymentsRow
        for rows.Next() {
                var i FilterPaymentsRow
                if err := rows.Scan(
                        &i.Payment.ID,
                        &i.Payment.AmountMsat,
                        &i.Payment.CreatedAt,
                        &i.Payment.PaymentIdentifier,
                        &i.Payment.FailReason,
                        &i.IntentType,
                        &i.IntentPayload,
                ); 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 filterPaymentsDesc = `-- name: FilterPaymentsDesc :many
SELECT
    p.id, p.amount_msat, p.created_at, p.payment_identifier, p.fail_reason,
    i.intent_type AS "intent_type",
    i.intent_payload AS "intent_payload"
FROM payments p
LEFT JOIN payment_intents i ON i.payment_id = p.id
WHERE p.id > COALESCE($1, -1)
  AND p.id < COALESCE($2, 9223372036854775807)
  -- NOTE: We use non-nullable time params with Go-side defaults instead of
  -- COALESCE, because COALESCE with text fallback causes type mismatch on
  -- Postgres (timestamp vs text), and OR-based optional filters can prevent
  -- the planner from using the created_at index.
  AND p.created_at >= $3
  AND p.created_at <= $4
  AND (
      i.intent_type = $5 OR
      $5 IS NULL OR i.intent_type IS NULL
  )
ORDER BY p.id DESC
LIMIT $6
`

type FilterPaymentsDescParams struct {
        IndexOffsetGet sql.NullInt64
        IndexOffsetLet sql.NullInt64
        CreatedAfter   time.Time
        CreatedBefore  time.Time
        IntentType     sql.NullInt16
        NumLimit       int32
}

type FilterPaymentsDescRow struct {
        Payment       Payment
        IntentType    sql.NullInt16
        IntentPayload []byte
}

func (q *Queries) FilterPaymentsDesc(ctx context.Context, arg FilterPaymentsDescParams) ([]FilterPaymentsDescRow, error) {
        rows, err := q.db.QueryContext(ctx, filterPaymentsDesc,
                arg.IndexOffsetGet,
                arg.IndexOffsetLet,
                arg.CreatedAfter,
                arg.CreatedBefore,
                arg.IntentType,
                arg.NumLimit,
        )
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []FilterPaymentsDescRow
        for rows.Next() {
                var i FilterPaymentsDescRow
                if err := rows.Scan(
                        &i.Payment.ID,
                        &i.Payment.AmountMsat,
                        &i.Payment.CreatedAt,
                        &i.Payment.PaymentIdentifier,
                        &i.Payment.FailReason,
                        &i.IntentType,
                        &i.IntentPayload,
                ); 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 insertHtlcAttempt = `-- name: InsertHtlcAttempt :one
INSERT INTO payment_htlc_attempts (
    payment_id,
    attempt_index,
    session_key,
    attempt_time,
    payment_hash,
    first_hop_amount_msat,
    route_total_time_lock,
    route_total_amount,
    route_source_key)
VALUES (
    $1,
    $2,
    $3,
    $4,
    $5, 
    $6, 
    $7, 
    $8, 
    $9)
RETURNING id
`

type InsertHtlcAttemptParams struct {
        PaymentID          int64
        AttemptIndex       int64
        SessionKey         []byte
        AttemptTime        time.Time
        PaymentHash        []byte
        FirstHopAmountMsat int64
        RouteTotalTimeLock int32
        RouteTotalAmount   int64
        RouteSourceKey     []byte
}

func (q *Queries) InsertHtlcAttempt(ctx context.Context, arg InsertHtlcAttemptParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertHtlcAttempt,
                arg.PaymentID,
                arg.AttemptIndex,
                arg.SessionKey,
                arg.AttemptTime,
                arg.PaymentHash,
                arg.FirstHopAmountMsat,
                arg.RouteTotalTimeLock,
                arg.RouteTotalAmount,
                arg.RouteSourceKey,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertPayment = `-- name: InsertPayment :one
INSERT INTO payments (
    amount_msat, 
    created_at, 
    payment_identifier,
    fail_reason)
VALUES (
    $1,
    $2,
    $3,
    NULL
)
RETURNING id
`

type InsertPaymentParams struct {
        AmountMsat        int64
        CreatedAt         time.Time
        PaymentIdentifier []byte
}

// Insert a new payment and return its ID.
// When creating a payment we don't have a fail reason because we start the
// payment process.
func (q *Queries) InsertPayment(ctx context.Context, arg InsertPaymentParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertPayment, arg.AmountMsat, arg.CreatedAt, arg.PaymentIdentifier)
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertPaymentAttemptFirstHopCustomRecord = `-- name: InsertPaymentAttemptFirstHopCustomRecord :exec
INSERT INTO payment_attempt_first_hop_custom_records (
    htlc_attempt_index,
    key,
    value
)
VALUES (
    $1,
    $2,
    $3
)
`

type InsertPaymentAttemptFirstHopCustomRecordParams struct {
        HtlcAttemptIndex int64
        Key              int64
        Value            []byte
}

func (q *Queries) InsertPaymentAttemptFirstHopCustomRecord(ctx context.Context, arg InsertPaymentAttemptFirstHopCustomRecordParams) error {
        _, err := q.db.ExecContext(ctx, insertPaymentAttemptFirstHopCustomRecord, arg.HtlcAttemptIndex, arg.Key, arg.Value)
        return err
}

const insertPaymentDuplicateMig = `-- name: InsertPaymentDuplicateMig :one
INSERT INTO payment_duplicates (
    payment_id,
    amount_msat,
    created_at,
    fail_reason,
    settle_preimage,
    settle_time
)
VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6
)
RETURNING id
`

type InsertPaymentDuplicateMigParams struct {
        PaymentID      int64
        AmountMsat     int64
        CreatedAt      time.Time
        FailReason     sql.NullInt32
        SettlePreimage []byte
        SettleTime     sql.NullTime
}

// Insert a duplicate payment record into the payment_duplicates table and
// return its ID.
func (q *Queries) InsertPaymentDuplicateMig(ctx context.Context, arg InsertPaymentDuplicateMigParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertPaymentDuplicateMig,
                arg.PaymentID,
                arg.AmountMsat,
                arg.CreatedAt,
                arg.FailReason,
                arg.SettlePreimage,
                arg.SettleTime,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertPaymentFirstHopCustomRecord = `-- name: InsertPaymentFirstHopCustomRecord :exec
INSERT INTO payment_first_hop_custom_records (
    payment_id,
    key,
    value
)
VALUES (
    $1,
    $2,
    $3
)
`

type InsertPaymentFirstHopCustomRecordParams struct {
        PaymentID int64
        Key       int64
        Value     []byte
}

func (q *Queries) InsertPaymentFirstHopCustomRecord(ctx context.Context, arg InsertPaymentFirstHopCustomRecordParams) error {
        _, err := q.db.ExecContext(ctx, insertPaymentFirstHopCustomRecord, arg.PaymentID, arg.Key, arg.Value)
        return err
}

const insertPaymentHopCustomRecord = `-- name: InsertPaymentHopCustomRecord :exec
INSERT INTO payment_hop_custom_records (
    hop_id,
    key,
    value
)
VALUES (
    $1,
    $2,
    $3
)
`

type InsertPaymentHopCustomRecordParams struct {
        HopID int64
        Key   int64
        Value []byte
}

func (q *Queries) InsertPaymentHopCustomRecord(ctx context.Context, arg InsertPaymentHopCustomRecordParams) error {
        _, err := q.db.ExecContext(ctx, insertPaymentHopCustomRecord, arg.HopID, arg.Key, arg.Value)
        return err
}

const insertPaymentIntent = `-- name: InsertPaymentIntent :one
INSERT INTO payment_intents (
    payment_id,
    intent_type, 
    intent_payload)
VALUES (
    $1,
    $2, 
    $3
)
RETURNING id
`

type InsertPaymentIntentParams struct {
        PaymentID     int64
        IntentType    int16
        IntentPayload []byte
}

// Insert a payment intent for a given payment and return its ID.
func (q *Queries) InsertPaymentIntent(ctx context.Context, arg InsertPaymentIntentParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertPaymentIntent, arg.PaymentID, arg.IntentType, arg.IntentPayload)
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertPaymentMig = `-- name: InsertPaymentMig :one
/* ─────────────────────────────────────────────
   Migration-specific queries

   These queries are used ONLY for the one-time migration from KV to SQL.
   ─────────────────────────────────────────────
*/

INSERT INTO payments (
    amount_msat,
    created_at,
    payment_identifier,
    fail_reason)
VALUES (
    $1,
    $2,
    $3,
    $4
)
RETURNING id
`

type InsertPaymentMigParams struct {
        AmountMsat        int64
        CreatedAt         time.Time
        PaymentIdentifier []byte
        FailReason        sql.NullInt32
}

// Migration-specific payment insert that allows setting fail_reason.
// Normal InsertPayment forces fail_reason to NULL since new payments
// aren't failed yet. During migration, we're inserting historical data
// that may already be failed.
func (q *Queries) InsertPaymentMig(ctx context.Context, arg InsertPaymentMigParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertPaymentMig,
                arg.AmountMsat,
                arg.CreatedAt,
                arg.PaymentIdentifier,
                arg.FailReason,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertRouteHop = `-- name: InsertRouteHop :one
INSERT INTO payment_route_hops (
    htlc_attempt_index,
    hop_index,
    pub_key,
    scid,
    outgoing_time_lock,
    amt_to_forward,
    meta_data
)
VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7
)
RETURNING id
`

type InsertRouteHopParams struct {
        HtlcAttemptIndex int64
        HopIndex         int32
        PubKey           []byte
        Scid             string
        OutgoingTimeLock int32
        AmtToForward     int64
        MetaData         []byte
}

func (q *Queries) InsertRouteHop(ctx context.Context, arg InsertRouteHopParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertRouteHop,
                arg.HtlcAttemptIndex,
                arg.HopIndex,
                arg.PubKey,
                arg.Scid,
                arg.OutgoingTimeLock,
                arg.AmtToForward,
                arg.MetaData,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertRouteHopAmp = `-- name: InsertRouteHopAmp :exec
INSERT INTO payment_route_hop_amp (
    hop_id,
    root_share,
    set_id,
    child_index
)
VALUES (
    $1,
    $2,
    $3,
    $4
)
`

type InsertRouteHopAmpParams struct {
        HopID      int64
        RootShare  []byte
        SetID      []byte
        ChildIndex int32
}

func (q *Queries) InsertRouteHopAmp(ctx context.Context, arg InsertRouteHopAmpParams) error {
        _, err := q.db.ExecContext(ctx, insertRouteHopAmp,
                arg.HopID,
                arg.RootShare,
                arg.SetID,
                arg.ChildIndex,
        )
        return err
}

const insertRouteHopBlinded = `-- name: InsertRouteHopBlinded :exec
INSERT INTO payment_route_hop_blinded (
    hop_id,
    encrypted_data,
    blinding_point,
    blinded_path_total_amt
)
VALUES (
    $1,
    $2,
    $3,
    $4
)
`

type InsertRouteHopBlindedParams struct {
        HopID               int64
        EncryptedData       []byte
        BlindingPoint       []byte
        BlindedPathTotalAmt sql.NullInt64
}

func (q *Queries) InsertRouteHopBlinded(ctx context.Context, arg InsertRouteHopBlindedParams) error {
        _, err := q.db.ExecContext(ctx, insertRouteHopBlinded,
                arg.HopID,
                arg.EncryptedData,
                arg.BlindingPoint,
                arg.BlindedPathTotalAmt,
        )
        return err
}

const insertRouteHopMpp = `-- name: InsertRouteHopMpp :exec
INSERT INTO payment_route_hop_mpp (
    hop_id,
    payment_addr,
    total_msat
)
VALUES (
    $1,
    $2,
    $3
)
`

type InsertRouteHopMppParams struct {
        HopID       int64
        PaymentAddr []byte
        TotalMsat   int64
}

func (q *Queries) InsertRouteHopMpp(ctx context.Context, arg InsertRouteHopMppParams) error {
        _, err := q.db.ExecContext(ctx, insertRouteHopMpp, arg.HopID, arg.PaymentAddr, arg.TotalMsat)
        return err
}

const settleAttempt = `-- name: SettleAttempt :exec
INSERT INTO payment_htlc_attempt_resolutions (
    attempt_index,
    resolution_time,
    resolution_type,
    settle_preimage
)
VALUES (
    $1,
    $2,
    $3,
    $4
)
`

type SettleAttemptParams struct {
        AttemptIndex   int64
        ResolutionTime time.Time
        ResolutionType int32
        SettlePreimage []byte
}

func (q *Queries) SettleAttempt(ctx context.Context, arg SettleAttemptParams) error {
        _, err := q.db.ExecContext(ctx, settleAttempt,
                arg.AttemptIndex,
                arg.ResolutionTime,
                arg.ResolutionType,
                arg.SettlePreimage,
        )
        return err
}

lightningnetwork / lnd / 24081604890

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous