lightningnetwork / lnd / 10203737448

package channeldb

import (

        "bytes"

        "crypto/hmac"

        "crypto/sha256"

        "encoding/binary"

        "errors"

        "fmt"

        "io"

        "net"

        "strconv"

        "strings"

        "sync"

        "github.com/btcsuite/btcd/btcec/v2"

        "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"

        "github.com/btcsuite/btcd/btcutil"

        "github.com/btcsuite/btcd/chaincfg/chainhash"

        "github.com/btcsuite/btcd/wire"

        "github.com/btcsuite/btcwallet/walletdb"

        "github.com/lightningnetwork/lnd/channeldb/models"

        "github.com/lightningnetwork/lnd/fn"

        "github.com/lightningnetwork/lnd/htlcswitch/hop"

        "github.com/lightningnetwork/lnd/input"

        "github.com/lightningnetwork/lnd/keychain"

        "github.com/lightningnetwork/lnd/kvdb"

        "github.com/lightningnetwork/lnd/lntypes"

        "github.com/lightningnetwork/lnd/lnwire"

        "github.com/lightningnetwork/lnd/shachain"

        "github.com/lightningnetwork/lnd/tlv"

)

const (

        // AbsoluteThawHeightThreshold is the threshold at which a thaw height

        // begins to be interpreted as an absolute block height, rather than a

        // relative one.

        AbsoluteThawHeightThreshold uint32 = 500000

        // HTLCBlindingPointTLV is the tlv type used for storing blinding

        // points with HTLCs.

        HTLCBlindingPointTLV tlv.Type = 0

)

