chancloser

type AsymmetricPeerState interface {
	ProtocolState

	// ShouldRouteTo returns true if the target state should process the
	// target event.
	ShouldRouteTo(ProtocolEvent) bool
}

type AuxChanCloser interface {
	// ShutdownBlob returns the set of custom records that should be
	// included in the shutdown message.
	ShutdownBlob(req AuxShutdownReq) (fn.Option[lnwire.CustomRecords],
		error)

	// AuxCloseOutputs returns the set of custom outputs that should be used
	// to construct the co-op close transaction.
	AuxCloseOutputs(desc AuxCloseDesc) (fn.Option[AuxCloseOutputs], error)

	// FinalizeClose is called after the close transaction has been agreed
	// upon.
	FinalizeClose(desc AuxCloseDesc, closeTx *wire.MsgTx) error
}

type AuxCloseDesc struct {
	AuxShutdownReq

	// CloseFee is the closing fee to be paid for this state.
	CloseFee btcutil.Amount

	// CommitFee is the fee that was paid for the last commitment.
	CommitFee btcutil.Amount

	// LocalCloseOutput is the output that the local node should be paid
	// to. This is None if the local party will not have an output on the
	// co-op close transaction.
	LocalCloseOutput fn.Option[CloseOutput]

	// RemoteCloseOutput is the output that the remote node should be paid
	// to. This will be None if the remote party will not have an output on
	// the co-op close transaction.
	RemoteCloseOutput fn.Option[CloseOutput]
}

type AuxCloseOutputs struct {
	// ExtraCloseOutputs is a set of extra outputs that should be included
	// in the close transaction.
	ExtraCloseOutputs []lnwallet.CloseOutput

	// CustomSort is a custom function that can be used to sort the
	// transaction outputs. If this isn't set, then the default BIP-69
	// sorting is used.
	CustomSort lnwallet.CloseSortFunc
}

type AuxShutdownReq struct {
	// ChanPoint is the channel point of the channel that is being shut
	// down.
	ChanPoint wire.OutPoint

	// ShortChanID is the short channel ID of the channel that is being
	// closed.
	ShortChanID lnwire.ShortChannelID

	// Initiator is true if the local node is the initiator of the channel.
	Initiator bool

	// InternalKey is the internal key for the shutdown addr. This will
	// only be set for taproot shutdown addrs.
	InternalKey fn.Option[btcec.PublicKey]

	// CommitBlob is the blob that was included in the last commitment.
	CommitBlob fn.Option[tlv.Blob]

	// FundingBlob is the blob that was included in the funding state.
	FundingBlob fn.Option[tlv.Blob]
}

type ChanCloseCfg struct {
	// Channel is the channel that should be closed.
	Channel Channel

	// MusigSession is used to handle generating musig2 nonces, and also
	// creating the proper set of closing options for taproot channels.
	MusigSession MusigSession

	// BroadcastTx broadcasts the passed transaction to the network.
	BroadcastTx func(*wire.MsgTx, string) error

	// DisableChannel disables a channel, resulting in it not being able to
	// forward payments.
	DisableChannel func(wire.OutPoint) error

	// Disconnect will disconnect from the remote peer in this close.
	Disconnect func() error

	// MaxFee, is non-zero represents the highest fee that the initiator is
	// willing to pay to close the channel.
	MaxFee chainfee.SatPerKWeight

	// ChainParams holds the parameters of the chain that we're active on.
	ChainParams *chaincfg.Params

	// Quit is a channel that should be sent upon in the occasion the state
	// machine should cease all progress and shutdown.
	Quit chan struct{}

	// FeeEstimator is used to estimate the absolute starting co-op close
	// fee.
	FeeEstimator CoopFeeEstimator

	// AuxCloser is an optional interface that can be used to modify the
	// way the co-op close process proceeds.
	AuxCloser fn.Option[AuxChanCloser]
}

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

