13211764208

Committed 08 Feb 2025 03:08AM UTC coverage: 49.288% (-9.5%) from 58.815%

Build # 13211764208

Build Type

Pull #9489

github

Committed by

calvinrzachman

Commit Message

itest: verify switchrpc server enforces send then track

We prevent the rpc server from allowing onion dispatches for
attempt IDs which have already been tracked by rpc clients.

This helps protect the client from leaking a duplicate onion
attempt. NOTE: This is not the only method for solving this
issue! The issue could be addressed via careful client side
programming which accounts for the uncertainty and async
nature of dispatching onions to a remote process via RPC.
This would require some lnd ChannelRouter changes for how
we intend to use these RPCs though.

Pull Request Pull Request #9489: multi: add BuildOnion, SendOnion, and TrackOnion RPCs

Run Details

474 of 990 new or added lines in 11 files covered. (47.88%)

27321 existing lines in 435 files now uncovered.

101192 of 205306 relevant lines covered (49.29%)

1.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lnwallet/chancloser/rbf_coop_states.go

package chancloser

import (
        "fmt"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/chainntnfs"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwallet/chainfee"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/protofsm"
)

var (
        // ErrInvalidStateTransition is returned when we receive an unexpected
        // event for a given state.
        ErrInvalidStateTransition = fmt.Errorf("invalid state transition")

        // ErrTooManySigs is returned when we receive too many sigs from the
        // remote party in the ClosingSigs message.
        ErrTooManySigs = fmt.Errorf("too many sigs received")

        // ErrNoSig is returned when we receive no sig from the remote party.
        ErrNoSig = fmt.Errorf("no sig received")

        // ErrUnknownFinalBalance is returned if we're unable to determine the
        // final channel balance after a flush.
        ErrUnknownFinalBalance = fmt.Errorf("unknown final balance")

        // ErrRemoteCannotPay is returned if the remote party cannot pay the
        // pay for the fees when it sends a signature.
        ErrRemoteCannotPay = fmt.Errorf("remote cannot pay fees")

        // ErrNonFinalSequence is returned if we receive a non-final sequence
        // from the remote party for their signature.
        ErrNonFinalSequence = fmt.Errorf("received non-final sequence")

        // ErrCloserNoClosee is returned if our balance is dust, but the remote
        // party includes our output.
        ErrCloserNoClosee = fmt.Errorf("expected CloserNoClosee sig")

        // ErrCloserAndClosee is returned when we expect a sig covering both
        // outputs, it isn't present.
        ErrCloserAndClosee = fmt.Errorf("expected CloserAndClosee sig")
)

// ProtocolEvent is a special interface used to create the equivalent of a
// sum-type, but using a "sealed" interface. Protocol events can be used as
// input to trigger a state transition, and also as output to trigger a new set
// of events into the very same state machine.
type ProtocolEvent interface {
        protocolSealed()
}

// ProtocolEvents is a special type constraint that enumerates all the possible
// protocol events. This is used mainly as type-level documentation, and may
// also be useful to constraint certain state transition functions.
type ProtocolEvents interface {
        SendShutdown | ShutdownReceived | ShutdownComplete | ChannelFlushed |
                SendOfferEvent | OfferReceivedEvent | LocalSigReceived |
                SpendEvent
}

// SpendEvent indicates that a transaction spending the funding outpoint has
// been confirmed in the main chain.
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
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *SpendEvent) protocolSealed() {}

// SendShutdown indicates that the user wishes to co-op close the channel, so we
// should send a new shutdown message to the remote party.
//
// transition:
//   - fromState: ChannelActive
//   - toState: ChannelFlushing
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
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *SendShutdown) protocolSealed() {}

// ShutdownReceived indicates that we received a shutdown event so we need to
// enter the flushing state.
//
// transition:
//   - fromState: ChannelActive
//   - toState: ChannelFlushing
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
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *ShutdownReceived) protocolSealed() {}

// ShutdownComplete is an event that indicates the channel has been fully
// shutdown. At this point, we'll go to the ChannelFlushing state so we can
// wait for all pending updates to be gone from the channel.
//
// transition:
//   - fromState: ShutdownPending
//   - toState: ChannelFlushing
type ShutdownComplete struct {
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *ShutdownComplete) protocolSealed() {}

// ShutdownBalances holds the local+remote balance once the channel has been
// fully flushed.
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
}

// unknownBalance is a special variable used to denote an unknown channel
// balance (channel not fully flushed yet).
var unknownBalance = ShutdownBalances{}