var (

        // closedChannelBucket stores summarization information concerning

        // previously open, but now closed channels.

        closedChannelBucket = []byte("closed-chan-bucket")

        // openChannelBucket stores all the currently open channels. This bucket

        // has a second, nested bucket which is keyed by a node's ID. Within

        // that node ID bucket, all attributes required to track, update, and

        // close a channel are stored.

        //

        // openChan -> nodeID -> chanPoint

        //

        // TODO(roasbeef): flesh out comment

        openChannelBucket = []byte("open-chan-bucket")

        // outpointBucket stores all of our channel outpoints and a tlv

        // stream containing channel data.

        //

        // outpoint -> tlv stream.

        //

        outpointBucket = []byte("outpoint-bucket")

        // chanIDBucket stores all of the 32-byte channel ID's we know about.

        // These could be derived from outpointBucket, but it is more

        // convenient to have these in their own bucket.

        //

        // chanID -> tlv stream.

        //

        chanIDBucket = []byte("chan-id-bucket")

        // historicalChannelBucket stores all channels that have seen their

        // commitment tx confirm. All information from their previous open state

        // is retained.

        historicalChannelBucket = []byte("historical-chan-bucket")

        // chanInfoKey can be accessed within the bucket for a channel

        // (identified by its chanPoint). This key stores all the static

        // information for a channel which is decided at the end of  the

        // funding flow.

        chanInfoKey = []byte("chan-info-key")

        // localUpfrontShutdownKey can be accessed within the bucket for a channel

        // (identified by its chanPoint). This key stores an optional upfront

        // shutdown script for the local peer.

        localUpfrontShutdownKey = []byte("local-upfront-shutdown-key")

        // remoteUpfrontShutdownKey can be accessed within the bucket for a channel

        // (identified by its chanPoint). This key stores an optional upfront

        // shutdown script for the remote peer.

        remoteUpfrontShutdownKey = []byte("remote-upfront-shutdown-key")

        // chanCommitmentKey can be accessed within the sub-bucket for a

        // particular channel. This key stores the up to date commitment state

        // for a particular channel party. Appending a 0 to the end of this key

        // indicates it's the commitment for the local party, and appending a 1

        // to the end of this key indicates it's the commitment for the remote

        // party.

        chanCommitmentKey = []byte("chan-commitment-key")

        // unsignedAckedUpdatesKey is an entry in the channel bucket that

        // contains the remote updates that we have acked, but not yet signed

        // for in one of our remote commits.

        unsignedAckedUpdatesKey = []byte("unsigned-acked-updates-key")

        // remoteUnsignedLocalUpdatesKey is an entry in the channel bucket that

        // contains the local updates that the remote party has acked, but

        // has not yet signed for in one of their local commits.

        remoteUnsignedLocalUpdatesKey = []byte("remote-unsigned-local-updates-key")

        // revocationStateKey stores their current revocation hash, our

        // preimage producer and their preimage store.

        revocationStateKey = []byte("revocation-state-key")

        // dataLossCommitPointKey stores the commitment point received from the

        // remote peer during a channel sync in case we have lost channel state.

        dataLossCommitPointKey = []byte("data-loss-commit-point-key")

        // forceCloseTxKey points to a the unilateral closing tx that we

        // broadcasted when moving the channel to state CommitBroadcasted.

        forceCloseTxKey = []byte("closing-tx-key")

        // coopCloseTxKey points to a the cooperative closing tx that we

        // broadcasted when moving the channel to state CoopBroadcasted.

        coopCloseTxKey = []byte("coop-closing-tx-key")

        // shutdownInfoKey points to the serialised shutdown info that has been

        // persisted for a channel. The existence of this info means that we

        // have sent the Shutdown message before and so should re-initiate the

        // shutdown on re-establish.

        shutdownInfoKey = []byte("shutdown-info-key")

        // commitDiffKey stores the current pending commitment state we've

        // extended to the remote party (if any). Each time we propose a new

        // state, we store the information necessary to reconstruct this state

        // from the prior commitment. This allows us to resync the remote party

        // to their expected state in the case of message loss.

        //

        // TODO(roasbeef): rename to commit chain?

        commitDiffKey = []byte("commit-diff-key")

        // frozenChanKey is the key where we store the information for any

        // active "frozen" channels. This key is present only in the leaf

        // bucket for a given channel.

        frozenChanKey = []byte("frozen-chans")

        // lastWasRevokeKey is a key that stores true when the last update we

        // sent was a revocation and false when it was a commitment signature.

        // This is nil in the case of new channels with no updates exchanged.

        lastWasRevokeKey = []byte("last-was-revoke")

        // finalHtlcsBucket contains the htlcs that have been resolved

        // definitively. Within this bucket, there is a sub-bucket for each

        // channel. In each channel bucket, the htlc indices are stored along

        // with final outcome.

        //

        // final-htlcs -> chanID -> htlcIndex -> outcome

        //

        // 'outcome' is a byte value that encodes:

        //

        //       | true      false

        // ------+------------------

        // bit 0 | settled   failed

        // bit 1 | offchain  onchain

        //

        // This bucket is positioned at the root level, because its contents

        // will be kept independent of the channel lifecycle. This is to avoid

        // the situation where a channel force-closes autonomously and the user

        // not being able to query for htlc outcomes anymore.

        finalHtlcsBucket = []byte("final-htlcs")

)

var (

        // ErrNoCommitmentsFound is returned when a channel has not set

        // commitment states.

        ErrNoCommitmentsFound = fmt.Errorf("no commitments found")

        // ErrNoChanInfoFound is returned when a particular channel does not

        // have any channels state.

        ErrNoChanInfoFound = fmt.Errorf("no chan info found")

        // ErrNoRevocationsFound is returned when revocation state for a

        // particular channel cannot be found.

        ErrNoRevocationsFound = fmt.Errorf("no revocations found")

        // ErrNoPendingCommit is returned when there is not a pending

        // commitment for a remote party. A new commitment is written to disk

        // each time we write a new state in order to be properly fault

        // tolerant.

        ErrNoPendingCommit = fmt.Errorf("no pending commits found")

        // ErrNoCommitPoint is returned when no data loss commit point is found

        // in the database.

        ErrNoCommitPoint = fmt.Errorf("no commit point found")

        // ErrNoCloseTx is returned when no closing tx is found for a channel

        // in the state CommitBroadcasted.

        ErrNoCloseTx = fmt.Errorf("no closing tx found")

        // ErrNoShutdownInfo is returned when no shutdown info has been

        // persisted for a channel.

        ErrNoShutdownInfo = errors.New("no shutdown info")

        // ErrNoRestoredChannelMutation is returned when a caller attempts to

        // mutate a channel that's been recovered.

        ErrNoRestoredChannelMutation = fmt.Errorf("cannot mutate restored " +

                "channel state")

        // ErrChanBorked is returned when a caller attempts to mutate a borked

        // channel.

        ErrChanBorked = fmt.Errorf("cannot mutate borked channel")

        // ErrMissingIndexEntry is returned when a caller attempts to close a

        // channel and the outpoint is missing from the index.

        ErrMissingIndexEntry = fmt.Errorf("missing outpoint from index")

        // ErrOnionBlobLength is returned is an onion blob with incorrect

        // length is read from disk.

        ErrOnionBlobLength = errors.New("onion blob < 1366 bytes")

)

