// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.25.0
// source: static_address_loopin.sql

package sqlc

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

const depositIDsForSwapHash = `-- name: DepositIDsForSwapHash :many
SELECT
    deposit_id
FROM
    deposits
WHERE
    swap_hash = $1
`

func (q *Queries) DepositIDsForSwapHash(ctx context.Context, swapHash []byte) ([][]byte, error) {
	rows, err := q.db.QueryContext(ctx, depositIDsForSwapHash, swapHash)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items [][]byte
	for rows.Next() {
		var deposit_id []byte
		if err := rows.Scan(&deposit_id); err != nil {
			return nil, err
		}
		items = append(items, deposit_id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const depositsForSwapHash = `-- name: DepositsForSwapHash :many
SELECT
    d.id, d.deposit_id, d.tx_hash, d.out_index, d.amount, d.confirmation_height, d.timeout_sweep_pk_script, d.expiry_sweep_txid, d.finalized_withdrawal_tx, d.swap_hash,
    u.update_state,
    u.update_timestamp
FROM
    deposits d
        LEFT JOIN
    deposit_updates u ON u.id = (
        SELECT id
        FROM deposit_updates
        WHERE deposit_id = d.deposit_id
        ORDER BY update_timestamp DESC
        LIMIT 1
    )
WHERE
    d.swap_hash = $1
`

type DepositsForSwapHashRow struct {
	ID                    int32
	DepositID             []byte
	TxHash                []byte
	OutIndex              int32
	Amount                int64
	ConfirmationHeight    int64
	TimeoutSweepPkScript  []byte
	ExpirySweepTxid       []byte
	FinalizedWithdrawalTx sql.NullString
	SwapHash              []byte
	UpdateState           sql.NullString
	UpdateTimestamp       sql.NullTime
}

func (q *Queries) DepositsForSwapHash(ctx context.Context, swapHash []byte) ([]DepositsForSwapHashRow, error) {
	rows, err := q.db.QueryContext(ctx, depositsForSwapHash, swapHash)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []DepositsForSwapHashRow
	for rows.Next() {
		var i DepositsForSwapHashRow
		if err := rows.Scan(
			&i.ID,
			&i.DepositID,
			&i.TxHash,
			&i.OutIndex,
			&i.Amount,
			&i.ConfirmationHeight,
			&i.TimeoutSweepPkScript,
			&i.ExpirySweepTxid,
			&i.FinalizedWithdrawalTx,
			&i.SwapHash,
			&i.UpdateState,
			&i.UpdateTimestamp,
		); 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 getLoopInSwapUpdates = `-- name: GetLoopInSwapUpdates :many
SELECT
    static_address_swap_updates.id, static_address_swap_updates.swap_hash, static_address_swap_updates.update_state, static_address_swap_updates.update_timestamp
FROM
    static_address_swap_updates
WHERE
    swap_hash = $1
`

func (q *Queries) GetLoopInSwapUpdates(ctx context.Context, swapHash []byte) ([]StaticAddressSwapUpdate, error) {
	rows, err := q.db.QueryContext(ctx, getLoopInSwapUpdates, swapHash)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []StaticAddressSwapUpdate
	for rows.Next() {
		var i StaticAddressSwapUpdate
		if err := rows.Scan(
			&i.ID,
			&i.SwapHash,
			&i.UpdateState,
			&i.UpdateTimestamp,
		); 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 getStaticAddressLoopInSwap = `-- name: GetStaticAddressLoopInSwap :one
SELECT
    swaps.id, swaps.swap_hash, swaps.preimage, swaps.initiation_time, swaps.amount_requested, swaps.cltv_expiry, swaps.max_miner_fee, swaps.max_swap_fee, swaps.initiation_height, swaps.protocol_version, swaps.label,
    static_address_swaps.id, static_address_swaps.swap_hash, static_address_swaps.swap_invoice, static_address_swaps.last_hop, static_address_swaps.payment_timeout_seconds, static_address_swaps.quoted_swap_fee_satoshis, static_address_swaps.deposit_outpoints, static_address_swaps.htlc_tx_fee_rate_sat_kw, static_address_swaps.htlc_timeout_sweep_tx_id, static_address_swaps.htlc_timeout_sweep_address, static_address_swaps.selected_amount,
    htlc_keys.swap_hash, htlc_keys.sender_script_pubkey, htlc_keys.receiver_script_pubkey, htlc_keys.sender_internal_pubkey, htlc_keys.receiver_internal_pubkey, htlc_keys.client_key_family, htlc_keys.client_key_index
FROM
    swaps
        JOIN
    static_address_swaps ON swaps.swap_hash = static_address_swaps.swap_hash
        JOIN
    htlc_keys ON swaps.swap_hash = htlc_keys.swap_hash
WHERE
        swaps.swap_hash = $1
`

type GetStaticAddressLoopInSwapRow struct {
	ID                      int32
	SwapHash                []byte
	Preimage                []byte
	InitiationTime          time.Time
	AmountRequested         int64
	CltvExpiry              int32
	MaxMinerFee             int64
	MaxSwapFee              int64
	InitiationHeight        int32
	ProtocolVersion         int32
	Label                   string
	ID_2                    int32
	SwapHash_2              []byte
	SwapInvoice             string
	LastHop                 []byte
	PaymentTimeoutSeconds   int32
	QuotedSwapFeeSatoshis   int64
	DepositOutpoints        string
	HtlcTxFeeRateSatKw      int64
	HtlcTimeoutSweepTxID    sql.NullString
	HtlcTimeoutSweepAddress string
	SelectedAmount          int64
	SwapHash_3              []byte
	SenderScriptPubkey      []byte
	ReceiverScriptPubkey    []byte
	SenderInternalPubkey    []byte
	ReceiverInternalPubkey  []byte
	ClientKeyFamily         int32
	ClientKeyIndex          int32
}

func (q *Queries) GetStaticAddressLoopInSwap(ctx context.Context, swapHash []byte) (GetStaticAddressLoopInSwapRow, error) {
	row := q.db.QueryRowContext(ctx, getStaticAddressLoopInSwap, swapHash)
	var i GetStaticAddressLoopInSwapRow
	err := row.Scan(
		&i.ID,
		&i.SwapHash,
		&i.Preimage,
		&i.InitiationTime,
		&i.AmountRequested,
		&i.CltvExpiry,
		&i.MaxMinerFee,
		&i.MaxSwapFee,
		&i.InitiationHeight,
		&i.ProtocolVersion,
		&i.Label,
		&i.ID_2,
		&i.SwapHash_2,
		&i.SwapInvoice,
		&i.LastHop,
		&i.PaymentTimeoutSeconds,
		&i.QuotedSwapFeeSatoshis,
		&i.DepositOutpoints,
		&i.HtlcTxFeeRateSatKw,
		&i.HtlcTimeoutSweepTxID,
		&i.HtlcTimeoutSweepAddress,
		&i.SelectedAmount,
		&i.SwapHash_3,
		&i.SenderScriptPubkey,
		&i.ReceiverScriptPubkey,
		&i.SenderInternalPubkey,
		&i.ReceiverInternalPubkey,
		&i.ClientKeyFamily,
		&i.ClientKeyIndex,
	)
	return i, err
}

const getStaticAddressLoopInSwapsByStates = `-- name: GetStaticAddressLoopInSwapsByStates :many
SELECT
    swaps.id, swaps.swap_hash, swaps.preimage, swaps.initiation_time, swaps.amount_requested, swaps.cltv_expiry, swaps.max_miner_fee, swaps.max_swap_fee, swaps.initiation_height, swaps.protocol_version, swaps.label,
    static_address_swaps.id, static_address_swaps.swap_hash, static_address_swaps.swap_invoice, static_address_swaps.last_hop, static_address_swaps.payment_timeout_seconds, static_address_swaps.quoted_swap_fee_satoshis, static_address_swaps.deposit_outpoints, static_address_swaps.htlc_tx_fee_rate_sat_kw, static_address_swaps.htlc_timeout_sweep_tx_id, static_address_swaps.htlc_timeout_sweep_address, static_address_swaps.selected_amount,
    htlc_keys.swap_hash, htlc_keys.sender_script_pubkey, htlc_keys.receiver_script_pubkey, htlc_keys.sender_internal_pubkey, htlc_keys.receiver_internal_pubkey, htlc_keys.client_key_family, htlc_keys.client_key_index
FROM
    swaps
        JOIN
    static_address_swaps ON swaps.swap_hash = static_address_swaps.swap_hash
        JOIN
    htlc_keys ON swaps.swap_hash = htlc_keys.swap_hash
        JOIN
    static_address_swap_updates u ON swaps.swap_hash = u.swap_hash
        -- This subquery ensures that we are checking only the latest update for
        -- each swap_hash.
        AND u.update_timestamp = (
            SELECT MAX(update_timestamp)
            FROM static_address_swap_updates
            WHERE swap_hash = u.swap_hash
        )
WHERE
        (',' || $1 || ',') LIKE ('%,' || u.update_state || ',%')
ORDER BY
    swaps.id
`

type GetStaticAddressLoopInSwapsByStatesRow struct {
	ID                      int32
	SwapHash                []byte
	Preimage                []byte
	InitiationTime          time.Time
	AmountRequested         int64
	CltvExpiry              int32
	MaxMinerFee             int64
	MaxSwapFee              int64
	InitiationHeight        int32
	ProtocolVersion         int32
	Label                   string
	ID_2                    int32
	SwapHash_2              []byte
	SwapInvoice             string
	LastHop                 []byte
	PaymentTimeoutSeconds   int32
	QuotedSwapFeeSatoshis   int64
	DepositOutpoints        string
	HtlcTxFeeRateSatKw      int64
	HtlcTimeoutSweepTxID    sql.NullString
	HtlcTimeoutSweepAddress string
	SelectedAmount          int64
	SwapHash_3              []byte
	SenderScriptPubkey      []byte
	ReceiverScriptPubkey    []byte
	SenderInternalPubkey    []byte
	ReceiverInternalPubkey  []byte
	ClientKeyFamily         int32
	ClientKeyIndex          int32
}

func (q *Queries) GetStaticAddressLoopInSwapsByStates(ctx context.Context, dollar_1 sql.NullString) ([]GetStaticAddressLoopInSwapsByStatesRow, error) {
	rows, err := q.db.QueryContext(ctx, getStaticAddressLoopInSwapsByStates, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetStaticAddressLoopInSwapsByStatesRow
	for rows.Next() {
		var i GetStaticAddressLoopInSwapsByStatesRow
		if err := rows.Scan(
			&i.ID,
			&i.SwapHash,
			&i.Preimage,
			&i.InitiationTime,
			&i.AmountRequested,
			&i.CltvExpiry,
			&i.MaxMinerFee,
			&i.MaxSwapFee,
			&i.InitiationHeight,
			&i.ProtocolVersion,
			&i.Label,
			&i.ID_2,
			&i.SwapHash_2,
			&i.SwapInvoice,
			&i.LastHop,
			&i.PaymentTimeoutSeconds,
			&i.QuotedSwapFeeSatoshis,
			&i.DepositOutpoints,
			&i.HtlcTxFeeRateSatKw,
			&i.HtlcTimeoutSweepTxID,
			&i.HtlcTimeoutSweepAddress,
			&i.SelectedAmount,
			&i.SwapHash_3,
			&i.SenderScriptPubkey,
			&i.ReceiverScriptPubkey,
			&i.SenderInternalPubkey,
			&i.ReceiverInternalPubkey,
			&i.ClientKeyFamily,
			&i.ClientKeyIndex,
		); 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 insertStaticAddressLoopIn = `-- name: InsertStaticAddressLoopIn :exec
INSERT INTO static_address_swaps (
    swap_hash,
    swap_invoice,
    last_hop,
    payment_timeout_seconds,
    quoted_swap_fee_satoshis,
    deposit_outpoints,
    selected_amount,
    htlc_tx_fee_rate_sat_kw,
    htlc_timeout_sweep_tx_id,
    htlc_timeout_sweep_address
) VALUES (
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    $8,
    $9,
    $10
)
`

type InsertStaticAddressLoopInParams struct {
	SwapHash                []byte
	SwapInvoice             string
	LastHop                 []byte
	PaymentTimeoutSeconds   int32
	QuotedSwapFeeSatoshis   int64
	DepositOutpoints        string
	SelectedAmount          int64
	HtlcTxFeeRateSatKw      int64
	HtlcTimeoutSweepTxID    sql.NullString
	HtlcTimeoutSweepAddress string
}

func (q *Queries) InsertStaticAddressLoopIn(ctx context.Context, arg InsertStaticAddressLoopInParams) error {
	_, err := q.db.ExecContext(ctx, insertStaticAddressLoopIn,
		arg.SwapHash,
		arg.SwapInvoice,
		arg.LastHop,
		arg.PaymentTimeoutSeconds,
		arg.QuotedSwapFeeSatoshis,
		arg.DepositOutpoints,
		arg.SelectedAmount,
		arg.HtlcTxFeeRateSatKw,
		arg.HtlcTimeoutSweepTxID,
		arg.HtlcTimeoutSweepAddress,
	)
	return err
}

const insertStaticAddressMetaUpdate = `-- name: InsertStaticAddressMetaUpdate :exec
INSERT INTO static_address_swap_updates (
    swap_hash,
    update_state,
    update_timestamp
) VALUES (
     $1,
     $2,
     $3
 )
`

type InsertStaticAddressMetaUpdateParams struct {
	SwapHash        []byte
	UpdateState     string
	UpdateTimestamp time.Time
}

func (q *Queries) InsertStaticAddressMetaUpdate(ctx context.Context, arg InsertStaticAddressMetaUpdateParams) error {
	_, err := q.db.ExecContext(ctx, insertStaticAddressMetaUpdate, arg.SwapHash, arg.UpdateState, arg.UpdateTimestamp)
	return err
}

const isStored = `-- name: IsStored :one
SELECT EXISTS (
    SELECT 1
    FROM static_address_swaps
    WHERE swap_hash = $1
)
`

func (q *Queries) IsStored(ctx context.Context, swapHash []byte) (bool, error) {
	row := q.db.QueryRowContext(ctx, isStored, swapHash)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const mapDepositToSwap = `-- name: MapDepositToSwap :exec
UPDATE
    deposits
SET
    swap_hash = $2
WHERE
    deposit_id = $1
`

type MapDepositToSwapParams struct {
	DepositID []byte
	SwapHash  []byte
}

func (q *Queries) MapDepositToSwap(ctx context.Context, arg MapDepositToSwapParams) error {
	_, err := q.db.ExecContext(ctx, mapDepositToSwap, arg.DepositID, arg.SwapHash)
	return err
}

const swapHashForDepositID = `-- name: SwapHashForDepositID :one
SELECT
    swap_hash
FROM
    deposits
WHERE
    deposit_id = $1
`

func (q *Queries) SwapHashForDepositID(ctx context.Context, depositID []byte) ([]byte, error) {
	row := q.db.QueryRowContext(ctx, swapHashForDepositID, depositID)
	var swap_hash []byte
	err := row.Scan(&swap_hash)
	return swap_hash, err
}

const updateStaticAddressLoopIn = `-- name: UpdateStaticAddressLoopIn :exec
UPDATE static_address_swaps
SET
    htlc_tx_fee_rate_sat_kw = $2,
    htlc_timeout_sweep_tx_id = $3
WHERE
    swap_hash = $1
`

type UpdateStaticAddressLoopInParams struct {
	SwapHash             []byte
	HtlcTxFeeRateSatKw   int64
	HtlcTimeoutSweepTxID sql.NullString
}

func (q *Queries) UpdateStaticAddressLoopIn(ctx context.Context, arg UpdateStaticAddressLoopInParams) error {
	_, err := q.db.ExecContext(ctx, updateStaticAddressLoopIn, arg.SwapHash, arg.HtlcTxFeeRateSatKw, arg.HtlcTimeoutSweepTxID)
	return err
}