// ChannelFlushed is an event that indicates the channel has been fully flushed
// can we can now start closing negotiation.
//
// transition:
//   - fromState: ChannelFlushing
//   - toState: ClosingNegotiation
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
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (c *ChannelFlushed) protocolSealed() {}

// SendOfferEvent is a self-triggered event that transitions us from the
// LocalCloseStart state to the LocalOfferSent state. This kicks off the new
// signing process for the co-op close process.
//
// transition:
//   - fromState: LocalCloseStart
//   - toState: LocalOfferSent
type SendOfferEvent struct {
        // TargetFeeRate is the fee rate we'll use for the closing transaction.
        TargetFeeRate chainfee.SatPerVByte
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *SendOfferEvent) protocolSealed() {}

// LocalSigReceived is an event that indicates we've received a signature from
// the remote party, which signs our the co-op close transaction at our
// specified fee rate.
//
// transition:
//   - fromState: LocalOfferSent
//   - toState: ClosePending
type LocalSigReceived struct {
        // SigMsg is the sig message we received from the remote party.
        SigMsg lnwire.ClosingSig
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *LocalSigReceived) protocolSealed() {}

// OfferReceivedEvent is an event that indicates we've received an offer from
// the remote party. This applies to the RemoteCloseStart state.
//
// transition:
//   - fromState: RemoteCloseStart
//   - toState: ClosePending
type OfferReceivedEvent struct {
        // SigMsg is the signature message we received from the remote party.
        SigMsg lnwire.ClosingComplete
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (s *OfferReceivedEvent) protocolSealed() {}

// CloseSigner is an interface that abstracts away the details of the signing
// new coop close transactions.
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)
}

// ChanStateObserver is an interface used to observe state changes that occur
// in a channel. This can be used to figure out if we're able to send a
// shutdown message or not.
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]
}

// Environment is a set of dependencies that a state machine may need to carry
// out the logic for a given state transition. All fields are to be considered
// immutable, and will be fixed for the lifetime of the state machine.
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
}

// Name returns the name of the environment. This is used to uniquely identify
// the environment of related state machines. For this state machine, the name
// is based on the channel ID.
func (e *Environment) Name() string {
        return fmt.Sprintf("rbf_chan_closer(%v)", e.ChanPoint)
}

// CloseStateTransition is the StateTransition type specific to the coop close
// state machine.
//
//nolint:ll
type CloseStateTransition = protofsm.StateTransition[ProtocolEvent, *Environment]

// ProtocolState is our sum-type ish interface that represents the current
// protocol state.
type ProtocolState interface {
        // protocolStateSealed is a special method that is used to seal the
        // interface (only types in this package can implement it).
        protocolStateSealed()

        // 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)
}

// AsymmetricPeerState is an extension of the normal ProtocolState interface
// that gives a caller a hit on if the target state should process an incoming
// event or not.
type AsymmetricPeerState interface {
        ProtocolState

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

// ProtocolStates is a special type constraint that enumerates all the possible
// protocol states.
type ProtocolStates interface {
        ChannelActive | ShutdownPending | ChannelFlushing | ClosingNegotiation |
                LocalCloseStart | LocalOfferSent | RemoteCloseStart |
                ClosePending | CloseFin
}

// ChannelActive is the base state for the channel closer state machine. In
// this state, we haven't begun the shutdown process yet, so the channel is
// still active. Receiving the ShutdownSent or ShutdownReceived events will
// transition us to the ChannelFushing state.
//
// When we transition to this state, we emit a DaemonEvent to send the shutdown
// message if we received one ourselves. Alternatively, we may send out a new
// shutdown if we're initiating it for the very first time.
//
// transition:
//   - fromState: None
//   - toState: ChannelFlushing
//
// input events:
//   - SendShutdown
//   - ShutdownReceived
type ChannelActive struct {
}

// IsTerminal returns true if the target state is a terminal state.
func (c *ChannelActive) IsTerminal() bool {
        return false
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (c *ChannelActive) protocolStateSealed() {}

// ShutdownScripts is a set of scripts that we'll use to co-op close the
// channel.
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
}

// ShutdownPending is the state we enter into after we've sent or received the
// shutdown message. If we sent the shutdown, then we'll wait for the remote
// party to send a shutdown. Otherwise, if we received it, then we'll send our
// shutdown then go to the next state.
//
// transition:
//   - fromState: ChannelActive
//   - toState: ChannelFlushing
//
// input events:
//   - SendShutdown
//   - ShutdownReceived
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]
}

// IsTerminal returns true if the target state is a terminal state.
func (s *ShutdownPending) IsTerminal() bool {
        return false
}

// protocolStateSealed indicates that this struct is a ProtocolEvent instance.
func (s *ShutdownPending) protocolStateSealed() {}

