account

type Account struct {
	// Value is the value of the account reflected in on-chain output that
	// backs the existence of an account.
	Value btcutil.Amount

	// Expiry is the expiration block height of an account. After this
	// point, the trader is able to withdraw the funds from their account
	// without cooperation of the auctioneer.
	Expiry uint32

	// TraderKey is the base trader's key in the 2-of-2 multi-sig
	// construction of a CLM account. This key will never be included in the
	// account script, but rather it will be tweaked with the per-batch key
	// and the account secret to prevent script reuse and provide plausible
	// deniability between account outputs to third parties.
	TraderKey *keychain.KeyDescriptor

	// AuctioneerKey is the base auctioneer's key in the 2-of-2 multi-sig
	// construction of a CLM account. This key will never be included in the
	// account script, but rather it will be tweaked with the per-batch
	// trader key to prevent script reuse and provide plausible deniability
	// between account outputs to third parties.
	AuctioneerKey *btcec.PublicKey

	// BatchKey is the batch key that is used to tweak the trader key of an
	// account with, along with the secret. This will be incremented by the
	// curve's base point each time the account is modified or participates
	// in a cleared batch to prevent output script reuse for accounts
	// on-chain.
	BatchKey *btcec.PublicKey

	// Secret is a static shared secret between the trader and the
	// auctioneer that is used to tweak the trader key of an account with,
	// along with the batch key. This ensures that only the trader and
	// auctioneer are able to successfully identify every past/future output
	// of an account.
	Secret [32]byte

	// State describes the state of the account.
	State State

	// HeightHint is the earliest height in the chain at which we can find
	// the account output in a block.
	HeightHint uint32

	// OutPoint is the outpoint of the output used to fund the account. This
	// only exists once the account has reached StatePendingOpen.
	OutPoint wire.OutPoint

	// LatestTx is the latest transaction of an account.
	//
	// NOTE: This is only nil within the StateInitiated phase. There are no
	// guarantees as to whether the transaction has its witness populated.
	LatestTx *wire.MsgTx

	// Version is the version of the account.
	Version Version
}

type AccountTxLabel struct {
	Key           string          `json:"key"`
	Action        Action          `json:"action"`
	ExpiryHeight  uint32          `json:"expiry_height"`
	OutputIndex   uint32          `json:"output_index"`
	IsExpirySpend bool            `json:"expiry_spend"`
	TxFee         *btcutil.Amount `json:"tx_fee"`
	BalanceDiff   btcutil.Amount  `json:"balance_diff"`
}

type Action string

type Auctioneer interface {
	// ReserveAccount reserves an account of the specified value with the
	// auctioneer. The auctioneer checks the account value against current
	// min/max values configured. If the value is valid, it returns the
	// public key we should use for them in our 2-of-2 multi-sig
	// construction. To address an edge case in the account recovery where
	// the trader crashes before confirming the account with the auctioneer,
	// we also send the trader key and expiry along with the reservation.
	ReserveAccount(context.Context, btcutil.Amount, uint32,
		*btcec.PublicKey, Version) (*Reservation, error)

	// InitAccount initializes an account with the auctioneer such that it
	// can be used once fully confirmed.
	InitAccount(context.Context, *Account) error

	// ModifyAccount sends an intent to the auctioneer that we'd like to
	// modify the account with the associated trader key. The auctioneer's
	// signature is returned, allowing us to broadcast a transaction
	// spending from the account allowing our modifications to take place.
	// If the account spend is a MuSig2 spend, then the trader's nonces must
	// be sent and the server's nonces are returned upon success. The inputs
	// and outputs provided should exclude the account input being spent and
	// the account output potentially being recreated, since the auctioneer
	// can construct those themselves. If no modifiers are present, then the
	// auctioneer will interpret the request as an account closure. The
	// previous outputs must always contain the UTXO information for _every_
	// input of the transaction, so inputs+account_input.
	ModifyAccount(ctx context.Context, acct *Account, inputs []*wire.TxIn,
		outputs []*wire.TxOut, modifiers []Modifier,
		traderNonces []byte, previousOutputs []*wire.TxOut) ([]byte,
		[]byte, error)

	// StartAccountSubscription opens a stream to the server and subscribes
	// to all updates that concern the given account, including all orders
	// that spend from that account. Only a single stream is ever open to
	// the server, so a second call to this method will send a second
	// subscription over the same stream, multiplexing all messages into the
	// same connection. A stream can be long-lived, so this can be called
	// for every account as soon as it's confirmed open. This method will
	// return as soon as the authentication was successful. Messages sent
	// from the server can then be received on the FromServerChan channel.
	StartAccountSubscription(context.Context, *keychain.KeyDescriptor) error

	// Terms returns the current dynamic auctioneer terms like max account
	// size, max order duration in blocks and the auction fee schedule.
	Terms(ctx context.Context) (*terms.AuctioneerTerms, error)
}