type ChanStateObserver interface {
	// NoDanglingUpdates returns true if there are no dangling updates in
	// the channel. In other words, there are no active update messages
	// that haven't already been covered by a commit sig.
	NoDanglingUpdates() bool

	// DisableIncomingAdds instructs the channel link to disable process new
	// incoming add messages.
	DisableIncomingAdds() error

	// DisableOutgoingAdds instructs the channel link to disable process
	// new outgoing add messages.
	DisableOutgoingAdds() error

	// DisableChannel attempts to disable a channel (marking it ineligible
	// to forward), and also sends out a network update to disable the
	// channel.
	DisableChannel() error

	// MarkCoopBroadcasted persistently marks that the channel close
	// transaction has been broadcast.
	MarkCoopBroadcasted(*wire.MsgTx, bool) error

	// MarkShutdownSent persists the given ShutdownInfo. The existence of
	// the ShutdownInfo represents the fact that the Shutdown message has
	// been sent by us and so should be re-sent on re-establish.
	MarkShutdownSent(deliveryAddr []byte, isInitiator bool) error

	// FinalBalances is the balances of the channel once it has been
	// flushed. If Some, then this indicates that the channel is now in a
	// state where it's always flushed, so we can accelerate the state
	// transitions.
	FinalBalances() fn.Option[ShutdownBalances]
}

type Channel interface {
	// ChannelPoint returns the channel point of the target channel.
	ChannelPoint() wire.OutPoint

	// LocalCommitmentBlob may return the auxiliary data storage blob for
	// the local commitment transaction.
	LocalCommitmentBlob() fn.Option[tlv.Blob]

	// FundingBlob may return the auxiliary data storage blob related to
	// funding details for the channel.
	FundingBlob() fn.Option[tlv.Blob]

	// MarkCoopBroadcasted persistently marks that the channel close
	// transaction has been broadcast.
	MarkCoopBroadcasted(*wire.MsgTx, lntypes.ChannelParty) error

	// MarkShutdownSent persists the given ShutdownInfo. The existence of
	// the ShutdownInfo represents the fact that the Shutdown message has
	// been sent by us and so should be re-sent on re-establish.
	MarkShutdownSent(info *channeldb.ShutdownInfo) error

	// IsInitiator returns true we are the initiator of the channel.
	IsInitiator() bool

	// ShortChanID returns the scid of the channel.
	ShortChanID() lnwire.ShortChannelID

	// ChanType returns the channel type of the channel.
	ChanType() channeldb.ChannelType

	// FundingTxOut returns the funding output of the channel.
	FundingTxOut() *wire.TxOut

	// AbsoluteThawHeight returns the absolute thaw height of the channel.
	// If the channel is pending, or an unconfirmed zero conf channel, then
	// an error should be returned.
	AbsoluteThawHeight() (uint32, error)

	// LocalBalanceDust returns true if when creating a co-op close
	// transaction, the balance of the local party will be dust after
	// accounting for any anchor outputs. The dust value for the local
	// party is also returned.
	LocalBalanceDust() (bool, btcutil.Amount)

	// RemoteBalanceDust returns true if when creating a co-op close
	// transaction, the balance of the remote party will be dust after
	// accounting for any anchor outputs. The dust value the remote party
	// is also returned.
	RemoteBalanceDust() (bool, btcutil.Amount)

	// CommitBalances returns the local and remote balances in the current
	// commitment state.
	CommitBalances() (btcutil.Amount, btcutil.Amount)

	// CommitFee returns the commitment fee for the current commitment
	// state.
	CommitFee() btcutil.Amount

	// RemoteUpfrontShutdownScript returns the upfront shutdown script of
	// the remote party. If the remote party didn't specify such a script,
	// an empty delivery address should be returned.
	RemoteUpfrontShutdownScript() lnwire.DeliveryAddress

	// CreateCloseProposal creates a new co-op close proposal in the form
	// of a valid signature, the chainhash of the final txid, and our final
	// balance in the created state.
	CreateCloseProposal(proposedFee btcutil.Amount,
		localDeliveryScript []byte, remoteDeliveryScript []byte,
		closeOpt ...lnwallet.ChanCloseOpt,
	) (
		input.Signature, *wire.MsgTx, btcutil.Amount, error)

	// CompleteCooperativeClose persistently "completes" the cooperative
	// close by producing a fully signed co-op close transaction.
	CompleteCooperativeClose(localSig, remoteSig input.Signature,
		localDeliveryScript, remoteDeliveryScript []byte,
		proposedFee btcutil.Amount, closeOpt ...lnwallet.ChanCloseOpt,
	) (*wire.MsgTx, btcutil.Amount, error)
}

