order

type AccountDiff struct {
	// AccountKeyRaw is the raw serialized account public key this diff
	// refers to.
	AccountKeyRaw [33]byte

	// AccountKey is the parsed account public key this diff refers to.
	AccountKey *btcec.PublicKey

	// EndingState is the ending on-chain state of the account after the
	// executed batch as the auctioneer calculated it.
	EndingState auctioneerrpc.AccountDiff_AccountState

	// EndingBalance is the ending balance for a trader's account.
	EndingBalance btcutil.Amount

	// OutpointIndex is the index of the re-created account output in the
	// batch transaction. This is set to -1 if no account output has been
	// created because the leftover value was considered to be dust.
	OutpointIndex int32

	// NewExpiry is the new expiry height for this account. This field
	// can be safely ignored if its value is 0.
	NewExpiry uint32

	// NewVersion is the version of the account that should be used after
	// the batch went through. This field influences the type of account
	// output that is created by this batch. If this differs from the
	// CurrentVersion, then the account was upgraded in this batch.
	NewVersion account.Version
}

type AccountNonces map[[33]byte]poolscript.MuSig2Nonces

type AccountTally struct {
	// EndingBalance is the ending balance for a trader's account.
	EndingBalance btcutil.Amount

	// TotalExecutionFeesPaid is the total amount of fees a trader paid to
	// the venue.
	TotalExecutionFeesPaid btcutil.Amount

	// TotalTakerFeesPaid is the total amount of fees the trader paid to
	// purchase any channels in this batch.
	TotalTakerFeesPaid btcutil.Amount

	// TotalMakerFeesAccrued is the total amount of fees the trader gained
	// by selling channels in this batch.
	TotalMakerFeesAccrued btcutil.Amount

	// NumChansCreated is the number of new channels that were created for
	// one account in a batch. This is needed to calculate the chain fees
	// that need to be paid from that account.
	NumChansCreated uint32
}

type Ask struct {
	// Kit contains all the common order parameters.
	Kit

	// AnnouncementConstraints specifies the constraints for the matched
	// channels in terms of announced/unannounced.
	AnnouncementConstraints ChannelAnnouncementConstraints

	// ConfirmationConstraints specifies the constraints for the matched
	// channels in terms of confirmed/zero conf.
	ConfirmationConstraints ChannelConfirmationConstraints
}

type AuctionType uint32

type Batch struct {
	// ID is the batch's unique ID. If multiple messages come in with the
	// same ID, they are to be considered to be the _same batch_ with
	// updated matches. Any previous version of a batch with that ID should
	// be discarded in that case.
	ID BatchID

	// BatchVersion is the version of the batch verification protocol.
	Version BatchVersion

	// MatchedOrders is a map between all trader's orders and the other
	// orders that were matched to them in the batch.
	MatchedOrders map[Nonce][]*MatchedOrder

	// AccountDiffs is the calculated difference for each trader's account
	// that was involved in the batch.
	AccountDiffs []*AccountDiff

	// ExecutionFee is the FeeSchedule that was used by the server to
	// calculate the execution fee.
	ExecutionFee terms.FeeSchedule

	// ClearingPrices is a map of the lease duration markets and the fixed
	// rate the orders were cleared at within that market.
	ClearingPrices map[uint32]FixedRatePremium

	// BatchTX is the complete batch transaction with all non-witness data
	// fully populated.
	BatchTX *wire.MsgTx

	// BatchTxFeeRate is the miner fee rate in sat/kW that was chosen for
	// the batch transaction.
	BatchTxFeeRate chainfee.SatPerKWeight

	// FeeRebate is the rebate that was offered to the trader if another
	// batch participant wanted to pay more fees for a faster confirmation.
	FeeRebate btcutil.Amount

	// HeightHint represents the earliest absolute height in the chain in
	// which the batch transaction can be found within. This will be used by
	// traders to base off their absolute channel lease maturity height.
	HeightHint uint32

	// ServerNonces is the map of all the auctioneer's public nonces for
	// each of the (Taproot enabled) accounts in the batch, keyed by the
	// account's trader key. This is volatile (in-memory only) information
	// that is _not_ persisted as part of the batch snapshot.
	ServerNonces AccountNonces

	// PreviousOutputs is the list of previous output scripts and amounts
	// (UTXO information) for all the inputs being spent by the batch
	// transaction. This is volatile (in-memory only) information that is
	// _not_ persisted as part of the batch snapshot.
	PreviousOutputs []*wire.TxOut
}

type BatchID [33]byte

type BatchSignature map[[33]byte][]byte

type BatchSigner interface {
	// Sign returns the witness stack of all account inputs in a batch that
	// belong to the trader.
	Sign(*Batch) (BatchSignature, AccountNonces, error)
}

type BatchStorer interface {
	// StorePendingBatch makes sure all changes executed by a pending batch
	// are correctly and atomically stored to the database.
	StorePendingBatch(_ *Batch) error

	// MarkBatchComplete marks a pending batch as complete, allowing a
	// trader to participate in a new batch.
	MarkBatchComplete() error
}