type BitcoinConfig struct {
	// Host is the bitcoind/btcd instance address.
	Host string

	// User is the bitcoind/btcd user name.
	User string

	// Password is the bitcoind/btcd password.
	Password string

	// HTTPPostMode uses HTTP Post mode if true.
	//
	// Note: bitcoind only supports this mode.
	HTTPPostMode bool

	// UseTLS use TLS to connect if ture.
	//
	// Note: bitcoind only supports non-TLS connections.
	UseTLS bool

	// TLSPath is the path to btcd's TLS certificate. This field is Ignored
	// if TLS is not enabled.
	TLSPath string `long:"tlspath" description:"Path to btcd's TLS certificate, if TLS is enabled"`
}

type FeeExpr interface {
	// CloseOutputs is the list of outputs that should be used for the
	// closing transaction of an account based on the concrete fee
	// expression implementation.
	CloseOutputs(btcutil.Amount, witnessType) ([]*wire.TxOut, error)
}

type Manager interface {
	// Start resumes all account on-chain operation after a restart.
	Start() error

	// Stop safely stops any ongoing operations within the Manager.
	Stop()

	// QuoteAccount returns the expected fee rate and total miner fee to
	// send to an account funding output with the given confTarget.
	QuoteAccount(ctx context.Context, value btcutil.Amount,
		confTarget uint32) (chainfee.SatPerKWeight, btcutil.Amount,
		error)

	// InitAccount handles a request to create a new account with the
	// provided parameters.
	InitAccount(ctx context.Context, value btcutil.Amount, version Version,
		feeRate chainfee.SatPerKWeight, expiry,
		bestHeight uint32) (*Account, error)

	// WatchMatchedAccounts resumes accounts that were just matched in a
	// batch and are expecting the batch transaction to confirm as their
	// next account output. This will cancel all previous spend and conf
	// watchers of all accounts involved in the batch.
	WatchMatchedAccounts(ctx context.Context,
		matchedAccounts []*btcec.PublicKey) error

	// HandleAccountConf takes the necessary steps after detecting the
	// confirmation of an account on-chain.
	HandleAccountConf(traderKey *btcec.PublicKey,
		confDetails *chainntnfs.TxConfirmation) error

	// HandleAccountSpend handles the different spend paths of an account.
	// If an account is spent by the expiration path, it'll always be marked
	// as closed thereafter. If it is spent by the cooperative path with the
	// auctioneer, then the account will only remain open if the spending
	// transaction recreates the account with the expected next account
	// script. Otherwise, it is also marked as closed. In case of multiple
	// consecutive batches with the same account, we only track the spend of
	// the latest batch, after it confirmed. So the account/ output in the
	// spend transaction should always match our database state if it was a
	// cooperative spend.
	HandleAccountSpend(traderKey *btcec.PublicKey,
		spendDetails *chainntnfs.SpendDetail) error

	// HandleAccountExpiry marks an account as expired within the database.
	HandleAccountExpiry(traderKey *btcec.PublicKey, height uint32) error

	// DepositAccount attempts to deposit funds into the account associated
	// with the given trader key such that the new account value is met
	// using inputs sourced from the backing lnd node's wallet. If needed, a
	// change output that does back to lnd may be added to the deposit
	// transaction.
	DepositAccount(ctx context.Context, traderKey *btcec.PublicKey,
		depositAmount btcutil.Amount, feeRate chainfee.SatPerKWeight,
		bestHeight, expiryHeight uint32, newVersion Version) (*Account,
		*wire.MsgTx, error)

	// WithdrawAccount attempts to withdraw funds from the account
	// associated with the given trader key into the provided outputs.
	WithdrawAccount(ctx context.Context, traderKey *btcec.PublicKey,
		outputs []*wire.TxOut, feeRate chainfee.SatPerKWeight,
		bestHeight, expiryHeight uint32, newVersion Version) (*Account,
		*wire.MsgTx, error)

	// RenewAccount updates the expiration of an open/expired account. This
	// will always require a signature from the auctioneer, even after the
	// account has expired, to ensure the auctioneer is aware the account is
	// being renewed.
	RenewAccount(ctx context.Context, traderKey *btcec.PublicKey,
		newExpiry uint32, feeRate chainfee.SatPerKWeight,
		bestHeight uint32, newVersion Version) (*Account, *wire.MsgTx,
		error)

	// BumpAccountFee attempts to bump the fee of an account's most recent
	// transaction. This is done by locating an eligible output for lnd to
	// CPFP, otherwise the fee bump will not succeed. Further invocations of
	// this call for the same account will result in the child being
	// replaced by the higher fee transaction (RBF).
	BumpAccountFee(ctx context.Context, traderKey *btcec.PublicKey,
		newFeeRate chainfee.SatPerKWeight) error

	// CloseAccount attempts to close the account associated with the given
	// trader key. Closing the account requires a signature of the
	// auctioneer if the account has not yet expired. The account funds are
	// swept according to the provided fee expression.
	CloseAccount(ctx context.Context, traderKey *btcec.PublicKey,
		feeExpr FeeExpr, bestHeight uint32) (*wire.MsgTx, error)

	// RecoverAccount re-introduces a recovered account into the database
	// and starts all watchers necessary depending on the account's state.
	RecoverAccount(ctx context.Context, account *Account) error
}

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

	// Auctioneer provides us with the different ways we are able to
	// communicate with our auctioneer during the process of
	// opening/closing/modifying accounts.
	Auctioneer Auctioneer

	// Wallet handles all of our on-chain transaction interaction, whether
	// that is deriving keys, creating transactions, etc.
	Wallet lndclient.WalletKitClient

	// Signer is responsible for deriving shared secrets for accounts
	// between the trader and auctioneer and signing account-related
	// transactions.
	Signer lndclient.SignerClient

	// ChainNotifier is responsible for requesting confirmation and spend
	// notifications for accounts.
	ChainNotifier lndclient.ChainNotifierClient

	// TxSource is a source that provides us with transactions previously
	// broadcast by us.
	TxSource TxSource

	// TxFeeEstimator is an estimator that can calculate the total on-chain
	// fees to send to an account output.
	TxFeeEstimator TxFeeEstimator

	// TxLabelPrefix is set, then all transactions the account manager
	// makes will use this string as a prefix for added transaction labels.
	TxLabelPrefix string

	// ChainParams are the currently used chain parameters.
	ChainParams *chaincfg.Params

	// LndVersion is the version of the connected lnd node.
	LndVersion *verrpc.Version
}

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

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

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

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

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

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

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

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

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

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

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

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

