chanevents

type BatchedSQLQueries interface {
	SQLQueries

	sqldb.BatchedTx[SQLQueries]
}

type Channel struct {
	// ID is the database ID of the channel.
	ID int64

	// ChannelPoint is the channel point of the channel.
	ChannelPoint string

	// ShortChannelID is the short channel ID of the channel.
	ShortChannelID uint64

	// PeerID is the database ID of the peer that this channel is with.
	PeerID int64
}

type ChannelEvent struct {
	// ID is the database ID of the event.
	ID int64

	// ChannelID is the database ID of the channel that this event is
	// associated with.
	ChannelID int64

	// EventType is the type of the event.
	EventType EventType

	// Timestamp is the time that the event occurred.
	Timestamp time.Time

	// LocalBalance is the local balance of the channel at the time of the
	// event. This is only populated for balance update events.
	LocalBalance fn.Option[btcutil.Amount]

	// RemoteBalance is the remote balance of the channel at the time of the
	// event. This is only populated for balance update events.
	RemoteBalance fn.Option[btcutil.Amount]

	// IsSync indicates whether this event was recorded during an initial
	// sync rather than from a live subscription.
	IsSync bool
}

type Config struct {
	// MaxEvents is the maximum number of channel events to retain. Once the
	// table exceeds this count, the oldest events are pruned. This operates
	// as a hard ceiling on database size to prevent disk filling. A value
	// of 0 disables this limit.
	MaxEvents uint64 `` /* 232-byte string literal not displayed */

	// Retention is the minimum duration of channel events to keep. Events
	// older than this window are pruned, even if the max-events limit is
	// not exceeded. If max-events is exceeded, newer events can still be
	// pruned to enforce the size ceiling. A value of 0 disables this limit.
	Retention time.Duration `` /* 210-byte string literal not displayed */
}

type EventType int16

type EventsSource interface {
	// GetLatestChannelUpdateBefore returns the latest channel event before
	// the given time, or (nil, nil) if no event predates it.
	GetLatestChannelUpdateBefore(ctx context.Context, channelID int64,
		before time.Time) (*ChannelEvent, error)

	// GetChannelEvents fetches up to limit events for a channel with id >
	// afterID and timestamp in [startTime, endTime), ordered by id ASC.
	// Callers page through a range by passing the last returned id as
	// afterID until a short page comes back.
	GetChannelEvents(ctx context.Context, channelID, afterID int64,
		startTime, endTime time.Time,
		limit int32) ([]*ChannelEvent, error)

	// GetChannelByShortChanID resolves an scid to a Channel, returning
	// ErrUnknownChannel when no row matches.
	GetChannelByShortChanID(ctx context.Context,
		shortChannelID uint64) (*Channel, error)

	// ScidToPeerMap returns the historically recorded scid→peer index,
	// including closed channels.
	ScidToPeerMap(ctx context.Context) (map[uint64]string, error)
}

type ForwardingAbility struct {
	// EffectiveUptime is the time the pair held at least the liquidity floor
	// of directional forwardable liquidity over the window.
	EffectiveUptime time.Duration

	// ForwardedMsat is the total successfully forwarded amount over the
	// window, in millisatoshis.
	ForwardedMsat lnwire.MilliSatoshi

	// FeeMsat is the total fee earned on the pair's forwards over the
	// window.
	FeeMsat lnwire.MilliSatoshi

	// Forwards is how many successful forwards the pair carried. It decides
	// whether the pair forwarded at all, since the fee total can be zero
	// for one that did under a zero-fee policy.
	Forwards int64
}

type ForwardingAnalyzer struct {
	// contains filtered or unexported fields
}

type Monitor struct {
	// contains filtered or unexported fields
}

type Peer struct {
	// ID is the database ID of the peer.
	ID int64

	// PubKey is the public key of the peer.
	PubKey string
}

type PeerPair struct {
	PeerIn  string
	PeerOut string
}

type Queries interface {
	InsertPeer(ctx context.Context, pubkey string) (int64, error)

	GetPeerByPubKey(ctx context.Context, pubkey string) (sqlc.Peer, error)

	InsertChannel(ctx context.Context,
		arg sqlc.InsertChannelParams) (int64, error)

	GetChannelByChanPoint(ctx context.Context,
		channelPoint string) (sqlc.Channel, error)

	GetChannelByShortChanID(ctx context.Context,
		shortChannelID int64) (sqlc.Channel, error)

	InsertChannelEvent(ctx context.Context,
		arg sqlc.InsertChannelEventParams) error

	GetChannelEvents(ctx context.Context,
		arg sqlc.GetChannelEventsParams) ([]sqlc.ChannelEvent, error)

	GetLatestChannelEventBefore(ctx context.Context,
		arg sqlc.GetLatestChannelEventBeforeParams) (
		sqlc.ChannelEvent,
		error,
	)

	GetChannels(ctx context.Context) ([]sqlc.GetChannelsRow, error)

	PruneChannelEventsBySize(ctx context.Context, offset int32) (int64,
		error)

	PruneChannelEventsByAge(ctx context.Context, timestamp time.Time) (
		int64, error)
}

type SQLQueries interface {
	Queries
}

type SQLQueriesExecutor[T any] struct {
	*sqldb.TransactionExecutor[T]

	SQLQueries
}

type Store struct {

	// BaseDB represents the underlying database connection.
	*sqldb.BaseDB
	// contains filtered or unexported fields
}