17191871672

Committed 24 Aug 2025 05:44PM UTC coverage: 66.162% (+8.8%) from 57.321%

Build # 17191871672

Build Type

Pull #9147

github

Committed by

web-flow

Commit Message

Merge edec0450e into 0c2f045f5

Pull Request Pull Request #9147: [Part 1|3] Introduce SQL Payment schema into LND

Run Details

72 of 1878 new or added lines in 12 files covered. (3.83%)

17 existing lines in 7 files now uncovered.

135954 of 205487 relevant lines covered (66.16%)

21319.58 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 htlc_fail_reason IS NOT NULL
`

// TODO(ziggie): Is the htlc_fail_reason always set for a failed attempt?
func (q *Queries) DeleteFailedAttempts(ctx context.Context, paymentID int64) error {
        _, err := q.db.ExecContext(ctx, deleteFailedAttempts, paymentID)
        return err
}

const deleteFailedAttemptsByAttemptIndices = `-- name: DeleteFailedAttemptsByAttemptIndices :exec
DELETE FROM payment_htlc_attempts WHERE attempt_index IN (/*SLICE:attempt_indices*/?)
`

func (q *Queries) DeleteFailedAttemptsByAttemptIndices(ctx context.Context, attemptIndices []int64) error {
        query := deleteFailedAttemptsByAttemptIndices
        var queryParams []interface{}
        if len(attemptIndices) > 0 {
                for _, v := range attemptIndices {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:attempt_indices*/?", makeQueryParams(len(queryParams), len(attemptIndices)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:attempt_indices*/?", "NULL", 1)
        }
        _, err := q.db.ExecContext(ctx, query, queryParams...)
        return err
}

const deletePayment = `-- name: DeletePayment :exec
/* ─────────────────────────────────────────────
   Delete queries
   ─────────────────────────────────────────────
*/

DELETE FROM payments WHERE payment_hash = $1
`

func (q *Queries) DeletePayment(ctx context.Context, paymentHash []byte) error {
        _, err := q.db.ExecContext(ctx, deletePayment, paymentHash)
        return err
}

const deletePayments = `-- name: DeletePayments :exec
DELETE FROM payments WHERE id IN (/*SLICE:payment_ids*/?)
`

func (q *Queries) DeletePayments(ctx context.Context, paymentIds []int64) error {
        query := deletePayments
        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)
        }
        _, err := q.db.ExecContext(ctx, query, queryParams...)
        return err
}

const fetchCustomRecordsForAttempts = `-- name: FetchCustomRecordsForAttempts :many
SELECT id, key, value, htlc_attempt_index FROM payment_htlc_attempt_custom_records
WHERE htlc_attempt_index IN (/*SLICE:htlc_attempt_indices*/?)
`

func (q *Queries) FetchCustomRecordsForAttempts(ctx context.Context, htlcAttemptIndices []int64) ([]PaymentHtlcAttemptCustomRecord, error) {
        query := fetchCustomRecordsForAttempts
        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 []PaymentHtlcAttemptCustomRecord
        for rows.Next() {
                var i PaymentHtlcAttemptCustomRecord
                if err := rows.Scan(
                        &i.ID,
                        &i.Key,
                        &i.Value,
                        &i.HtlcAttemptIndex,
                ); 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 fetchCustomRecordsForHops = `-- name: FetchCustomRecordsForHops :many
SELECT id, key, value, hop_id FROM payment_route_hop_custom_records
WHERE hop_id IN (/*SLICE:hop_ids*/?)
`

func (q *Queries) FetchCustomRecordsForHops(ctx context.Context, hopIds []int64) ([]PaymentRouteHopCustomRecord, error) {
        query := fetchCustomRecordsForHops
        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 []PaymentRouteHopCustomRecord
        for rows.Next() {
                var i PaymentRouteHopCustomRecord
                if err := rows.Scan(
                        &i.ID,
                        &i.Key,
                        &i.Value,
                        &i.HopID,
                ); 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 fetchFirstHopCustomRecords = `-- name: FetchFirstHopCustomRecords :many