// ChannelFlushing is the state we enter into after we've received or sent a
// shutdown message. In this state, we wait the ChannelFlushed event, after
// which we'll transition to the CloseReady state.
//
// transition:
//   - fromState: ShutdownPending
//   - toState: ClosingNegotiation
//
// input events:
//   - ShutdownComplete
//   - ShutdownReceived
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]
}

// protocolStateSealed indicates that this struct is a ProtocolEvent instance.
func (c *ChannelFlushing) protocolStateSealed() {}

// IsTerminal returns true if the target state is a terminal state.
func (c *ChannelFlushing) IsTerminal() bool {
        return false
}

// ClosingNegotiation is the state we transition to once the channel has been
// flushed. This is actually a composite state that contains one for each side
// of the channel, as the closing process is asymmetric. Once either of the
// peer states reaches the CloseFin state, then the channel is fully closed,
// and we'll transition to that terminal state.
//
// transition:
//   - fromState: ChannelFlushing
//   - toState: CloseFin
//
// input events:
//   - ChannelFlushed
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]
}

// IsTerminal returns true if the target state is a terminal state.
func (c *ClosingNegotiation) IsTerminal() bool {
        return false
}

// protocolSealed indicates that this struct is a ProtocolEvent instance.
func (c *ClosingNegotiation) protocolStateSealed() {}

// CloseChannelTerms is a set of terms that we'll use to close the channel. This
// includes the balances of the channel, and the scripts we'll use to send each
// party's funds to.
type CloseChannelTerms struct {
        ShutdownScripts

        ShutdownBalances
}

// DeriveCloseTxOuts takes the close terms, and returns the local and remote tx
// out for the close transaction. If an output is dust, then it'll be nil.
//
// TODO(roasbeef): add func for w/e heuristic to not manifest own output?
func (c *CloseChannelTerms) DeriveCloseTxOuts() (*wire.TxOut, *wire.TxOut) {
        //nolint:ll
        deriveTxOut := func(balance btcutil.Amount, pkScript []byte) *wire.TxOut {
                dustLimit := lnwallet.DustLimitForSize(len(pkScript))
                if balance >= dustLimit {
                        return &wire.TxOut{
                                PkScript: pkScript,
                                Value:    int64(balance),
                        }
                }

                return nil
        }

        localTxOut := deriveTxOut(
                c.LocalBalance.ToSatoshis(),
                c.LocalDeliveryScript,
        )
        remoteTxOut := deriveTxOut(
                c.RemoteBalance.ToSatoshis(),
                c.RemoteDeliveryScript,
        )

        return localTxOut, remoteTxOut
}

// RemoteAmtIsDust returns true if the remote output is dust.
func (c *CloseChannelTerms) RemoteAmtIsDust() bool {
        return c.RemoteBalance.ToSatoshis() < lnwallet.DustLimitForSize(
                len(c.RemoteDeliveryScript),
        )
}

// LocalAmtIsDust returns true if the local output is dust.
func (c *CloseChannelTerms) LocalAmtIsDust() bool {
        return c.LocalBalance.ToSatoshis() < lnwallet.DustLimitForSize(
                len(c.LocalDeliveryScript),
        )
}

// LocalCanPayFees returns true if the local party can pay the absolute fee
// from their local settled balance.
func (c *CloseChannelTerms) LocalCanPayFees(absoluteFee btcutil.Amount) bool {
        return c.LocalBalance.ToSatoshis() >= absoluteFee
}

// RemoteCanPayFees returns true if the remote party can pay the absolute fee
// from their remote settled balance.
func (c *CloseChannelTerms) RemoteCanPayFees(absoluteFee btcutil.Amount) bool {
        return c.RemoteBalance.ToSatoshis() >= absoluteFee
}

// LocalCloseStart is the state we enter into after we've received or sent
// shutdown, and the channel has been flushed. In this state, we'll emit a new
// event to send our offer to drive the rest of the process.
//
// transition:
//   - fromState: ChannelFlushing
//   - toState: LocalOfferSent
//
// input events:
//   - SendOfferEvent
type LocalCloseStart struct {
        CloseChannelTerms
}

// ShouldRouteTo returns true if the target state should process the target
// event.
func (l *LocalCloseStart) ShouldRouteTo(event ProtocolEvent) bool {
        switch event.(type) {
        case *SendOfferEvent:
                return true
        default:
                return false
        }
}

// IsTerminal returns true if the target state is a terminal state.
func (l *LocalCloseStart) IsTerminal() bool {
        return false
}

// protocolStateaSealed indicates that this struct is a ProtocolEvent instance.
func (l *LocalCloseStart) protocolStateSealed() {}