type ChannelActive struct {
}

type ChannelFlushed struct {
	// FreshFlush indicates if this is the first time the channel has been
	// flushed, or if this is a flush as part of an RBF iteration.
	FreshFlush bool

	// ShutdownBalances is the balances of the channel once it has been
	// flushed. We tie this to the ChannelFlushed state as this may not be
	// the same as the starting value.
	ShutdownBalances
}

type ChannelFlushing struct {
	// EarlyRemoteOffer is the offer we received from the remote party
	// before we obtained the local channel flushed event. We'll stash this
	// to process later.
	EarlyRemoteOffer fn.Option[OfferReceivedEvent]

	// ShutdownScripts store the set of scripts we'll use to initiate a coop
	// close.
	ShutdownScripts

	// IdealFeeRate is the ideal fee rate we'd like to use for the closing
	// transaction. Once the channel has been flushed, we'll use this as
	// our target fee rate.
	IdealFeeRate fn.Option[chainfee.SatPerVByte]
}

type CloseChannelTerms struct {
	ShutdownScripts

	ShutdownBalances
}

type CloseErr struct {
	ErrState

	*CloseChannelTerms

	// Party indicates which party is at this state. This is used to
	// implement the state transition properly, based on ShouldRouteTo.
	Party lntypes.ChannelParty
}

type CloseFin struct {
	// ConfirmedTx is the transaction that confirmed the channel close.
	ConfirmedTx *wire.MsgTx
}

type CloseOutput struct {
	// Amt is the amount of the output.
	Amt btcutil.Amount

	// DustLimit is the dust limit for the local node.
	DustLimit btcutil.Amount

	// PkScript is the script that should be used to pay to the output.
	PkScript []byte

	// ShutdownRecords is the set of custom records that may result in
	// extra close outputs being added.
	ShutdownRecords lnwire.CustomRecords
}

type ClosePending struct {
	// CloseTx is the pending close transaction.
	CloseTx *wire.MsgTx

	*CloseChannelTerms

	// FeeRate is the fee rate of the closing transaction.
	FeeRate chainfee.SatPerVByte

	// Party indicates which party is at this state. This is used to
	// implement the state transition properly, based on ShouldRouteTo.
	Party lntypes.ChannelParty
}

type CloseSigner interface {
	// CreateCloseProposal creates a new co-op close proposal in the form
	// of a valid signature, the chainhash of the final txid, and our final
	// balance in the created state.
	CreateCloseProposal(proposedFee btcutil.Amount,
		localDeliveryScript []byte, remoteDeliveryScript []byte,
		closeOpt ...lnwallet.ChanCloseOpt,
	) (
		input.Signature, *wire.MsgTx, btcutil.Amount, error)

	// CompleteCooperativeClose persistently "completes" the cooperative
	// close by producing a fully signed co-op close transaction.
	CompleteCooperativeClose(localSig, remoteSig input.Signature,
		localDeliveryScript, remoteDeliveryScript []byte,
		proposedFee btcutil.Amount, closeOpt ...lnwallet.ChanCloseOpt,
	) (*wire.MsgTx, btcutil.Amount, error)
}

type CloseStateTransition = protofsm.StateTransition[ProtocolEvent, *Environment]

type ClosingNegotiation struct {
	// PeerStates is a composite state that contains the state for both the
	// local and remote parties. Our usage of Dual makes this a special
	// state that allows us to treat two states as a single state. We'll use
	// the ShouldRouteTo method to determine which state route incoming
	// events to.
	PeerState lntypes.Dual[AsymmetricPeerState]

	// CloseChannelTerms is the terms we'll use to close the channel. We
	// hold a value here which is pointed to by the various
	// AsymmetricPeerState instances. This allows us to update this value if
	// the remote peer sends a new address, with each of the state noting
	// the new value via a pointer.
	*CloseChannelTerms
}

type CoopFeeEstimator interface {
	// EstimateFee estimates an _absolute_ fee for a co-op close transaction
	// given the local+remote tx outs (for the co-op close transaction),
	// channel type, and ideal fee rate. If a passed TxOut is nil, then
	// that indicates that an output is dust on the co-op close transaction
	// _before_ fees are accounted for.
	EstimateFee(chanType channeldb.ChannelType,
		localTxOut, remoteTxOut *wire.TxOut,
		idealFeeRate chainfee.SatPerKWeight) btcutil.Amount
}

