models

type CachedEdgeInfo struct {
	// ChannelID is the unique channel ID for the channel. The first 3
	// bytes are the block height, the next 3 the index within the block,
	// and the last 2 bytes are the output index for the channel.
	ChannelID uint64

	// NodeKey1Bytes is the raw public key of the first node.
	NodeKey1Bytes [33]byte

	// NodeKey2Bytes is the raw public key of the second node.
	NodeKey2Bytes [33]byte

	// Capacity is the total capacity of the channel, this is determined by
	// the value output in the outpoint that created this channel.
	Capacity btcutil.Amount
}

type CachedEdgePolicy struct {
	// ChannelID is the unique channel ID for the channel. The first 3
	// bytes are the block height, the next 3 the index within the block,
	// and the last 2 bytes are the output index for the channel.
	ChannelID uint64

	// HasMaxHTLC indicates whether the policy has a max HTLC value.
	HasMaxHTLC bool

	// IsNode1 indicates whether this policy was announced by the channel's
	// node_1.
	IsNode1 bool

	// IsDisabled indicates whether the policy disables forwarding.
	IsDisabled bool

	// TimeLockDelta is the number of blocks this node will subtract from
	// the expiry of an incoming HTLC. This value expresses the time buffer
	// the node would like to HTLC exchanges.
	TimeLockDelta uint16

	// MinHTLC is the smallest value HTLC this node will forward, expressed
	// in millisatoshi.
	MinHTLC lnwire.MilliSatoshi

	// MaxHTLC is the largest value HTLC this node will forward, expressed
	// in millisatoshi.
	MaxHTLC lnwire.MilliSatoshi

	// FeeBaseMSat is the base HTLC fee that will be charged for forwarding
	// ANY HTLC, expressed in mSAT's.
	FeeBaseMSat lnwire.MilliSatoshi

	// FeeProportionalMillionths is the rate that the node will charge for
	// HTLCs for each millionth of a satoshi forwarded.
	FeeProportionalMillionths lnwire.MilliSatoshi

	// InboundFee is the fee that the node will charge for incoming HTLCs.
	InboundFee fn.Option[lnwire.Fee]

	// ToNodePubKey is a function that returns the to node of a policy.
	// Since we only ever store the inbound policy, this is always the node
	// that we query the channels for in ForEachChannel(). Therefore, we can
	// save a lot of space by not storing this information in the memory and
	// instead just set this function when we copy the policy from cache in
	// ForEachChannel().
	ToNodePubKey func() route.Vertex

	// ToNodeFeatures are the to node's features. They are never set while
	// the edge is in the cache, only on the copy that is returned in
	// ForEachChannel().
	ToNodeFeatures *lnwire.FeatureVector
}

type ChannelAuthProof struct {
	// Version is the version of the channel announcement.
	Version lnwire.GossipVersion

	// NodeSig1Bytes are the raw bytes of the first node signature encoded
	// in DER format.
	//
	// NOTE: v1 channel announcements only.
	NodeSig1Bytes fn.Option[[]byte]

	// NodeSig2Bytes are the raw bytes of the second node signature
	// encoded in DER format.
	//
	// NOTE: v1 channel announcements only.
	NodeSig2Bytes fn.Option[[]byte]

	// BitcoinSig1Bytes are the raw bytes of the first bitcoin signature
	// encoded in DER format.
	//
	// NOTE: v1 channel announcements only.
	BitcoinSig1Bytes fn.Option[[]byte]

	// BitcoinSig2Bytes are the raw bytes of the second bitcoin signature
	// encoded in DER format.
	//
	// NOTE: v1 channel announcements only.
	BitcoinSig2Bytes fn.Option[[]byte]

	// Signature is the raw bytes of the single schnorr signature for v2
	// channel announcements.
	//
	// NOTE: v2 channel announcements only.
	Signature fn.Option[[]byte]
}

type ChannelEdgeInfo struct {
	// Version is the gossip version that this channel was advertised on.
	Version lnwire.GossipVersion

	// ChannelID is the unique channel ID for the channel. The first 3
	// bytes are the block height, the next 3 the index within the block,
	// and the last 2 bytes are the output index for the channel.
	ChannelID uint64

	// ChainHash is the hash that uniquely identifies the chain that this
	// channel was opened within.
	ChainHash chainhash.Hash

	// NodeKey1Bytes is the raw public key of the first node.
	NodeKey1Bytes route.Vertex

	// NodeKey2Bytes is the raw public key of the second node.
	NodeKey2Bytes route.Vertex

	// BitcoinKey1Bytes is the raw public key of the first node.
	//
	// NOTE: this must be set for v1 channels but is optional for v2 and
	// beyond.
	BitcoinKey1Bytes fn.Option[route.Vertex]

	// BitcoinKey2Bytes is the raw public key of the second node.
	//
	// NOTE: this must be set for v1 channels but is optional for v2 and
	// beyond.
	BitcoinKey2Bytes fn.Option[route.Vertex]

	// Features is the list of protocol features supported by this channel
	// edge.
	Features *lnwire.FeatureVector

	// AuthProof is the authentication proof for this channel. This proof
	// contains a set of signatures binding four identities, which attests
	// to the legitimacy of the advertised channel.
	AuthProof *ChannelAuthProof

	// ChannelPoint is the funding outpoint of the channel. This can be
	// used to uniquely identify the channel within the channel graph.
	ChannelPoint wire.OutPoint

	// Capacity is the total capacity of the channel, this is determined by
	// the value output in the outpoint that created this channel.
	Capacity btcutil.Amount

	// FundingScript holds the script of the channel's funding transaction.
	//
	// NOTE: this is not currently persisted and so will not be present if
	// the edge object is loaded from the database.
	FundingScript fn.Option[[]byte]

	// MerkleRootHash is an optional root hash of a Merkle tree that the
	// funding output is committed to. This is then used to compute the
	// final funding output script.
	//
	// NOTE: only used for version 2 channels and beyond.
	MerkleRootHash fn.Option[chainhash.Hash]

	// ExtraOpaqueData is the set of data that was appended to this
	// message, some of which we may not actually know how to iterate or
	// parse. By holding onto this data, we ensure that we're able to
	// properly validate the set of signatures that cover these new fields,
	// and ensure we're able to make upgrades to the network in a forwards
	// compatible manner.
	//
	// NOTE: only used for version 1 channels.
	ExtraOpaqueData []byte

	// ExtraSignedFields is a map of extra fields that are covered by the
	// node announcement's signature that we have not explicitly parsed.
	//
	// NOTE: This is only used for version 2 node announcements and beyond.
	ExtraSignedFields map[uint64][]byte
}

type ChannelEdgePolicy struct {
	// Version is the gossip version of the channel update that produced
	// this policy.
	Version lnwire.GossipVersion

	// SigBytes is the raw bytes of the signature of the channel edge
	// policy. We'll only parse these if the caller needs to access the
	// signature for validation purposes.
	SigBytes []byte

	// ChannelID is the unique channel ID for the channel. The first 3
	// bytes are the block height, the next 3 the index within the block,
	// and the last 2 bytes are the output index for the channel.
	ChannelID uint64

	// LastUpdate is the last time an authenticated edge for this channel
	// was received.
	LastUpdate time.Time

	// LastBlockHeight is the block height that timestamps the last update
	// for v2 channel updates.
	LastBlockHeight uint32

	// SecondPeer indicates whether this policy was announced by the second
	// peer in the channel for v2 channel updates.
	SecondPeer bool

	// MessageFlags is a bitfield which indicates the presence of optional
	// fields (like max_htlc) in the policy.
	MessageFlags lnwire.ChanUpdateMsgFlags

	// ChannelFlags is a bitfield which signals the capabilities of the
	// channel as well as the directed edge this update applies to.
	ChannelFlags lnwire.ChanUpdateChanFlags

	// DisableFlags is a v2-specific bitfield which signals whether the
	// channel is disabled for incoming or outgoing traffic.
	DisableFlags lnwire.ChanUpdateDisableFlags

	// TimeLockDelta is the number of blocks this node will subtract from
	// the expiry of an incoming HTLC. This value expresses the time buffer
	// the node would like to HTLC exchanges.
	TimeLockDelta uint16

	// MinHTLC is the smallest value HTLC this node will forward, expressed
	// in millisatoshi.
	MinHTLC lnwire.MilliSatoshi

	// MaxHTLC is the largest value HTLC this node will forward, expressed
	// in millisatoshi.
	MaxHTLC lnwire.MilliSatoshi

	// FeeBaseMSat is the base HTLC fee that will be charged for forwarding
	// ANY HTLC, expressed in mSAT's.
	FeeBaseMSat lnwire.MilliSatoshi

	// FeeProportionalMillionths is the rate that the node will charge for
	// HTLCs for each millionth of a satoshi forwarded.
	FeeProportionalMillionths lnwire.MilliSatoshi

	// ToNode is the public key of the node that this directed edge leads
	// to. Using this pub key, the channel graph can further be traversed.
	ToNode [33]byte

	// InboundFee is the fee that must be paid for incoming HTLCs.
	//
	// NOTE: for our kvdb implementation of the graph store, inbound fees
	// are still only persisted as part of extra opaque data and so this
	// field is not explicitly stored but is rather populated from the
	// ExtraOpaqueData field on deserialization. For our SQL implementation,
	// this field will be explicitly persisted in the database.
	InboundFee fn.Option[lnwire.Fee]

	// ExtraOpaqueData is the set of data that was appended to this
	// message, some of which we may not actually know how to iterate or
	// parse. By holding onto this data, we ensure that we're able to
	// properly validate the set of signatures that cover these new fields,
	// and ensure we're able to make upgrades to the network in a forwards
	// compatible manner.
	ExtraOpaqueData lnwire.ExtraOpaqueData

	// ExtraSignedFields are the extra signed fields found in v2 channel
	// updates.
	ExtraSignedFields map[uint64][]byte
}

type ChannelV1Fields struct {
	// BitcoinKey1Bytes is the raw public key of the first node.
	BitcoinKey1Bytes route.Vertex

	// BitcoinKey2Bytes is the raw public key of the second node.
	BitcoinKey2Bytes route.Vertex

	// ExtraOpaqueData is the set of data that was appended to this
	// message, some of which we may not actually know how to iterate or
	// parse. By holding onto this data, we ensure that we're able to
	// properly validate the set of signatures that cover these new fields,
	// and ensure we're able to make upgrades to the network in a forwards
	// compatible manner.
	ExtraOpaqueData []byte
}

type ChannelV2Fields struct {
	// BitcoinKey1Bytes is the raw public key of the first node.
	BitcoinKey1Bytes fn.Option[route.Vertex]

	// BitcoinKey2Bytes is the raw public key of the second node.
	BitcoinKey2Bytes fn.Option[route.Vertex]

	// FundingScript is the funding output's pkScript. This is required for
	// v2 channels when the bitcoin keys are not provided.
	FundingScript fn.Option[[]byte]

	// MerkleRootHash is an optional root hash of a Merkle tree that the
	// funding output is committed to.
	MerkleRootHash fn.Option[chainhash.Hash]

	// ExtraSignedFields is a map of extra fields that are covered by the
	// node announcement's signature that we have not explicitly parsed.
	//
	// NOTE: This is only used for version 2 node announcements and beyond.
	ExtraSignedFields map[uint64][]byte
}

type CircuitKey struct {
	// ChanID is the short chanid indicating the HTLC's origin.
	//
	// NOTE: It is fine for this value to be blank, as this indicates a
	// locally-sourced payment.
	ChanID lnwire.ShortChannelID

	// HtlcID is the unique htlc index predominately assigned by links,
	// though can also be assigned by switch in the case of locally-sourced
	// payments.
	HtlcID uint64
}

type EdgeModifier func(*ChannelEdgeInfo)

