loopdb

type BaseDB struct {
	*sql.DB

	*sqlc.Queries
	// contains filtered or unexported fields
}

type BatchInsertUpdateData struct {
	Time  time.Time
	State SwapStateData
}

type ChannelSet []uint64

type ErrSqlUniqueConstraintViolation struct {
	DbError error
}

type HtlcKeys struct {
	// SenderScriptKey is the sender's public key that is used in the HTLC,
	// specifically when constructing the script spend scripts.
	SenderScriptKey [33]byte

	// SenderInternalPubKey is the sender's internal pubkey that is used in
	// taproot HTLCs as part of the aggregate internal key.
	SenderInternalPubKey [33]byte

	// ReceiverScriptKey is the receiver's public key that is used in the
	// HTLC, specifically when constructing the script spend scripts.
	ReceiverScriptKey [33]byte

	// ReceiverInternalPubKey is the sender's internal pubkey that is used
	// in taproot HTLCs as part of the aggregate internal key.
	ReceiverInternalPubKey [33]byte

	// ClientScriptKeyLocator is the client's key locator for the key used
	// in the HTLC script spend scripts.
	ClientScriptKeyLocator keychain.KeyLocator
}

type Loop struct {
	Hash   lntypes.Hash
	Events []*LoopEvent
}

type LoopEvent struct {
	SwapStateData

	// Time is the time that this swap had its state changed.
	Time time.Time
}

type LoopIn struct {
	Loop

	Contract *LoopInContract
}

type LoopInContract struct {
	SwapContract

	// SweepConfTarget specifies the targeted confirmation target for the
	// client sweep tx.
	HtlcConfTarget int32

	// LastHop is the last hop to use for the loop in swap (optional).
	LastHop *route.Vertex

	// ExternalHtlc specifies whether the htlc is published by an external
	// source.
	ExternalHtlc bool
}

type LoopOut struct {
	Loop

	// Contract is the active contract for this swap. It describes the
	// precise details of the swap including the final fee, CLTV value,
	// etc.
	Contract *LoopOutContract
}

type LoopOutContract struct {
	// SwapContract contains basic information pertaining to this swap.
	// Each swap type has a base contract, then swap specific information
	// on top of it.
	SwapContract

	// DestAddr is the destination address of the loop out swap.
	DestAddr btcutil.Address

	// IsExternalAddr indicates whether the destination address does not
	// belong to the backing lnd node.
	IsExternalAddr bool

	// SwapInvoice is the invoice that is to be paid by the client to
	// initiate the loop out swap.
	SwapInvoice string

	// MaxSwapRoutingFee is the maximum off-chain fee in msat that may be
	// paid for the swap payment to the server.
	MaxSwapRoutingFee btcutil.Amount

	// SweepConfTarget specifies the targeted confirmation target for the
	// client sweep tx.
	SweepConfTarget int32

	// HtlcConfirmations is the number of confirmations we require the on
	// chain htlc to have before proceeding with the swap.
	HtlcConfirmations uint32

	// OutgoingChanSet is the set of short ids of channels that may be used.
	// If empty, any channel may be used.
	OutgoingChanSet ChannelSet

	// PrepayInvoice is the invoice that the client should pay to the
	// server that will be returned if the swap is complete.
	PrepayInvoice string

	// MaxPrepayRoutingFee is the maximum off-chain fee in msat that may be
	// paid for the prepayment to the server.
	MaxPrepayRoutingFee btcutil.Amount

	// SwapPublicationDeadline is a timestamp that the server commits to
	// have the on-chain swap published by. It is set by the client to
	// allow the server to delay the publication in exchange for possibly
	// lower fees.
	SwapPublicationDeadline time.Time
}

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

type PostgresConfig struct {
	SkipMigrations     bool   `long:"skipmigrations" description:"Skip applying migrations on startup."`
	Host               string `long:"host" description:"Database server hostname."`
	Port               int    `long:"port" description:"Database server port."`
	User               string `long:"user" description:"Database user."`
	Password           string `long:"password" description:"Database user's password."`
	DBName             string `long:"dbname" description:"Database name to use."`
	MaxOpenConnections int32  `long:"maxconnections" description:"Max open connections to keep alive to the database server."`
	RequireSSL         bool   `long:"requiressl" description:"Whether to require using SSL (mode: require) when connecting to the server."`
}

type PostgresStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type ProtocolVersion uint32

type SqliteConfig struct {
	// SkipMigrations if true, then all the tables will be created on start
	// up if they don't already exist.
	SkipMigrations bool `long:"skipmigrations" description:"Skip applying migrations on startup."`

	// DatabaseFileName is the full file path where the database file can be
	// found.
	DatabaseFileName string `long:"dbfile" description:"The full path to the database."`
}

type SqliteSwapStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

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

type StoreMock struct {
	LoopOutSwaps   map[lntypes.Hash]*LoopOutContract
	LoopOutUpdates map[lntypes.Hash][]SwapStateData

	LoopInSwaps   map[lntypes.Hash]*LoopInContract
	LoopInUpdates map[lntypes.Hash][]SwapStateData
	// contains filtered or unexported fields
}

type SwapContract struct {
	// Preimage is the preimage for the swap.
	Preimage lntypes.Preimage

	// AmountRequested is the total amount of the swap.
	AmountRequested btcutil.Amount

	// HtlcKeys holds all keys used in the swap HTLC construction.
	HtlcKeys HtlcKeys

	// CltvExpiry is the total absolute CLTV expiry of the swap.
	CltvExpiry int32

	// MaxSwapFee is the maximum we are willing to pay the server for the
	// swap.
	MaxSwapFee btcutil.Amount

	// MaxMinerFee is the maximum in on-chain fees that we are willing to
	// spend.
	MaxMinerFee btcutil.Amount

	// InitiationHeight is the block height at which the swap was
	// initiated.
	InitiationHeight int32

	// InitiationTime is the time at which the swap was initiated.
	InitiationTime time.Time

	// Label contains an optional label for the swap.
	Label string

	// ProtocolVersion stores the protocol version when the swap was
	// created.
	ProtocolVersion ProtocolVersion
}

type SwapCost struct {
	// Swap is the amount paid to the server.
	Server btcutil.Amount

	// Onchain is the amount paid to miners for the onchain tx.
	Onchain btcutil.Amount

	// Offchain is the amount paid in routing fees.
	Offchain btcutil.Amount
}

type SwapState uint8

type SwapStateData struct {
	// SwapState is the state the swap is in.
	State SwapState

	// Cost are the accrued (final) costs so far.
	Cost SwapCost

	// HtlcTxHash is the tx id of the confirmed htlc.
	HtlcTxHash *chainhash.Hash
}

type SwapStateType uint8

type SwapStore interface {
	// FetchLoopOutSwaps returns all swaps currently in the store.
	FetchLoopOutSwaps(ctx context.Context) ([]*LoopOut, error)

	// FetchLoopOutSwap returns the loop out swap with the given hash.
	FetchLoopOutSwap(ctx context.Context, hash lntypes.Hash) (*LoopOut, error)

	// CreateLoopOut adds an initiated swap to the store.
	CreateLoopOut(ctx context.Context, hash lntypes.Hash,
		swap *LoopOutContract) error

	// BatchCreateLoopOut creates a batch of loop out swaps to the store.
	BatchCreateLoopOut(ctx context.Context,
		swaps map[lntypes.Hash]*LoopOutContract) error

	// UpdateLoopOut stores a new event for a target loop out swap. This
	// appends to the event log for a particular swap as it goes through
	// the various stages in its lifetime.
	UpdateLoopOut(ctx context.Context, hash lntypes.Hash, time time.Time,
		state SwapStateData) error

	// FetchLoopInSwaps returns all swaps currently in the store.
	FetchLoopInSwaps(ctx context.Context) ([]*LoopIn, error)

	// CreateLoopIn adds an initiated swap to the store.
	CreateLoopIn(ctx context.Context, hash lntypes.Hash,
		swap *LoopInContract) error

	// BatchCreateLoopIn creates a batch of loop in swaps to the store.
	BatchCreateLoopIn(ctx context.Context,
		swaps map[lntypes.Hash]*LoopInContract) error

	// UpdateLoopIn stores a new event for a target loop in swap. This
	// appends to the event log for a particular swap as it goes through
	// the various stages in its lifetime.
	UpdateLoopIn(ctx context.Context, hash lntypes.Hash, time time.Time,
		state SwapStateData) error

	// BatchInsertUpdate inserts batch of swap updates to the store.
	BatchInsertUpdate(ctx context.Context,
		updateData map[lntypes.Hash][]BatchInsertUpdateData) error

	// PutLiquidityParams writes the serialized `manager.Parameters` bytes
	// into the bucket.
	//
	// NOTE: it's the caller's responsibility to encode the param. Atm,
	// it's encoding using the proto package's `Marshal` method.
	PutLiquidityParams(ctx context.Context, params []byte) error

	// FetchLiquidityParams reads the serialized `manager.Parameters` bytes
	// from the bucket.
	//
	// NOTE: it's the caller's responsibility to decode the param. Atm,
	// it's decoding using the proto package's `Unmarshal` method.
	FetchLiquidityParams(ctx context.Context) ([]byte, error)

	// Close closes the underlying database.
	Close() error
}

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

type TxOptions interface {
	// ReadOnly returns true if the transaction should be read only.
	ReadOnly() bool
}