const (

        // A tlv type definition used to serialize an outpoint's indexStatus

        // for use in the outpoint index.

        indexStatusType tlv.Type = 0

        // A tlv type definition used to serialize and deserialize a KeyLocator

        // from the database.

        keyLocType tlv.Type = 1

        // A tlv type used to serialize and deserialize the

        // `InitialLocalBalance` field.

        initialLocalBalanceType tlv.Type = 2

        // A tlv type used to serialize and deserialize the

        // `InitialRemoteBalance` field.

        initialRemoteBalanceType tlv.Type = 3

        // A tlv type definition used to serialize and deserialize the

        // confirmed ShortChannelID for a zero-conf channel.

        realScidType tlv.Type = 4

        // A tlv type definition used to serialize and deserialize the

        // Memo for the channel channel.

        channelMemoType tlv.Type = 5

)

// indexStatus is an enum-like type that describes what state the

// outpoint is in. Currently only two possible values.

type indexStatus uint8

const (

        // outpointOpen represents an outpoint that is open in the outpoint index.

        outpointOpen indexStatus = 0

        // outpointClosed represents an outpoint that is closed in the outpoint

        // index.

        outpointClosed indexStatus = 1

)

// ChannelType is an enum-like type that describes one of several possible

// channel types. Each open channel is associated with a particular type as the

// channel type may determine how higher level operations are conducted such as

// fee negotiation, channel closing, the format of HTLCs, etc. Structure-wise,

// a ChannelType is a bit field, with each bit denoting a modification from the

// base channel type of single funder.

type ChannelType uint64

const (

        // NOTE: iota isn't used here for this enum needs to be stable

        // long-term as it will be persisted to the database.

        // SingleFunderBit represents a channel wherein one party solely funds

        // the entire capacity of the channel.

        SingleFunderBit ChannelType = 0

        // DualFunderBit represents a channel wherein both parties contribute

        // funds towards the total capacity of the channel. The channel may be

        // funded symmetrically or asymmetrically.

        DualFunderBit ChannelType = 1 << 0

        // SingleFunderTweaklessBit is similar to the basic SingleFunder channel

        // type, but it omits the tweak for one's key in the commitment

        // transaction of the remote party.

        SingleFunderTweaklessBit ChannelType = 1 << 1

        // NoFundingTxBit denotes if we have the funding transaction locally on

        // disk. This bit may be on if the funding transaction was crafted by a

        // wallet external to the primary daemon.

        NoFundingTxBit ChannelType = 1 << 2

        // AnchorOutputsBit indicates that the channel makes use of anchor

        // outputs to bump the commitment transaction's effective feerate. This

        // channel type also uses a delayed to_remote output script.

        AnchorOutputsBit ChannelType = 1 << 3

        // FrozenBit indicates that the channel is a frozen channel, meaning

        // that only the responder can decide to cooperatively close the

        // channel.

        FrozenBit ChannelType = 1 << 4

        // ZeroHtlcTxFeeBit indicates that the channel should use zero-fee

        // second-level HTLC transactions.

        ZeroHtlcTxFeeBit ChannelType = 1 << 5

        // LeaseExpirationBit indicates that the channel has been leased for a

        // period of time, constraining every output that pays to the channel

        // initiator with an additional CLTV of the lease maturity.

        LeaseExpirationBit ChannelType = 1 << 6

        // ZeroConfBit indicates that the channel is a zero-conf channel.

        ZeroConfBit ChannelType = 1 << 7

        // ScidAliasChanBit indicates that the channel has negotiated the

        // scid-alias channel type.

        ScidAliasChanBit ChannelType = 1 << 8

        // ScidAliasFeatureBit indicates that the scid-alias feature bit was

        // negotiated during the lifetime of this channel.

        ScidAliasFeatureBit ChannelType = 1 << 9

        // SimpleTaprootFeatureBit indicates that the simple-taproot-chans

        // feature bit was negotiated during the lifetime of the channel.

        SimpleTaprootFeatureBit ChannelType = 1 << 10

)