type BatchVerifier interface {
	// Verify makes sure the batch prepared by the server is correct and
	// can be accepted by the trader.
	Verify(batch *Batch, bestHeight uint32) error
}

type BatchVersion uint32

type Bid struct {
	// Kit contains all the common order parameters.
	Kit

	// MinNodeTier is the minimum node tier that this order should be
	// matched with. Only Asks backed by nodes on this tier or above will
	// be matched with this bid.
	MinNodeTier NodeTier

	// SelfChanBalance is the initial outbound balance that should be added
	// to the channel resulting from matching this bid by moving additional
	// funds from the taker's account into the channel.
	SelfChanBalance btcutil.Amount

	// SidecarTicket indicates, if non-nil, that the channel being purchased
	// with this bid should be opened to a node other than the caller's
	// node. The lease recipient is another Pool (light) node that
	// authenticates itself to the auctioneer using the information in this
	// ticket (the information exchange between bidder and lease recipient
	// happens out of band). This will only be used if the order version is
	// VersionSidecarChannel or greater.
	SidecarTicket *sidecar.Ticket

	// UnannouncedChannel signals if the resulting channel needs to be
	// announced or not.
	UnannouncedChannel bool

	// ZeroConfChannel signals if the resulting channels need to be zero
	// conf or not.
	ZeroConfChannel bool
}

type ChanTypeSelector func() ChannelType

type ChannelAnnouncementConstraints uint8

type ChannelConfirmationConstraints uint8

type ChannelType uint8

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

type Fetcher func(Nonce) (Order, error)

type FixedRatePremium uint32

type Kit struct {

	// Preimage is the randomly generated preimage to the nonce hash. It is
	// only known to the trader client.
	Preimage lntypes.Preimage

	// AuctionType is the market where this offer should be considered in.
	AuctionType AuctionType

	// Version is the feature version of this order. Can be used to
	// distinguish between certain feature sets or to signal feature flags.
	Version Version

	// State is the current state the order is in as it was last seen by the
	// client. The real state is tracked on the auction server, so this can
	// be out of sync if there was no connection for a while.
	State State

	// FixedRate is the fixed order rate expressed in parts per million.
	FixedRate uint32

	// Amt is the order amount in satoshis.
	Amt btcutil.Amount

	// Units the total amount of units that the target amount maps to.
	Units SupplyUnit

	// UnitsUnfulfilled is the number of units that have not been filled yet
	// and are still available for matching against other orders.
	UnitsUnfulfilled SupplyUnit

	// MultiSigKeyLocator is the key locator used to obtain the multi sig
	// key. This will be needed for operations that require a signature
	// under said key and will therefore only be known to the trader client.
	// This key will only be derived from the connected lnd after the order
	// has been formally validated.
	MultiSigKeyLocator keychain.KeyLocator

	// MaxBatchFeeRate is the maximum fee rate the trader is willing to
	// pay for the batch transaction, in sat/kW.
	MaxBatchFeeRate chainfee.SatPerKWeight

	// AcctKey is key of the account the order belongs to.
	AcctKey [33]byte

	// LeaseDuration identifies how long this order wishes to acquire or
	// lease out capital in the Lightning Network for.
	LeaseDuration uint32

	// MinUnitsMatch signals the minimum number of units that must be
	// matched against an order.
	MinUnitsMatch SupplyUnit

	// ChannelType denotes the channel type that must be used for the
	// resulting matched channels.
	ChannelType ChannelType

	// AllowedNodeIDs is the list of node ids this order is allowed to
	// match with.
	AllowedNodeIDs [][33]byte

	// NotAllowedNodeIDs is the list of node ids this order is not allowed
	// to match with.
	NotAllowedNodeIDs [][33]byte

	// IsPublic is the flag used to signal if the details of this order can
	// be shared in public marketplaces or not.
	IsPublic bool
	// contains filtered or unexported fields
}

type Manager interface {
	// Start starts all concurrent tasks the manager is responsible for.
	Start() error

	// Stop stops all concurrent tasks the manager is responsible for.
	Stop()

	// PrepareOrder validates an order, signs it and then stores it locally.
	PrepareOrder(ctx context.Context, order Order, acct *account.Account,
		terms *terms.AuctioneerTerms) (*ServerOrderParams, error)

	// OrderMatchValidate verifies an incoming batch is sane before
	// accepting it.
	OrderMatchValidate(batch *Batch, bestHeight uint32) error

	// HasPendingBatch returns whether a pending batch is currently being
	// processed.
	HasPendingBatch() bool

	// PendingBatch returns the current pending batch being validated.
	PendingBatch() *Batch

	// BatchSign returns the witness stack of all account inputs in a batch
	// that belong to the trader.
	BatchSign() (BatchSignature, AccountNonces, error)

	// BatchFinalize marks a batch as complete upon receiving the finalize
	// message from the auctioneer.
	BatchFinalize(batchID BatchID) error

	// OurNodePubkey returns our lnd node's public identity key or an error
	// if the manager wasn't fully started yet.
	OurNodePubkey() ([33]byte, error)
}