SELECT id, key, value, payment_id FROM payment_first_hop_custom_records WHERE payment_id = $1
`

func (q *Queries) FetchFirstHopCustomRecords(ctx context.Context, paymentID int64) ([]PaymentFirstHopCustomRecord, error) {
        rows, err := q.db.QueryContext(ctx, fetchFirstHopCustomRecords, paymentID)
        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.Key,
                        &i.Value,
                        &i.PaymentID,
                ); 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 fetchHopsForAttempt = `-- name: FetchHopsForAttempt :many
SELECT id, htlc_attempt_index, hop_index, pub_key, scid, outgoing_time_lock, amt_to_forward, meta_data, legacy_payload, mpp_payment_addr, mpp_total_msat, amp_root_share, amp_set_id, amp_child_index, encrypted_data, blinding_point, blinded_path_total_amt FROM payment_route_hops h
WHERE h.htlc_attempt_index = $1
ORDER BY h.hop_index ASC
`

func (q *Queries) FetchHopsForAttempt(ctx context.Context, htlcAttemptIndex int64) ([]PaymentRouteHop, error) {
        rows, err := q.db.QueryContext(ctx, fetchHopsForAttempt, htlcAttemptIndex)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentRouteHop
        for rows.Next() {
                var i PaymentRouteHop
                if err := rows.Scan(
                        &i.ID,
                        &i.HtlcAttemptIndex,
                        &i.HopIndex,
                        &i.PubKey,
                        &i.Scid,
                        &i.OutgoingTimeLock,
                        &i.AmtToForward,
                        &i.MetaData,
                        &i.LegacyPayload,
                        &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 fetchHopsForAttempts = `-- name: FetchHopsForAttempts :many
SELECT id, htlc_attempt_index, hop_index, pub_key, scid, outgoing_time_lock, amt_to_forward, meta_data, legacy_payload, mpp_payment_addr, mpp_total_msat, amp_root_share, amp_set_id, amp_child_index, encrypted_data, blinding_point, blinded_path_total_amt FROM payment_route_hops 
WHERE htlc_attempt_index IN (/*SLICE:htlc_attempt_indices*/?)
`

func (q *Queries) FetchHopsForAttempts(ctx context.Context, htlcAttemptIndices []int64) ([]PaymentRouteHop, 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 []PaymentRouteHop
        for rows.Next() {
                var i PaymentRouteHop
                if err := rows.Scan(
                        &i.ID,
                        &i.HtlcAttemptIndex,
                        &i.HopIndex,
                        &i.PubKey,
                        &i.Scid,
                        &i.OutgoingTimeLock,
                        &i.AmtToForward,
                        &i.MetaData,
                        &i.LegacyPayload,
                        &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 fetchHtlcAttempts = `-- name: FetchHtlcAttempts :many
SELECT id, attempt_index, payment_id, session_key, attempt_time, payment_hash, route_total_time_lock, route_total_amount, route_source_key, failure_source_index, htlc_fail_reason, failure_msg, fail_time, settle_preimage, settle_time FROM payment_htlc_attempts ha
WHERE ha.payment_id = $1 
    AND (
        ($2 = true AND ha.settle_preimage IS NULL AND ha.htlc_fail_reason IS NULL)
        OR
        ($2 = false OR $2 IS NULL)
    )
ORDER BY 
    CASE WHEN $3 = false OR $3 IS NULL THEN ha.attempt_time END ASC,
    CASE WHEN $3 = true THEN ha.attempt_time END DESC
`

type FetchHtlcAttemptsParams struct {
        PaymentID    int64
        InFlightOnly interface{}
        Reverse      interface{}
}

// This will not include the hops for the htlc attempts which are in a separate
// table.
func (q *Queries) FetchHtlcAttempts(ctx context.Context, arg FetchHtlcAttemptsParams) ([]PaymentHtlcAttempt, error) {
        rows, err := q.db.QueryContext(ctx, fetchHtlcAttempts, arg.PaymentID, arg.InFlightOnly, arg.Reverse)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []PaymentHtlcAttempt
        for rows.Next() {
                var i PaymentHtlcAttempt
                if err := rows.Scan(
                        &i.ID,
                        &i.AttemptIndex,
                        &i.PaymentID,
                        &i.SessionKey,
                        &i.AttemptTime,
                        &i.PaymentHash,
                        &i.RouteTotalTimeLock,
                        &i.RouteTotalAmount,
                        &i.RouteSourceKey,
                        &i.FailureSourceIndex,
                        &i.HtlcFailReason,
                        &i.FailureMsg,
                        &i.FailTime,
                        &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 fetchPayment = `-- name: FetchPayment :one