// LocalOfferSent is the state we transition to after we reveiver the
// SendOfferEvent in the LocalCloseStart state. With this state we send our
// offer to the remote party, then await a sig from them which concludes the
// local cooperative close process.
//
// transition:
//   - fromState: LocalCloseStart
//   - toState: ClosePending
//
// input events:
//   - LocalSigReceived
type LocalOfferSent struct {
        CloseChannelTerms

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

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

// ShouldRouteTo returns true if the target state should process the target
// event.
func (l *LocalOfferSent) ShouldRouteTo(event ProtocolEvent) bool {
        switch event.(type) {
        case *LocalSigReceived:
                return true
        default:
                return false
        }
}

// protocolStateaSealed indicates that this struct is a ProtocolEvent instance.
func (l *LocalOfferSent) protocolStateSealed() {}

// IsTerminal returns true if the target state is a terminal state.
func (l *LocalOfferSent) IsTerminal() bool {
        return false
}

// ClosePending is the state we enter after concluding the negotiation for the
// remote or local state. At this point, given a confirmation notification we
// can terminate the process. Otherwise, we can receive a fresh CoopCloseReq to
// go back to the very start.
//
// transition:
//   - fromState: LocalOfferSent || RemoteCloseStart
//   - toState: CloseFin
//
// input events:
//   - LocalSigReceived
//   - OfferReceivedEvent
type ClosePending struct {
        // CloseTx is the pending close transaction.
        CloseTx *wire.MsgTx
}

// ShouldRouteTo returns true if the target state should process the target
// event.
func (c *ClosePending) ShouldRouteTo(event ProtocolEvent) bool {
        switch event.(type) {
        case *SpendEvent:
                return true
        default:
                return false
        }
}

// protocolStateSealed indicates that this struct is a ProtocolEvent instance.
func (c *ClosePending) protocolStateSealed() {}

// IsTerminal returns true if the target state is a terminal state.
func (c *ClosePending) IsTerminal() bool {
        return true
}

// CloseFin is the terminal state for the channel closer state machine. At this
// point, the close tx has been confirmed on chain.
type CloseFin struct {
        // ConfirmedTx is the transaction that confirmed the channel close.
        ConfirmedTx *wire.MsgTx
}

// protocolStateSealed indicates that this struct is a ProtocolEvent instance.
func (c *CloseFin) protocolStateSealed() {}

// IsTerminal returns true if the target state is a terminal state.
func (c *CloseFin) IsTerminal() bool {
        return true
}

// RemoteCloseStart is similar to the LocalCloseStart, but is used to drive the
// process of signing an offer for the remote party
//
// transition:
//   - fromState: ChannelFlushing
//   - toState: ClosePending
type RemoteCloseStart struct {
        CloseChannelTerms
}

// ShouldRouteTo returns true if the target state should process the target
// event.
func (l *RemoteCloseStart) ShouldRouteTo(event ProtocolEvent) bool {
        switch event.(type) {
        case *OfferReceivedEvent:
                return true
        default:
                return false
        }
}

// protocolStateSealed indicates that this struct is a ProtocolEvent instance.
func (l *RemoteCloseStart) protocolStateSealed() {}

// IsTerminal returns true if the target state is a terminal state.
func (l *RemoteCloseStart) IsTerminal() bool {
        return false
}

// RbfChanCloser is a state machine that handles the RBF-enabled cooperative
// channel close protocol.
type RbfChanCloser = protofsm.StateMachine[ProtocolEvent, *Environment]

// RbfChanCloserCfg is a configuration struct that is used to initialize a new
// RBF chan closer state machine.
type RbfChanCloserCfg = protofsm.StateMachineCfg[ProtocolEvent, *Environment]

// RbfSpendMapper is a type used to map the generic spend event to one specific
// to this package.
type RbfSpendMapper = protofsm.SpendMapper[ProtocolEvent]

func SpendMapper(spendEvent *chainntnfs.SpendDetail) ProtocolEvent {
        return &SpendEvent{
                Tx:          spendEvent.SpendingTx,
                BlockHeight: uint32(spendEvent.SpendingHeight),
        }
}

// RbfMsgMapperT is a type used to map incoming wire messages to protocol
// events.
type RbfMsgMapperT = protofsm.MsgMapper[ProtocolEvent]

// RbfState is a type alias for the state of the RBF channel closer.
type RbfState = protofsm.State[ProtocolEvent, *Environment]

// RbfEvent is a type alias for the event type of the RBF channel closer.
type RbfEvent = protofsm.EmittedEvent[ProtocolEvent]

lightningnetwork / lnd / 13211764208

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous