lnwire

type BlindedHop struct {
	// BlindedNodeID is the blinded node id of a node in the path.
	BlindedNodeID *btcec.PublicKey

	// EncryptedData is the encrypted data to be included for the node.
	EncryptedData []byte
}

type BlindedRouteData struct {
	// NextNodeID is the unblinded node id of the next hop in the route.
	NextNodeID *btcec.PublicKey

	// NextBlindingOverride is an optional blinding override used to switch
	// out ephemeral keys.
	NextBlindingOverride *btcec.PublicKey
}

type FinalHopPayload struct {
	// TLVType is the type for the payload.
	TLVType tlv.Type

	// Value is the raw byte value read for this tlv type. This field is
	// expected to contain "sub-tlv" namespaces, and will require further
	// decoding to be used.
	Value []byte
}

type Invoice struct {
	// Chainhash is the hash of the genesis block of the chain that the
	// invoice is for.
	Chainhash lntypes.Hash

	// OfferID is the merkle root of the offer this invoice is associated
	// with.
	OfferID lntypes.Hash

	// Amount is the amount that the invoice is for.
	Amount lndwire.MilliSatoshi

	// Description is an optional description of the invoice.
	Description string

	// Features is the set of features the invoice requires.
	Features *lndwire.FeatureVector

	// NodeID is the node ID for the recipient.
	NodeID *btcec.PublicKey

	// Quantity is an optional quantity of items for the invoice.
	Quantity uint64

	// PayerKey is the paying party's "proof of payee" key.
	PayerKey *btcec.PublicKey

	// PayerNote is an optional note from the paying party.
	PayerNote string

	// CreatedAt is the time the invoice was created.
	CreatedAt time.Time

	// PaymentHash is the payment hash for this invoice.
	PaymentHash lntypes.Hash

	// RelativeExpiry is the relative expiry in seconds from the invoice's
	// created time.
	RelativeExpiry time.Duration

	// CLTVExpiry is the minimum final cltv expiry for the invoice.
	CLTVExpiry uint64

	// PayerInfo is an arbitrary piece of data set by the payer.
	PayerInfo []byte

	// Signature is a signature over the tlv merkle root of the invoice's
	// fields.
	Signature *[64]byte

	// MerkleRoot is the merkle root of all the non-signature tlvs included
	// in the invoice. This field isn't actually encoded in our tlv stream,
	// but rather calculated from it.
	MerkleRoot lntypes.Hash
}

type InvoiceRequest struct {
	// Chainhash is the hash of the genesis block of the chain that the
	// invoice request is for.
	Chainhash lntypes.Hash

	// OfferID is the merkle root of the offer this request is associated
	// with.
	OfferID lntypes.Hash

	// Amount is the invoice amount that the request is for.
	Amount lndwire.MilliSatoshi

	// Features is the set of features required for the invoice.
	Features *lndwire.FeatureVector

	// Quantity is the number of items that the invoice is for.
	Quantity uint64

	// PayerKey is a proof-of-payee key for the sender.
	PayerKey *btcec.PublicKey

	// PayerNote is a note from the sender.
	PayerNote string

	// PayerInfo is arbitrary information included by the sender.
	PayerInfo []byte

	// Signature is an optional signature on the tlv merkle root of the
	// request.
	Signature *[64]byte

	// MerkleRoot is the merkle root of all the non-signature tlvs included
	// in the invoice request. This field isn't actually encoded in our
	// tlv stream, but rather calculated from it.
	MerkleRoot lntypes.Hash
}

type Offer struct {
	// Chainhash is the genesis block hash of the network that the offer is
	// for.
	Chainhash lntypes.Hash

	// MinimumAmount is an optional minimum amount for the offer.
	MinimumAmount lnwire.MilliSatoshi

	// Description is an optional description of the offer.
	Description string

	// Features are the specification features that the offer requires and
	// supports.
	Features *lnwire.FeatureVector

	// Expiry is an optional expiry time of the offer.
	Expiry time.Time

	// Issuer identifies the issuing party.
	Issuer string

	// QuantityMin is the minimum number of invoices for an offer.
	QuantityMin uint64

	// QuantityMax is the maximum number of invoices for an offer.
	QuantityMax uint64

	// NodeID is the public key advertized by the offering node.
	// Note: at present this is encoded as a x-only 32 byte pubkey, but the
	// spec is set to change, so in future this should be encoded as a 33
	// byte compressed pubkey.
	NodeID *btcec.PublicKey

	// Signature is the bip340 signature for the offer.
	Signature *[64]byte

	// MerkleRoot is the merkle root of all the non-signature tlvs included
	// in the offer. This field isn't actually encoded in our tlv stream,
	// but rather calculated from it.
	MerkleRoot lntypes.Hash
}

type OnionMessage struct {
	// BlindingPoint is the route blinding ephemeral pubkey to be used for
	// the onion message.
	BlindingPoint *btcec.PublicKey

	// OnionBlob is the raw serialized mix header used to relay messages in
	// a privacy-preserving manner. This blob should be handled in the same
	// manner as onions used to route HTLCs, with the exception that it uses
	// blinded routes by default.
	OnionBlob []byte
}

type OnionMessagePayload struct {
	// ReplyPath contains a blinded path that can be used to respond to an
	// onion message.
	ReplyPath *ReplyPath

	// EncryptedData contains enrypted data for the recipient.
	EncryptedData []byte

	// FinalHopPayloads contains any tlvs with type > 64 that
	FinalHopPayloads []*FinalHopPayload
}

type ReplyPath struct {
	// FirstNodeID is the pubkey of the first node in the reply path.
	FirstNodeID *btcec.PublicKey

	// BlindingPoint is the ephemeral pubkey used in route blinding.
	BlindingPoint *btcec.PublicKey

	// Hops is a set of blinded hops in the route, starting with the blinded
	// introduction node (first node id).
	Hops []*BlindedHop
}

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

type TLVLeaf struct {
	// Tag is the tag to be used when hashing the value into a node.
	Tag []byte

	// Value is the value contained in the leaf.
	Value []byte
}