SELECT id, payment_request, amount_msat, created_at, payment_hash, fail_reason FROM payments WHERE payment_hash = $1
`

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

const fetchPayments = `-- name: FetchPayments :many
SELECT id, payment_request, amount_msat, created_at, payment_hash, fail_reason FROM payments WHERE payment_hash IN (/*SLICE:payment_hashes*/?)
`

func (q *Queries) FetchPayments(ctx context.Context, paymentHashes [][]byte) ([]Payment, error) {
        query := fetchPayments
        var queryParams []interface{}
        if len(paymentHashes) > 0 {
                for _, v := range paymentHashes {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:payment_hashes*/?", makeQueryParams(len(queryParams), len(paymentHashes)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:payment_hashes*/?", "NULL", 1)
        }
        rows, err := q.db.QueryContext(ctx, query, queryParams...)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []Payment
        for rows.Next() {
                var i Payment
                if err := rows.Scan(
                        &i.ID,
                        &i.PaymentRequest,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.PaymentHash,
                        &i.FailReason,
                ); 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 id, payment_request, amount_msat, created_at, payment_hash, fail_reason FROM payments
WHERE (
    -- This will exclude payments which have the failed reason set. These 
    -- payments might not be final yet meaning that they still can be inflight
    -- but they will transition to failed when all corresponding HTLCs are
    -- resolved.     
    ($1 = true AND fail_reason IS NULL) OR
    $1 = false OR $1 IS NULL
)
 AND (
    id > $2 OR
    $2 IS NULL 

) AND (
    id < $3 OR
    $3 IS NULL
) AND (
    created_at >= $4 OR
    $4 IS NULL
) AND (
    created_at <= $5 OR
    $5 IS NULL
)
ORDER BY 
    CASE WHEN $6 = false OR $6 IS NULL THEN id END ASC,
    CASE WHEN $6 = true THEN id END DESC
LIMIT $7
`

type FilterPaymentsParams struct {
        ExcludeFailed  interface{}
        IndexOffsetGet sql.NullInt64
        IndexOffsetLet sql.NullInt64
        CreatedAfter   sql.NullTime
        CreatedBefore  sql.NullTime
        Reverse        interface{}
        NumLimit       int32
}

func (q *Queries) FilterPayments(ctx context.Context, arg FilterPaymentsParams) ([]Payment, error) {
        rows, err := q.db.QueryContext(ctx, filterPayments,
                arg.ExcludeFailed,
                arg.IndexOffsetGet,
                arg.IndexOffsetLet,
                arg.CreatedAfter,
                arg.CreatedBefore,
                arg.Reverse,
                arg.NumLimit,
        )
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []Payment
        for rows.Next() {
                var i Payment
                if err := rows.Scan(
                        &i.ID,
                        &i.PaymentRequest,
                        &i.AmountMsat,
                        &i.CreatedAt,
                        &i.PaymentHash,
                        &i.FailReason,
                ); 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 insertFirstHopCustomRecord = `-- name: InsertFirstHopCustomRecord :exec
INSERT INTO payment_first_hop_custom_records (
    payment_id,
    key,
    value
) VALUES (
    $1, $2, $3
)
`

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

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

const insertFirstHopCustomRecordsBatch = `-- name: InsertFirstHopCustomRecordsBatch :exec
INSERT INTO payment_first_hop_custom_records (payment_id, key, value)
SELECT 
    $1 as payment_id,
    unnest(/*SLICE:keys*/?) as key,
    unnest(/*SLICE:values*/?) as value
`

type InsertFirstHopCustomRecordsBatchParams struct {
        PaymentID int64
        Keys      []interface{}
        Values    []interface{}
}

func (q *Queries) InsertFirstHopCustomRecordsBatch(ctx context.Context, arg InsertFirstHopCustomRecordsBatchParams) error {
        query := insertFirstHopCustomRecordsBatch
        var queryParams []interface{}
        queryParams = append(queryParams, arg.PaymentID)
        if len(arg.Keys) > 0 {
                for _, v := range arg.Keys {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:keys*/?", makeQueryParams(len(queryParams), len(arg.Keys)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:keys*/?", "NULL", 1)
        }
        if len(arg.Values) > 0 {
                for _, v := range arg.Values {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:values*/?", makeQueryParams(len(queryParams), len(arg.Values)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:values*/?", "NULL", 1)
        }
        _, err := q.db.ExecContext(ctx, query, queryParams...)
        return err
}

const insertHop = `-- name: InsertHop :one
INSERT INTO payment_route_hops (
    htlc_attempt_index,
    hop_index,
    pub_key,
    scid,
    outgoing_time_lock,
    amt_to_forward,
    meta_data,
    legacy_payload,
    mpp_payment_addr,
    mpp_total_msat,
    amp_root_share,
    amp_set_id,
    amp_child_index,
    blinding_point,
    encrypted_data,
    blinded_path_total_amt
) VALUES (
        $1,
        $2,
        $3,
        $4,
        $5,
        $6,
        $7,
        $8,
        $9,
        $10,
        $11,
        $12,
        $13,
        $14,
        $15,
        $16
) RETURNING id
`

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

func (q *Queries) InsertHop(ctx context.Context, arg InsertHopParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertHop,
                arg.HtlcAttemptIndex,
                arg.HopIndex,
                arg.PubKey,
                arg.Scid,
                arg.OutgoingTimeLock,
                arg.AmtToForward,
                arg.MetaData,
                arg.LegacyPayload,
                arg.MppPaymentAddr,
                arg.MppTotalMsat,
                arg.AmpRootShare,
                arg.AmpSetID,
                arg.AmpChildIndex,
                arg.BlindingPoint,
                arg.EncryptedData,
                arg.BlindedPathTotalAmt,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const insertHopCustomRecordsBatch = `-- name: InsertHopCustomRecordsBatch :exec
INSERT INTO payment_route_hop_custom_records (
    hop_id,
    key,
    value
) SELECT
    $1 as hop_id,
    unnest(/*SLICE:keys*/?) as key,
    unnest(/*SLICE:values*/?) as value
`

type InsertHopCustomRecordsBatchParams struct {
        HopID  int64
        Keys   []interface{}
        Values []interface{}
}

func (q *Queries) InsertHopCustomRecordsBatch(ctx context.Context, arg InsertHopCustomRecordsBatchParams) error {
        query := insertHopCustomRecordsBatch
        var queryParams []interface{}
        queryParams = append(queryParams, arg.HopID)
        if len(arg.Keys) > 0 {
                for _, v := range arg.Keys {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:keys*/?", makeQueryParams(len(queryParams), len(arg.Keys)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:keys*/?", "NULL", 1)
        }
        if len(arg.Values) > 0 {
                for _, v := range arg.Values {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:values*/?", makeQueryParams(len(queryParams), len(arg.Values)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:values*/?", "NULL", 1)
        }
        _, err := q.db.ExecContext(ctx, query, queryParams...)
        return err
}

const insertHtlAttemptCustomRecordsBatch = `-- name: InsertHtlAttemptCustomRecordsBatch :exec
INSERT INTO payment_htlc_attempt_custom_records (
    htlc_attempt_index,
    key,
    value
) SELECT
    $1 as htlc_attempt_index,
    unnest(/*SLICE:keys*/?) as key,
    unnest(/*SLICE:values*/?) as value
`

type InsertHtlAttemptCustomRecordsBatchParams struct {
        HtlcAttemptIndex int64
        Keys             []interface{}
        Values           []interface{}
}

func (q *Queries) InsertHtlAttemptCustomRecordsBatch(ctx context.Context, arg InsertHtlAttemptCustomRecordsBatchParams) error {
        query := insertHtlAttemptCustomRecordsBatch
        var queryParams []interface{}
        queryParams = append(queryParams, arg.HtlcAttemptIndex)
        if len(arg.Keys) > 0 {
                for _, v := range arg.Keys {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:keys*/?", makeQueryParams(len(queryParams), len(arg.Keys)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:keys*/?", "NULL", 1)
        }
        if len(arg.Values) > 0 {
                for _, v := range arg.Values {
                        queryParams = append(queryParams, v)
                }
                query = strings.Replace(query, "/*SLICE:values*/?", makeQueryParams(len(queryParams), len(arg.Values)), 1)
        } else {
                query = strings.Replace(query, "/*SLICE:values*/?", "NULL", 1)
        }
        _, err := q.db.ExecContext(ctx, query, queryParams...)
        return err
}

const insertHtlcAttempt = `-- name: InsertHtlcAttempt :one
INSERT INTO payment_htlc_attempts (
    attempt_index,
    payment_id,
    session_key,
    attempt_time,
    payment_hash,
    route_total_time_lock,
    route_total_amount,
    route_source_key
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8
) RETURNING id
`

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

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

const insertPayment = `-- name: InsertPayment :one
/* ─────────────────────────────────────────────
   Insert queries
   ─────────────────────────────────────────────
*/

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

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

func (q *Queries) InsertPayment(ctx context.Context, arg InsertPaymentParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, insertPayment,
                arg.PaymentRequest,
                arg.AmountMsat,
                arg.CreatedAt,
                arg.PaymentHash,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const updateHtlcAttemptFailInfo = `-- name: UpdateHtlcAttemptFailInfo :one
UPDATE payment_htlc_attempts 
SET htlc_fail_reason = $1, fail_time = $2, failure_source_index = $3, failure_msg = $4
WHERE attempt_index = $5
RETURNING id
`

type UpdateHtlcAttemptFailInfoParams struct {
        HtlcFailReason     sql.NullInt32
        FailTime           sql.NullTime
        FailureSourceIndex sql.NullInt32
        FailureMsg         []byte
        AttemptIndex       int64
}

func (q *Queries) UpdateHtlcAttemptFailInfo(ctx context.Context, arg UpdateHtlcAttemptFailInfoParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, updateHtlcAttemptFailInfo,
                arg.HtlcFailReason,
                arg.FailTime,
                arg.FailureSourceIndex,
                arg.FailureMsg,
                arg.AttemptIndex,
        )
        var id int64
        err := row.Scan(&id)
        return id, err
}

const updateHtlcAttemptSettleInfo = `-- name: UpdateHtlcAttemptSettleInfo :one
/* ─────────────────────────────────────────────
   Update queries
   ─────────────────────────────────────────────
*/

UPDATE payment_htlc_attempts 
SET settle_preimage = $1, settle_time = $2 
WHERE attempt_index = $3
RETURNING id
`

type UpdateHtlcAttemptSettleInfoParams struct {
        SettlePreimage []byte
        SettleTime     sql.NullTime
        AttemptIndex   int64
}

func (q *Queries) UpdateHtlcAttemptSettleInfo(ctx context.Context, arg UpdateHtlcAttemptSettleInfoParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, updateHtlcAttemptSettleInfo, arg.SettlePreimage, arg.SettleTime, arg.AttemptIndex)
        var id int64
        err := row.Scan(&id)
        return id, err
}

const updatePaymentFailReason = `-- name: UpdatePaymentFailReason :one
UPDATE payments 
SET fail_reason = $1
WHERE payment_hash = $2
RETURNING id
`

type UpdatePaymentFailReasonParams struct {
        FailReason  sql.NullInt32
        PaymentHash []byte
}

func (q *Queries) UpdatePaymentFailReason(ctx context.Context, arg UpdatePaymentFailReasonParams) (int64, error) {
        row := q.db.QueryRowContext(ctx, updatePaymentFailReason, arg.FailReason, arg.PaymentHash)
        var id int64
        err := row.Scan(&id)
        return id, err
}

lightningnetwork / lnd / 17191871672

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