// IsSingleFunder returns true if the channel type if one of the known single

// funder variants.

// IsDualFunder returns true if the ChannelType has the DualFunderBit set.

// IsTweakless returns true if the target channel uses a commitment that

// doesn't tweak the key for the remote party.

// HasFundingTx returns true if this channel type is one that has a funding

// transaction stored locally.

// HasAnchors returns true if this channel type has anchor outputs on its

// commitment.

// ZeroHtlcTxFee returns true if this channel type uses second-level HTLC

// transactions signed with zero-fee.

// IsFrozen returns true if the channel is considered to be "frozen". A frozen

// channel means that only the responder can initiate a cooperative channel

// closure.

// HasLeaseExpiration returns true if the channel originated from a lease.

// HasZeroConf returns true if the channel is a zero-conf channel.

// HasScidAliasChan returns true if the scid-alias channel type was negotiated.

// HasScidAliasFeature returns true if the scid-alias feature bit was

// negotiated during the lifetime of this channel.

// IsTaproot returns true if the channel is using taproot features.

// ChannelConstraints represents a set of constraints meant to allow a node to

// limit their exposure, enact flow control and ensure that all HTLCs are

// economically relevant. This struct will be mirrored for both sides of the

// channel, as each side will enforce various constraints that MUST be adhered

// to for the life time of the channel. The parameters for each of these

// constraints are static for the duration of the channel, meaning the channel

// must be torn down for them to change.

type ChannelConstraints struct {

        // DustLimit is the threshold (in satoshis) below which any outputs

        // should be trimmed. When an output is trimmed, it isn't materialized

        // as an actual output, but is instead burned to miner's fees.

        DustLimit btcutil.Amount

        // ChanReserve is an absolute reservation on the channel for the

        // owner of this set of constraints. This means that the current

        // settled balance for this node CANNOT dip below the reservation

        // amount. This acts as a defense against costless attacks when

        // either side no longer has any skin in the game.

        ChanReserve btcutil.Amount

        // MaxPendingAmount is the maximum pending HTLC value that the

        // owner of these constraints can offer the remote node at a

        // particular time.

        MaxPendingAmount lnwire.MilliSatoshi

        // MinHTLC is the minimum HTLC value that the owner of these

        // constraints can offer the remote node. If any HTLCs below this

        // amount are offered, then the HTLC will be rejected. This, in

        // tandem with the dust limit allows a node to regulate the

        // smallest HTLC that it deems economically relevant.

        MinHTLC lnwire.MilliSatoshi

        // MaxAcceptedHtlcs is the maximum number of HTLCs that the owner of

        // this set of constraints can offer the remote node. This allows each

        // node to limit their over all exposure to HTLCs that may need to be

        // acted upon in the case of a unilateral channel closure or a contract

        // breach.

        MaxAcceptedHtlcs uint16

        // CsvDelay is the relative time lock delay expressed in blocks. Any

        // settled outputs that pay to the owner of this channel configuration

        // MUST ensure that the delay branch uses this value as the relative

        // time lock. Similarly, any HTLC's offered by this node should use

        // this value as well.

        CsvDelay uint16

}

// ChannelConfig is a struct that houses the various configuration opens for

// channels. Each side maintains an instance of this configuration file as it

// governs: how the funding and commitment transaction to be created, the

// nature of HTLC's allotted, the keys to be used for delivery, and relative

// time lock parameters.

