mirror of
https://github.com/lightningnetwork/lnd.git
synced 2025-02-23 14:40:30 +01:00
709 lines
16 KiB
Go
709 lines
16 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.18.0
|
|
// source: invoices.sql
|
|
|
|
package sqlc
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"time"
|
|
)
|
|
|
|
const deleteInvoice = `-- name: DeleteInvoice :exec
|
|
DELETE
|
|
FROM invoices
|
|
WHERE (
|
|
id = $1 OR
|
|
$1 IS NULL
|
|
) AND (
|
|
hash = $2 OR
|
|
$2 IS NULL
|
|
) AND (
|
|
preimage = $3 OR
|
|
$3 IS NULL
|
|
) AND (
|
|
payment_addr = $4 OR
|
|
$4 IS NULL
|
|
)
|
|
`
|
|
|
|
type DeleteInvoiceParams struct {
|
|
AddIndex sql.NullInt32
|
|
Hash []byte
|
|
Preimage []byte
|
|
PaymentAddr []byte
|
|
}
|
|
|
|
func (q *Queries) DeleteInvoice(ctx context.Context, arg DeleteInvoiceParams) error {
|
|
_, err := q.db.ExecContext(ctx, deleteInvoice,
|
|
arg.AddIndex,
|
|
arg.Hash,
|
|
arg.Preimage,
|
|
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
|
|
FROM invoices
|
|
WHERE (
|
|
id >= $1 OR
|
|
$1 IS NULL
|
|
) AND (
|
|
id <= $2 OR
|
|
$2 IS NULL
|
|
) AND (
|
|
state = $3 OR
|
|
$3 IS NULL
|
|
) AND (
|
|
created_at >= $4 OR
|
|
$4 IS NULL
|
|
) AND (
|
|
created_at <= $5 OR
|
|
$5 IS NULL
|
|
) AND (
|
|
CASE
|
|
WHEN $6=TRUE THEN (state = 0 OR state = 3)
|
|
ELSE TRUE
|
|
END
|
|
)
|
|
ORDER BY
|
|
CASE
|
|
WHEN $7 = FALSE THEN id
|
|
ELSE NULL
|
|
END ASC,
|
|
CASE
|
|
WHEN $7 = TRUE THEN id
|
|
ELSE NULL
|
|
END DESC
|
|
LIMIT $9 OFFSET $8
|
|
`
|
|
|
|
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
|
|
}
|
|
|
|
func (q *Queries) FilterInvoices(ctx context.Context, arg FilterInvoicesParams) ([]Invoice, error) {
|
|
rows, err := q.db.QueryContext(ctx, filterInvoices,
|
|
arg.AddIndexGet,
|
|
arg.AddIndexLet,
|
|
arg.State,
|
|
arg.CreatedAfter,
|
|
arg.CreatedBefore,
|
|
arg.PendingOnly,
|
|
arg.Reverse,
|
|
arg.NumOffset,
|
|
arg.NumLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Invoice
|
|
for rows.Next() {
|
|
var i Invoice
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Hash,
|
|
&i.Preimage,
|
|
&i.Memo,
|
|
&i.AmountMsat,
|
|
&i.CltvDelta,
|
|
&i.Expiry,
|
|
&i.PaymentAddr,
|
|
&i.PaymentRequest,
|
|
&i.State,
|
|
&i.AmountPaidMsat,
|
|
&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 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
|
|
WHERE (
|
|
id = $1 OR
|
|
$1 IS NULL
|
|
) AND (
|
|
hash = $2 OR
|
|
$2 IS NULL
|
|
) AND (
|
|
preimage = $3 OR
|
|
$3 IS NULL
|
|
) AND (
|
|
payment_addr = $4 OR
|
|
$4 IS NULL
|
|
)
|
|
LIMIT 2
|
|
`
|
|
|
|
type GetInvoiceParams struct {
|
|
AddIndex sql.NullInt32
|
|
Hash []byte
|
|
Preimage []byte
|
|
PaymentAddr []byte
|
|
}
|
|
|
|
// 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.
|
|
func (q *Queries) GetInvoice(ctx context.Context, arg GetInvoiceParams) ([]Invoice, error) {
|
|
rows, err := q.db.QueryContext(ctx, getInvoice,
|
|
arg.AddIndex,
|
|
arg.Hash,
|
|
arg.Preimage,
|
|
arg.PaymentAddr,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Invoice
|
|
for rows.Next() {
|
|
var i Invoice
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Hash,
|
|
&i.Preimage,
|
|
&i.Memo,
|
|
&i.AmountMsat,
|
|
&i.CltvDelta,
|
|
&i.Expiry,
|
|
&i.PaymentAddr,
|
|
&i.PaymentRequest,
|
|
&i.State,
|
|
&i.AmountPaidMsat,
|
|
&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 getInvoiceFeatures = `-- name: GetInvoiceFeatures :many
|
|
SELECT feature, invoice_id
|
|
FROM invoice_features
|
|
WHERE invoice_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetInvoiceFeatures(ctx context.Context, invoiceID int32) ([]InvoiceFeature, error) {
|
|
rows, err := q.db.QueryContext(ctx, getInvoiceFeatures, invoiceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []InvoiceFeature
|
|
for rows.Next() {
|
|
var i InvoiceFeature
|
|
if err := rows.Scan(&i.Feature, &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 getInvoiceHTLCCustomRecords = `-- name: GetInvoiceHTLCCustomRecords :many
|
|
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
|
|
`
|
|
|
|
type GetInvoiceHTLCCustomRecordsRow struct {
|
|
HtlcID int64
|
|
Key int64
|
|
Value []byte
|
|
}
|
|
|
|
func (q *Queries) GetInvoiceHTLCCustomRecords(ctx context.Context, invoiceID int32) ([]GetInvoiceHTLCCustomRecordsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getInvoiceHTLCCustomRecords, invoiceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetInvoiceHTLCCustomRecordsRow
|
|
for rows.Next() {
|
|
var i GetInvoiceHTLCCustomRecordsRow
|
|
if err := rows.Scan(&i.HtlcID, &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 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
|
|
FROM invoice_htlcs
|
|
WHERE invoice_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetInvoiceHTLCs(ctx context.Context, invoiceID int32) ([]InvoiceHtlc, error) {
|
|
rows, err := q.db.QueryContext(ctx, getInvoiceHTLCs, invoiceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []InvoiceHtlc
|
|
for rows.Next() {
|
|
var i InvoiceHtlc
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.HtlcID,
|
|
&i.ChanID,
|
|
&i.AmountMsat,
|
|
&i.TotalMppMsat,
|
|
&i.AcceptHeight,
|
|
&i.AcceptTime,
|
|
&i.ExpiryHeight,
|
|
&i.State,
|
|
&i.ResolveTime,
|
|
&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 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
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14
|
|
) 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
|
|
}
|
|
|
|
func (q *Queries) InsertInvoice(ctx context.Context, arg InsertInvoiceParams) (int32, error) {
|
|
row := q.db.QueryRowContext(ctx, insertInvoice,
|
|
arg.Hash,
|
|
arg.Preimage,
|
|
arg.Memo,
|
|
arg.AmountMsat,
|
|
arg.CltvDelta,
|
|
arg.Expiry,
|
|
arg.PaymentAddr,
|
|
arg.PaymentRequest,
|
|
arg.State,
|
|
arg.AmountPaidMsat,
|
|
arg.IsAmp,
|
|
arg.IsHodl,
|
|
arg.IsKeysend,
|
|
arg.CreatedAt,
|
|
)
|
|
var id int32
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const insertInvoiceFeature = `-- name: InsertInvoiceFeature :exec
|
|
INSERT INTO invoice_features (
|
|
invoice_id, feature
|
|
) VALUES (
|
|
$1, $2
|
|
)
|
|
`
|
|
|
|
type InsertInvoiceFeatureParams struct {
|
|
InvoiceID int32
|
|
Feature int32
|
|
}
|
|
|
|
func (q *Queries) InsertInvoiceFeature(ctx context.Context, arg InsertInvoiceFeatureParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertInvoiceFeature, arg.InvoiceID, arg.Feature)
|
|
return err
|
|
}
|
|
|
|
const insertInvoiceHTLC = `-- name: InsertInvoiceHTLC :exec
|
|
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
|
|
)
|
|
`
|
|
|
|
type InsertInvoiceHTLCParams struct {
|
|
HtlcID int64
|
|
ChanID string
|
|
AmountMsat int64
|
|
TotalMppMsat sql.NullInt64
|
|
AcceptHeight int32
|
|
AcceptTime time.Time
|
|
ExpiryHeight int32
|
|
State int16
|
|
ResolveTime sql.NullTime
|
|
InvoiceID int32
|
|
}
|
|
|
|
func (q *Queries) InsertInvoiceHTLC(ctx context.Context, arg InsertInvoiceHTLCParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertInvoiceHTLC,
|
|
arg.HtlcID,
|
|
arg.ChanID,
|
|
arg.AmountMsat,
|
|
arg.TotalMppMsat,
|
|
arg.AcceptHeight,
|
|
arg.AcceptTime,
|
|
arg.ExpiryHeight,
|
|
arg.State,
|
|
arg.ResolveTime,
|
|
arg.InvoiceID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertInvoiceHTLCCustomRecord = `-- name: InsertInvoiceHTLCCustomRecord :exec
|
|
INSERT INTO invoice_htlc_custom_records (
|
|
key, value, htlc_id
|
|
) VALUES (
|
|
$1, $2, $3
|
|
)
|
|
`
|
|
|
|
type InsertInvoiceHTLCCustomRecordParams struct {
|
|
Key int64
|
|
Value []byte
|
|
HtlcID int64
|
|
}
|
|
|
|
func (q *Queries) InsertInvoiceHTLCCustomRecord(ctx context.Context, arg InsertInvoiceHTLCCustomRecordParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertInvoiceHTLCCustomRecord, arg.Key, arg.Value, arg.HtlcID)
|
|
return err
|
|
}
|
|
|
|
const insertInvoicePayment = `-- name: InsertInvoicePayment :one
|
|
INSERT INTO invoice_payments (
|
|
invoice_id, amount_paid_msat, settled_at
|
|
) VALUES (
|
|
$1, $2, $3
|
|
) RETURNING id
|
|
`
|
|
|
|
type InsertInvoicePaymentParams struct {
|
|
InvoiceID int32
|
|
AmountPaidMsat int64
|
|
SettledAt time.Time
|
|
}
|
|
|
|
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
|
|
`
|
|
|
|
type UpdateInvoiceParams struct {
|
|
ID int32
|
|
Preimage []byte
|
|
State int16
|
|
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
|
|
}
|
|
|
|
const updateInvoiceHTLC = `-- name: UpdateInvoiceHTLC :exec
|
|
UPDATE invoice_htlcs
|
|
SET state=$2, resolve_time=$3
|
|
WHERE id = $1
|
|
`
|
|
|
|
type UpdateInvoiceHTLCParams struct {
|
|
ID int32
|
|
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)
|
|
return err
|
|
}
|
|
|
|
const updateInvoiceHTLCs = `-- name: UpdateInvoiceHTLCs :exec
|
|
UPDATE invoice_htlcs
|
|
SET state=$2, resolve_time=$3
|
|
WHERE invoice_id = $1 AND resolve_time IS NULL
|
|
`
|
|
|
|
type UpdateInvoiceHTLCsParams struct {
|
|
InvoiceID int32
|
|
State int16
|
|
ResolveTime sql.NullTime
|
|
}
|
|
|
|
func (q *Queries) UpdateInvoiceHTLCs(ctx context.Context, arg UpdateInvoiceHTLCsParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateInvoiceHTLCs, arg.InvoiceID, arg.State, arg.ResolveTime)
|
|
return err
|
|
}
|