type Modifier func(*Account)

type OutputWithFee struct {
	// PkScript is the destination output script. Note that this may be nil,
	// in which case a wallet-derived P2WKH script should be used.
	PkScript []byte

	// FeeRate is the accompanying fee rate to use to determine the
	// transaction fee.
	FeeRate chainfee.SatPerKWeight
}

type OutputsWithImplicitFee []*wire.TxOut

type RecoveryConfig struct {
	// Network to run recovery on.
	Network string

	// Number of accounts that we are trying to find.
	AccountTarget uint32

	// FirstBlock block marks the initial height for our search.
	FirstBlock uint32

	// LastBlock block marks the final height for our search.
	LastBlock uint32

	// CurrentBlockHeight is the best known height of the main chain.
	CurrentBlockHeight int64

	// BitcoinConfig defines exported config options for the connection to
	// the btcd/bitcoind backend.
	BitcoinConfig *BitcoinConfig

	// Transactions is a list of all transactions that the lnd wallet is
	// currently aware of.
	Transactions []*wire.MsgTx

	// Signer is the signrpc client used to derive the shared key between
	// the server and client.
	Signer lndclient.SignerClient

	// Wallet is the walletrpc client used to derive all possible account
	// keys.
	Wallet lndclient.WalletKitClient

	// InitialBatchKey is the starting value for the auctioneer's batch key.
	InitialBatchKey *btcec.PublicKey

	// AuctioneerPubKey is the static, per-environment public key of the
	// auctioneer.
	AuctioneerPubKey *btcec.PublicKey

	// Quit is a channel that is closed when the server is shutting down.
	Quit chan struct{}
	// contains filtered or unexported fields
}

type Reservation struct {
	// AuctioneerKey is the base auctioneer's key in the 2-of-2 multi-sig
	// construction of a CLM account. This key will never be included in the
	// account script, but rather it will be tweaked with the per-batch
	// trader key to prevent script reuse and provide plausible deniability
	// between account outputs to third parties.
	AuctioneerKey *btcec.PublicKey

	// InitialBatchKey is the initial batch key that is used to tweak the
	// trader key of an account.
	InitialBatchKey *btcec.PublicKey
}

type State uint8

type Store interface {
	// AddAccount adds a record for the account to the database.
	AddAccount(*Account) error

	// UpdateAccount updates an account in the database according to the
	// given modifiers.
	UpdateAccount(*Account, ...Modifier) error

	// Account retrieves the account associated with the given trader key
	// from the database.
	Account(*btcec.PublicKey) (*Account, error)

	// Accounts retrieves all existing accounts.
	Accounts() ([]*Account, error)

	// PendingBatch determines whether we currently have a pending batch.
	// If a batch doesn't exist, ErrNoPendingBatch is returned.
	PendingBatch() error

	// MarkBatchComplete marks the batch with the given ID as complete,
	// indicating that the staged account updates can be applied to disk.
	MarkBatchComplete() error

	// LockID retrieves the global lock ID we'll use to lock any outputs
	// when performing coin selection.
	LockID() (wtxmgr.LockID, error)
}

type TxFeeEstimator interface {
	// EstimateFeeToP2WSH estimates the total chain fees in satoshis to send
	// the given amount to a single P2WSH output with the given target
	// confirmation.
	EstimateFeeToP2WSH(ctx context.Context, amt btcutil.Amount,
		confTarget int32) (btcutil.Amount, error)
}

type TxLabel struct {
	Account AccountTxLabel `json:"account"`
}

type TxSource interface {
	// ListTransactions returns all known transactions of the backing lnd
	// node. It takes a start and end block height which can be used to
	// limit the block range that we query over. These values can be left
	// as zero to include all blocks. To include unconfirmed transactions
	// in the query, endHeight must be set to -1.
	ListTransactions(ctx context.Context, startHeight, endHeight int32,
		opts ...lndclient.ListTransactionsOption) (
		[]lndclient.Transaction, error)
}

type Version uint8