type ChannelConfig struct {

        // ChannelConstraints is the set of constraints that must be upheld for

        // the duration of the channel for the owner of this channel

        // configuration. Constraints govern a number of flow control related

        // parameters, also including the smallest HTLC that will be accepted

        // by a participant.

        ChannelConstraints

        // MultiSigKey is the key to be used within the 2-of-2 output script

        // for the owner of this channel config.

        MultiSigKey keychain.KeyDescriptor

        // RevocationBasePoint is the base public key to be used when deriving

        // revocation keys for the remote node's commitment transaction. This

        // will be combined along with a per commitment secret to derive a

        // unique revocation key for each state.

        RevocationBasePoint keychain.KeyDescriptor

        // PaymentBasePoint is the base public key to be used when deriving

        // the key used within the non-delayed pay-to-self output on the

        // commitment transaction for a node. This will be combined with a

        // tweak derived from the per-commitment point to ensure unique keys

        // for each commitment transaction.

        PaymentBasePoint keychain.KeyDescriptor

        // DelayBasePoint is the base public key to be used when deriving the

        // key used within the delayed pay-to-self output on the commitment

        // transaction for a node. This will be combined with a tweak derived

        // from the per-commitment point to ensure unique keys for each

        // commitment transaction.

        DelayBasePoint keychain.KeyDescriptor

        // HtlcBasePoint is the base public key to be used when deriving the

        // local HTLC key. The derived key (combined with the tweak derived

        // from the per-commitment point) is used within the "to self" clause

        // within any HTLC output scripts.

        HtlcBasePoint keychain.KeyDescriptor

}

// ChannelCommitment is a snapshot of the commitment state at a particular

// point in the commitment chain. With each state transition, a snapshot of the

// current state along with all non-settled HTLCs are recorded. These snapshots

// detail the state of the _remote_ party's commitment at a particular state

// number.  For ourselves (the local node) we ONLY store our most recent

// (unrevoked) state for safety purposes.

type ChannelCommitment struct {

        // CommitHeight is the update number that this ChannelDelta represents

        // the total number of commitment updates to this point. This can be

        // viewed as sort of a "commitment height" as this number is

        // monotonically increasing.

        CommitHeight uint64

        // LocalLogIndex is the cumulative log index index of the local node at

        // this point in the commitment chain. This value will be incremented

        // for each _update_ added to the local update log.

        LocalLogIndex uint64

        // LocalHtlcIndex is the current local running HTLC index. This value

        // will be incremented for each outgoing HTLC the local node offers.

        LocalHtlcIndex uint64

        // RemoteLogIndex is the cumulative log index index of the remote node

        // at this point in the commitment chain. This value will be

        // incremented for each _update_ added to the remote update log.

        RemoteLogIndex uint64

        // RemoteHtlcIndex is the current remote running HTLC index. This value

        // will be incremented for each outgoing HTLC the remote node offers.

        RemoteHtlcIndex uint64

        // LocalBalance is the current available settled balance within the

        // channel directly spendable by us.

        //

        // NOTE: This is the balance *after* subtracting any commitment fee,

        // AND anchor output values.

        LocalBalance lnwire.MilliSatoshi

        // RemoteBalance is the current available settled balance within the

        // channel directly spendable by the remote node.

        //

        // NOTE: This is the balance *after* subtracting any commitment fee,

        // AND anchor output values.

        RemoteBalance lnwire.MilliSatoshi

        // CommitFee is the amount calculated to be paid in fees for the

        // current set of commitment transactions. The fee amount is persisted

        // with the channel in order to allow the fee amount to be removed and

        // recalculated with each channel state update, including updates that

        // happen after a system restart.

        CommitFee btcutil.Amount

        // FeePerKw is the min satoshis/kilo-weight that should be paid within

        // the commitment transaction for the entire duration of the channel's

        // lifetime. This field may be updated during normal operation of the

        // channel as on-chain conditions change.

        //

        // TODO(halseth): make this SatPerKWeight. Cannot be done atm because

        // this will cause the import cycle lnwallet<->channeldb. Fee

        // estimation stuff should be in its own package.

        FeePerKw btcutil.Amount

        // CommitTx is the latest version of the commitment state, broadcast

        // able by us.

        CommitTx *wire.MsgTx

        // CommitSig is one half of the signature required to fully complete

        // the script for the commitment transaction above. This is the

        // signature signed by the remote party for our version of the

        // commitment transactions.

        CommitSig []byte

        // Htlcs is the set of HTLC's that are pending at this particular

        // commitment height.

        Htlcs []HTLC

        // TODO(roasbeef): pending commit pointer?

        //  * lets just walk through

}