type ForwardingPolicy struct {
	// MinHTLCOut is the smallest HTLC that is to be forwarded.
	MinHTLCOut lnwire.MilliSatoshi

	// MaxHTLC is the largest HTLC that is to be forwarded.
	MaxHTLC lnwire.MilliSatoshi

	// BaseFee is the base fee, expressed in milli-satoshi that must be
	// paid for each incoming HTLC. This field, combined with FeeRate is
	// used to compute the required fee for a given HTLC.
	BaseFee lnwire.MilliSatoshi

	// FeeRate is the fee rate, expressed in milli-satoshi that must be
	// paid for each incoming HTLC. This field combined with BaseFee is
	// used to compute the required fee for a given HTLC.
	FeeRate lnwire.MilliSatoshi

	// InboundFee is the fee that must be paid for incoming HTLCs.
	InboundFee InboundFee

	// TimeLockDelta is the absolute time-lock value, expressed in blocks,
	// that will be subtracted from an incoming HTLC's timelock value to
	// create the time-lock value for the forwarded outgoing HTLC. The
	// following constraint MUST hold for an HTLC to be forwarded:
	//
	//  * incomingHtlc.timeLock - timeLockDelta = fwdInfo.OutgoingCTLV
	//
	// where fwdInfo is the forwarding information extracted from the
	// per-hop payload of the incoming HTLC's onion packet.
	TimeLockDelta uint32
}

type InboundFee struct {
	Base int32
	Rate int32
}

type Node struct {
	// Version is the gossip version that this node was advertised on.
	Version lnwire.GossipVersion

	// PubKeyBytes is the raw bytes of the public key of the target node.
	PubKeyBytes [33]byte

	// LastUpdate is the last time the vertex information for this node has
	// been updated.
	LastUpdate time.Time

	// LastBlockHeight is the block height that timestamps the last update
	// we received for this node. This is only used if this is a V2 node
	// announcement.
	LastBlockHeight uint32

	// Address is the TCP address this node is reachable over.
	Addresses []net.Addr

	// Color is the selected color for the node.
	Color fn.Option[color.RGBA]

	// Alias is a nick-name for the node. The alias can be used to confirm
	// a node's identity or to serve as a short ID for an address book.
	Alias fn.Option[string]

	// AuthSigBytes is the raw signature under the advertised public key
	// which serves to authenticate the attributes announced by this node.
	AuthSigBytes []byte

	// Features is the list of protocol features supported by this node.
	Features *lnwire.FeatureVector

	// ExtraOpaqueData is the set of data that was appended to this
	// message, some of which we may not actually know how to iterate or
	// parse. By holding onto this data, we ensure that we're able to
	// properly validate the set of signatures that cover these new fields,
	// and ensure we're able to make upgrades to the network in a forwards
	// compatible manner. This is only used for V1 node announcements.
	ExtraOpaqueData []byte

	// ExtraSignedFields is a map of extra fields that are covered by the
	// node announcement's signature that we have not explicitly parsed.
	// This is only used for version 2 node announcements and beyond.
	ExtraSignedFields map[uint64][]byte
}

type NodeV1Fields struct {
	// Address is the TCP address this node is reachable over.
	Addresses []net.Addr

	// AuthSigBytes is the raw signature under the advertised public key
	// which serves to authenticate the attributes announced by this node.
	AuthSigBytes []byte

	// Features is the list of protocol features supported by this node.
	Features *lnwire.RawFeatureVector

	// Color is the selected color for the node.
	Color color.RGBA

	// Alias is a nick-name for the node. The alias can be used to confirm
	// a node's identity or to serve as a short ID for an address book.
	Alias string

	// LastUpdate is the last time the vertex information for this node has
	// been updated.
	LastUpdate time.Time

	// ExtraOpaqueData is the set of data that was appended to this
	// message, some of which we may not actually know how to iterate or
	// parse. By holding onto this data, we ensure that we're able to
	// properly validate the set of signatures that cover these new fields,
	// and ensure we're able to make upgrades to the network in a forwards
	// compatible manner.
	ExtraOpaqueData []byte
}

type NodeV2Fields struct {
	// LastBlockHeight is the block height that timestamps the last update
	// we received for this node.
	LastBlockHeight uint32

	// Address is the TCP address this node is reachable over.
	Addresses []net.Addr

	// Color is the selected color for the node.
	Color fn.Option[color.RGBA]

	// Alias is a nick-name for the node. The alias can be used to confirm
	// a node's identity or to serve as a short ID for an address book.
	Alias fn.Option[string]

	// Signature is the schnorr signature under the advertised public key
	// which serves to authenticate the attributes announced by this node.
	Signature []byte

	// Features is the list of protocol features supported by this node.
	Features *lnwire.RawFeatureVector

	// ExtraSignedFields is a map of extra fields that are covered by the
	// node announcement's signature that we have not explicitly parsed.
	ExtraSignedFields map[uint64][]byte
}