type DeliveryAddrWithKey struct {
	// DeliveryAddress is the raw, serialized pkScript of the delivery
	// address.
	lnwire.DeliveryAddress

	// InternalKey is the Taproot internal key of the delivery address, if
	// the address is a P2TR output.
	InternalKey fn.Option[btcec.PublicKey]
}

type Environment struct {
	// ChainParams is the chain parameters for the channel.
	ChainParams chaincfg.Params

	// ChanPeer is the peer we're attempting to close the channel with.
	ChanPeer btcec.PublicKey

	// ChanPoint is the channel point of the active channel.
	ChanPoint wire.OutPoint

	// ChanID is the channel ID of the channel we're attempting to close.
	ChanID lnwire.ChannelID

	// ShortChanID is the short channel ID of the channel we're attempting
	// to close.
	Scid lnwire.ShortChannelID

	// ChanType is the type of channel we're attempting to close.
	ChanType channeldb.ChannelType

	// BlockHeight is the current block height.
	BlockHeight uint32

	// DefaultFeeRate is the fee we'll use for the closing transaction if
	// the user didn't specify an ideal fee rate. This may happen if the
	// remote party is the one that initiates the co-op close.
	DefaultFeeRate chainfee.SatPerVByte

	// ThawHeight is the height at which the channel will be thawed. If
	// this is None, then co-op close can occur at any moment.
	ThawHeight fn.Option[uint32]

	// RemoteUprontShutdown is the upfront shutdown addr of the remote
	// party. We'll use this to validate if the remote peer is authorized to
	// close the channel with the sent addr or not.
	RemoteUpfrontShutdown fn.Option[lnwire.DeliveryAddress]

	// LocalUprontShutdown is our upfront shutdown address. If Some, then
	// we'll default to using this.
	LocalUpfrontShutdown fn.Option[lnwire.DeliveryAddress]

	// NewDeliveryScript is a function that returns a new delivery script.
	// This is used if we don't have an upfront shutdown addr, and no addr
	// was specified at closing time.
	NewDeliveryScript func() (lnwire.DeliveryAddress, error)

	// FeeEstimator is the fee estimator we'll use to determine the fee in
	// satoshis we'll pay given a local and/or remote output.
	FeeEstimator CoopFeeEstimator

	// ChanObserver is an interface used to observe state changes to the
	// channel. We'll use this to figure out when/if we can send certain
	// messages.
	ChanObserver ChanStateObserver

	// CloseSigner is the signer we'll use to sign the close transaction.
	// This is a part of the ChannelFlushed state, as the channel state
	// we'll be signing can only be determined once the channel has been
	// flushed.
	CloseSigner CloseSigner
}

type ErrState interface {
	error

	// Err returns an error for the ErrState.
	Err() error
	// contains filtered or unexported methods
}

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

type LocalCloseStart struct {
	*CloseChannelTerms
}

type LocalOfferSent struct {
	*CloseChannelTerms

	// ProposedFee is the fee we proposed to the remote party.
	ProposedFee btcutil.Amount

	// ProposedFeeRate is the fee rate we proposed to the remote party.
	ProposedFeeRate chainfee.SatPerVByte

	// LocalSig is the signature we sent to the remote party.
	LocalSig lnwire.Sig
}

type LocalSigReceived struct {
	// SigMsg is the sig message we received from the remote party.
	SigMsg lnwire.ClosingSig
}

type MusigSession interface {
	// ProposalClosingOpts generates the set of closing options needed to
	// generate a new musig2 proposal signature.
	ProposalClosingOpts() ([]lnwallet.ChanCloseOpt, error)

	// CombineClosingOpts returns the options that should be used when
	// combining the final musig partial signature. The method also maps
	// the lnwire partial signatures into an input.Signature that can be
	// used more generally.
	CombineClosingOpts(localSig, remoteSig lnwire.PartialSig,
	) (input.Signature, input.Signature, []lnwallet.ChanCloseOpt, error)

	// ClosingNonce generates the nonce we'll use to generate the musig2
	// partial signatures for the co-op close transaction.
	ClosingNonce() (*musig2.Nonces, error)

	// InitRemoteNonce saves the remote nonce the party sent during their
	// shutdown message so it can be used later to generate and verify
	// signatures.
	InitRemoteNonce(nonce *musig2.Nonces)
}

type OfferReceivedEvent struct {
	// SigMsg is the signature message we received from the remote party.
	SigMsg lnwire.ClosingComplete
}

type ProtocolEvent interface {
	// contains filtered or unexported methods
}

type ProtocolEvents interface {
	SendShutdown | ShutdownReceived | ShutdownComplete | ChannelFlushed |
		SendOfferEvent | OfferReceivedEvent | LocalSigReceived |
		SpendEvent
}

type ProtocolState interface {

	// IsTerminal returns true if the target state is a terminal state.
	IsTerminal() bool

	// ProcessEvent takes a protocol event, and implements a state
	// transition for the state.
	ProcessEvent(ProtocolEvent, *Environment) (*CloseStateTransition, error)

	// String returns the name of the state.
	String() string
	// contains filtered or unexported methods
}

type ProtocolStates interface {
	ChannelActive | ShutdownPending | ChannelFlushing | ClosingNegotiation |
		LocalCloseStart | LocalOfferSent | RemoteCloseStart |
		ClosePending | CloseFin | CloseErr
}

type RbfChanCloser = protofsm.StateMachine[ProtocolEvent, *Environment]

type RbfChanCloserCfg = protofsm.StateMachineCfg[ProtocolEvent, *Environment]

type RbfEvent = protofsm.EmittedEvent[ProtocolEvent]

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

type RbfMsgMapperT = protofsm.MsgMapper[ProtocolEvent]

type RbfSpendMapper = protofsm.SpendMapper[ProtocolEvent]

type RbfState = protofsm.State[ProtocolEvent, *Environment]

type RbfStateSub = protofsm.StateSubscriber[ProtocolEvent, *Environment]

type RemoteCloseStart struct {
	*CloseChannelTerms
}

type SendOfferEvent struct {
	// TargetFeeRate is the fee rate we'll use for the closing transaction.
	TargetFeeRate chainfee.SatPerVByte
}

type SendShutdown struct {
	// DeliveryAddr is the address we'd like to receive the funds to. If
	// None, then a new addr will be generated.
	DeliveryAddr fn.Option[lnwire.DeliveryAddress]

	// IdealFeeRate is the ideal fee rate we'd like to use for the closing
	// attempt.
	IdealFeeRate chainfee.SatPerVByte
}

type ShutdownBalances struct {
	// LocalBalance is the local balance of the channel.
	LocalBalance lnwire.MilliSatoshi

	// RemoteBalance is the remote balance of the channel.
	RemoteBalance lnwire.MilliSatoshi
}

type ShutdownComplete struct {
}

type ShutdownPending struct {
	// ShutdownScripts store the set of scripts we'll use to initiate a coop
	// close.
	ShutdownScripts

	// IdealFeeRate is the ideal fee rate we'd like to use for the closing
	// attempt.
	IdealFeeRate fn.Option[chainfee.SatPerVByte]

	// EarlyRemoteOffer is the offer we received from the remote party
	// before we received their shutdown message. We'll stash it to process
	// later.
	EarlyRemoteOffer fn.Option[OfferReceivedEvent]
}

type ShutdownReceived struct {
	// ShutdownScript is the script the remote party wants to use to
	// shutdown.
	ShutdownScript lnwire.DeliveryAddress

	// BlockHeight is the height at which the shutdown message was
	// received. This is used for channel leases to determine if a co-op
	// close can occur.
	BlockHeight uint32
}

type ShutdownScripts struct {
	// LocalDeliveryScript is the script that we'll send our settled
	// channel funds to.
	LocalDeliveryScript lnwire.DeliveryAddress

	// RemoteDeliveryScript is the script that we'll send the remote
	// party's settled channel funds to.
	RemoteDeliveryScript lnwire.DeliveryAddress
}

type SimpleCoopFeeEstimator struct {
}

type SpendEvent struct {
	// Tx is the spending transaction that has been confirmed.
	Tx *wire.MsgTx

	// BlockHeight is the height of the block that confirmed the
	// transaction.
	BlockHeight uint32
}