// ChannelStatus is a bit vector used to indicate whether an OpenChannel is in

// the default usable state, or a state where it shouldn't be used.

type ChannelStatus uint64

var (

        // ChanStatusDefault is the normal state of an open channel.

        ChanStatusDefault ChannelStatus

        // ChanStatusBorked indicates that the channel has entered an

        // irreconcilable state, triggered by a state desynchronization or

        // channel breach.  Channels in this state should never be added to the

        // htlc switch.

        ChanStatusBorked ChannelStatus = 1

        // ChanStatusCommitBroadcasted indicates that a commitment for this

        // channel has been broadcasted.

        ChanStatusCommitBroadcasted ChannelStatus = 1 << 1

        // ChanStatusLocalDataLoss indicates that we have lost channel state

        // for this channel, and broadcasting our latest commitment might be

        // considered a breach.

        //

        // TODO(halseh): actually enforce that we are not force closing such a

        // channel.

        ChanStatusLocalDataLoss ChannelStatus = 1 << 2

        // ChanStatusRestored is a status flag that signals that the channel

        // has been restored, and doesn't have all the fields a typical channel

        // will have.

        ChanStatusRestored ChannelStatus = 1 << 3

        // ChanStatusCoopBroadcasted indicates that a cooperative close for

        // this channel has been broadcasted. Older cooperatively closed

        // channels will only have this status set. Newer ones will also have

        // close initiator information stored using the local/remote initiator

        // status. This status is set in conjunction with the initiator status

        // so that we do not need to check multiple channel statues for

        // cooperative closes.

        ChanStatusCoopBroadcasted ChannelStatus = 1 << 4

        // ChanStatusLocalCloseInitiator indicates that we initiated closing

        // the channel.

        ChanStatusLocalCloseInitiator ChannelStatus = 1 << 5

        // ChanStatusRemoteCloseInitiator indicates that the remote node

        // initiated closing the channel.

        ChanStatusRemoteCloseInitiator ChannelStatus = 1 << 6

)

// chanStatusStrings maps a ChannelStatus to a human friendly string that

// describes that status.

var chanStatusStrings = map[ChannelStatus]string{

        ChanStatusDefault:              "ChanStatusDefault",

        ChanStatusBorked:               "ChanStatusBorked",

        ChanStatusCommitBroadcasted:    "ChanStatusCommitBroadcasted",

        ChanStatusLocalDataLoss:        "ChanStatusLocalDataLoss",

        ChanStatusRestored:             "ChanStatusRestored",

        ChanStatusCoopBroadcasted:      "ChanStatusCoopBroadcasted",

        ChanStatusLocalCloseInitiator:  "ChanStatusLocalCloseInitiator",

        ChanStatusRemoteCloseInitiator: "ChanStatusRemoteCloseInitiator",

}

// orderedChanStatusFlags is an in-order list of all that channel status flags.

var orderedChanStatusFlags = []ChannelStatus{

        ChanStatusBorked,

        ChanStatusCommitBroadcasted,

        ChanStatusLocalDataLoss,

        ChanStatusRestored,

        ChanStatusCoopBroadcasted,

        ChanStatusLocalCloseInitiator,

        ChanStatusRemoteCloseInitiator,

}

// String returns a human-readable representation of the ChannelStatus.

        // Add individual bit flags.

        }

        // Remove anything to the right of the final bar, including it as well.

        // If this was purely an unknown flag, then remove the extra bar at the

        // start of the string.

}

// FinalHtlcByte defines a byte type that encodes information about the final

// htlc resolution.

type FinalHtlcByte byte