type ManagerConfig struct {
	// Store is responsible for storing and retrieving order information.
	Store Store

	AcctStore account.Store

	// Lightning is used to access the main RPC to get information about the
	// lnd node that poold is connected to.
	Lightning lndclient.LightningClient

	// Wallet is responsible for deriving new keys we need to sign orders.
	Wallet lndclient.WalletKitClient

	// Signer is used to sign orders before submitting them to the server.
	Signer lndclient.SignerClient

	// BatchVersion is the batch version that we should use to verify new
	// batches against.
	BatchVersion BatchVersion
}

type MatchState uint8

type MatchedOrder struct {
	// Order contains the details of the other order as sent by the server.
	Order Order

	// MultiSigKey is a key of the node creating the order that will be used
	// to craft the channel funding TX's 2-of-2 multi signature output.
	MultiSigKey [33]byte

	// NodeKey is the identity public key of the node creating the order.
	NodeKey [33]byte

	// NodeAddrs is the list of network addresses of the node creating the
	// order.
	NodeAddrs []net.Addr

	// UnitsFilled is the number of units that were matched by this order.
	UnitsFilled SupplyUnit
}

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

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

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

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

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

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

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

type Modifier func(*Kit)

type NodeTier uint32

type Nonce [32]byte

type Order interface {
	// Nonce is the unique identifier of each order and MUST be created by
	// hashing a new random preimage for each new order. The nonce is what
	// is signed in the order signature.
	Nonce() Nonce

	// Details returns the Kit of the order.
	Details() *Kit

	// Type returns the order type.
	Type() Type

	// Digest returns a deterministic SHA256 hash over the contents of an
	// order. Deterministic in this context means that if two orders have
	// the same content, their digest have to be identical as well.
	Digest() ([hashSize]byte, error)

	// ReservedValue returns the maximum value that could be deducted from
	// the account if the order is matched, and therefore has to be
	// reserved to ensure the trader can afford it.
	ReservedValue(feeSchedule terms.FeeSchedule,
		accountVersion account.Version) btcutil.Amount
}

type ParseOption func(*parseOptions)

type Quote struct {
	// TotalPremium is the total order premium in satoshis for filling the
	// entire order.
	TotalPremium btcutil.Amount

	// RatePerBlock is the fixed order rate expressed as a fraction instead
	// of parts per billion.
	RatePerBlock float64

	// TotalExecutionFee is the total execution fee in satoshis that needs
	// to be paid to the auctioneer for executing the entire order.
	TotalExecutionFee btcutil.Amount

	// WorstCaseChainFee is the chain fees that have to be paid in the worst
	// case scenario where fees spike up to the given max batch fee rate and
	// the order is executed in the maximum parts possible (amount divided
	// by minimum channel amount).
	WorstCaseChainFee btcutil.Amount
}

type ServerOrderParams struct {
	// MultiSigKey is a key of the node creating the order that will be used
	// to craft the channel funding TX's 2-of-2 multi signature output.
	MultiSigKey [33]byte

	// NodePubkey is the identity public key of the node submitting the
	// order.
	NodePubkey [33]byte

	// Addrs is a list of network addresses through which the node
	// submitting the order can be reached.
	Addrs []net.Addr

	// RawSig is the raw signature over the order digest signed with the
	// trader's account key.
	RawSig []byte
}

type State uint8

type Store interface {
	// SubmitOrder stores an order by using the orders's nonce as an
	// identifier. If an order with the given nonce already exists in the
	// store, ErrOrderExists is returned.
	SubmitOrder(Order) error

	// UpdateOrder updates an order in the database according to the given
	// modifiers.
	UpdateOrder(Nonce, ...Modifier) error

	// UpdateOrders atomically updates a list of orders in the database
	// according to the given modifiers.
	UpdateOrders([]Nonce, [][]Modifier) error

	// GetOrder returns an order by looking up the nonce. If no order with
	// that nonce exists in the store, ErrNoOrder is returned.
	GetOrder(Nonce) (Order, error)

	// GetOrders returns all orders that are currently known to the store.
	GetOrders() ([]Order, error)

	// DeleteOrder removes the order with the given Nonce.
	//
	// Note: this method deletes the order without checking if it is
	// referenced somewhere else (e.g. pending batch).
	DeleteOrder(Nonce) error

	// StorePendingBatch atomically stages all modified orders/accounts as a
	// result of a pending batch. If any single operation fails, the whole
	// set of changes is rolled back. Once the batch has been
	// finalized/confirmed on-chain, then the stage modifications will be
	// applied atomically as a result of MarkBatchComplete.
	StorePendingBatch(_ *Batch, orders []Nonce,
		orderModifiers [][]Modifier, accounts []*account.Account,
		accountModifiers [][]account.Modifier) error

	// MarkBatchComplete marks a pending batch as complete, applying any
	// staged modifications necessary, and allowing a trader to participate
	// in a new batch. If a pending batch is not found, ErrNoPendingBatch is
	// returned.
	MarkBatchComplete() error
}

type SupplyUnit uint64

type Type uint8

type UserError struct {
	FailMsg string
	Details *auctioneerrpc.InvalidOrder
}

type Version uint32