const (

        // FinalHtlcSettledBit is the bit that encodes whether the htlc was

        // settled or failed.

        FinalHtlcSettledBit FinalHtlcByte = 1 << 0

        // FinalHtlcOffchainBit is the bit that encodes whether the htlc was

        // resolved offchain or onchain.

        FinalHtlcOffchainBit FinalHtlcByte = 1 << 1

)

// OpenChannel encapsulates the persistent and dynamic state of an open channel

// with a remote node. An open channel supports several options for on-disk

// serialization depending on the exact context. Full (upon channel creation)

// state commitments, and partial (due to a commitment update) writes are

// supported. Each partial write due to a state update appends the new update

// to an on-disk log, which can then subsequently be queried in order to

// "time-travel" to a prior state.

type OpenChannel struct {

        // ChanType denotes which type of channel this is.

        ChanType ChannelType

        // ChainHash is a hash which represents the blockchain that this

        // channel will be opened within. This value is typically the genesis

        // hash. In the case that the original chain went through a contentious

        // hard-fork, then this value will be tweaked using the unique fork

        // point on each branch.

        ChainHash chainhash.Hash

        // FundingOutpoint is the outpoint of the final funding transaction.

        // This value uniquely and globally identifies the channel within the

        // target blockchain as specified by the chain hash parameter.

        FundingOutpoint wire.OutPoint

        // ShortChannelID encodes the exact location in the chain in which the

        // channel was initially confirmed. This includes: the block height,

        // transaction index, and the output within the target transaction.

        //

        // If IsZeroConf(), then this will the "base" (very first) ALIAS scid

        // and the confirmed SCID will be stored in ConfirmedScid.

        ShortChannelID lnwire.ShortChannelID

        // IsPending indicates whether a channel's funding transaction has been

        // confirmed.

        IsPending bool

        // IsInitiator is a bool which indicates if we were the original

        // initiator for the channel. This value may affect how higher levels

        // negotiate fees, or close the channel.

        IsInitiator bool

        // chanStatus is the current status of this channel. If it is not in

        // the state Default, it should not be used for forwarding payments.

        chanStatus ChannelStatus

        // FundingBroadcastHeight is the height in which the funding

        // transaction was broadcast. This value can be used by higher level

        // sub-systems to determine if a channel is stale and/or should have

        // been confirmed before a certain height.

        FundingBroadcastHeight uint32

        // NumConfsRequired is the number of confirmations a channel's funding

        // transaction must have received in order to be considered available

        // for normal transactional use.

        NumConfsRequired uint16

        // ChannelFlags holds the flags that were sent as part of the

        // open_channel message.

        ChannelFlags lnwire.FundingFlag

        // IdentityPub is the identity public key of the remote node this

        // channel has been established with.

        IdentityPub *btcec.PublicKey

        // Capacity is the total capacity of this channel.

        Capacity btcutil.Amount

        // TotalMSatSent is the total number of milli-satoshis we've sent

        // within this channel.

        TotalMSatSent lnwire.MilliSatoshi

        // TotalMSatReceived is the total number of milli-satoshis we've

        // received within this channel.

        TotalMSatReceived lnwire.MilliSatoshi

        // InitialLocalBalance is the balance we have during the channel

        // opening. When we are not the initiator, this value represents the

        // push amount.

        InitialLocalBalance lnwire.MilliSatoshi

        // InitialRemoteBalance is the balance they have during the channel

        // opening.

        InitialRemoteBalance lnwire.MilliSatoshi

        // LocalChanCfg is the channel configuration for the local node.

        LocalChanCfg ChannelConfig

        // RemoteChanCfg is the channel configuration for the remote node.

        RemoteChanCfg ChannelConfig

        // LocalCommitment is the current local commitment state for the local

        // party. This is stored distinct from the state of the remote party

        // as there are certain asymmetric parameters which affect the

        // structure of each commitment.

        LocalCommitment ChannelCommitment

        // RemoteCommitment is the current remote commitment state for the

        // remote party. This is stored distinct from the state of the local

        // party as there are certain asymmetric parameters which affect the

        // structure of each commitment.

        RemoteCommitment ChannelCommitment

        // RemoteCurrentRevocation is the current revocation for their

        // commitment transaction. However, since this the derived public key,

        // we don't yet have the private key so we aren't yet able to verify

        // that it's actually in the hash chain.

        RemoteCurrentRevocation *btcec.PublicKey

        // RemoteNextRevocation is the revocation key to be used for the *next*

        // commitment transaction we create for the local node. Within the

        // specification, this value is referred to as the

        // per-commitment-point.

        RemoteNextRevocation *btcec.PublicKey

        // RevocationProducer is used to generate the revocation in such a way

        // that remote side might store it efficiently and have the ability to

        // restore the revocation by index if needed. Current implementation of

        // secret producer is shachain producer.

        RevocationProducer shachain.Producer

        // RevocationStore is used to efficiently store the revocations for

        // previous channels states sent to us by remote side. Current

        // implementation of secret store is shachain store.

        RevocationStore shachain.Store

        // Packager is used to create and update forwarding packages for this

        // channel, which encodes all necessary information to recover from

        // failures and reforward HTLCs that were not fully processed.

        Packager FwdPackager

        // FundingTxn is the transaction containing this channel's funding

        // outpoint. Upon restarts, this txn will be rebroadcast if the channel

        // is found to be pending.

        //

        // NOTE: This value will only be populated for single-funder channels

        // for which we are the initiator, and that we also have the funding

        // transaction for. One can check this by using the HasFundingTx()

        // method on the ChanType field.

        FundingTxn *wire.MsgTx

        // LocalShutdownScript is set to a pre-set script if the channel was opened

        // by the local node with option_upfront_shutdown_script set. If the option

        // was not set, the field is empty.

        LocalShutdownScript lnwire.DeliveryAddress

        // RemoteShutdownScript is set to a pre-set script if the channel was opened

        // by the remote node with option_upfront_shutdown_script set. If the option

        // was not set, the field is empty.

        RemoteShutdownScript lnwire.DeliveryAddress

        // ThawHeight is the height when a frozen channel once again becomes a

        // normal channel. If this is zero, then there're no restrictions on

        // this channel. If the value is lower than 500,000, then it's

        // interpreted as a relative height, or an absolute height otherwise.

        ThawHeight uint32

        // LastWasRevoke is a boolean that determines if the last update we sent

        // was a revocation (true) or a commitment signature (false).

        LastWasRevoke bool

        // RevocationKeyLocator stores the KeyLocator information that we will

        // need to derive the shachain root for this channel. This allows us to

        // have private key isolation from lnd.

        RevocationKeyLocator keychain.KeyLocator

        // confirmedScid is the confirmed ShortChannelID for a zero-conf

        // channel. If the channel is unconfirmed, then this will be the

        // default ShortChannelID. This is only set for zero-conf channels.

        confirmedScid lnwire.ShortChannelID

        // Memo is any arbitrary information we wish to store locally about the

        // channel that will be useful to our future selves.

        Memo []byte

        // TODO(roasbeef): eww

        Db *ChannelStateDB

        // TODO(roasbeef): just need to store local and remote HTLC's?

        sync.RWMutex

}

// String returns a string representation of the channel.

// ShortChanID returns the current ShortChannelID of this channel.

// ZeroConfRealScid returns the zero-conf channel's confirmed scid. This should

// only be called if IsZeroConf returns true.

// ZeroConfConfirmed returns whether the zero-conf channel has confirmed. This

// should only be called if IsZeroConf returns true.

// IsZeroConf returns whether the option_zeroconf channel type was negotiated.

// IsOptionScidAlias returns whether the option_scid_alias channel type was

// negotiated.

// NegotiatedAliasFeature returns whether the option-scid-alias feature bit was

// negotiated.

// ChanStatus returns the current ChannelStatus of this channel.

// ApplyChanStatus allows the caller to modify the internal channel state in a

// thead-safe manner.

// ClearChanStatus allows the caller to clear a particular channel status from

// the primary channel status bit field. After this method returns, a call to

// HasChanStatus(status) should return false.

// HasChanStatus returns true if the internal bitfield channel status of the

// target channel has the specified status bit set.