payments/migration1: freeze lnwire and record dependency
Also freeze the lnwire and record packages used by the migration. Copy the minimal subset of lnwire files (16) into payments/db/migration1/lnwire/ and all record files (6) into payments/db/migration1/record/. Three lnwire files are trimmed to avoid pulling in the full message-type dispatch tree — all changes are purely subtractive and can be verified with: diff lnwire/message.go payments/db/migration1/lnwire/message.go diff lnwire/writer.go payments/db/migration1/lnwire/writer.go diff lnwire/lnwire.go payments/db/migration1/lnwire/lnwire.go All migration1 files now import only the frozen packages, removing the live dependency on lnwire and record so future changes to those packages cannot affect migration correctness.
This commit is contained in:
33 files changed
+6433
-16
No files matched your search
@@ -0,0 +1,121 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/lightningnetwork/lnd/tlv"
|
||||
)
|
||||
|
||||
// AMPOnionType is the type used in the onion to reference the AMP fields:
|
||||
// root_share, set_id, and child_index.
|
||||
const AMPOnionType tlv.Type = 14
|
||||
|
||||
// AMP is a record that encodes the fields necessary for atomic multi-path
|
||||
// payments.
|
||||
type AMP struct {
|
||||
rootShare [32]byte
|
||||
setID [32]byte
|
||||
childIndex uint32
|
||||
}
|
||||
|
||||
// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
|
||||
// the maximum payload size. The `childIndex` is created randomly and is a
|
||||
// 4 byte `varint` type so we make sure we use an index which will be encoded in
|
||||
// 4 bytes.
|
||||
var MaxAmpPayLoadSize = AMP{
|
||||
rootShare: [32]byte{},
|
||||
setID: [32]byte{},
|
||||
childIndex: 0x80000000,
|
||||
}
|
||||
|
||||
// NewAMP generate a new AMP record with the given root_share, set_id, and
|
||||
// child_index.
|
||||
func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {
|
||||
return &{
|
||||
rootShare: rootShare,
|
||||
setID: setID,
|
||||
childIndex: childIndex,
|
||||
}
|
||||
}
|
||||
|
||||
// RootShare returns the root share contained in the AMP record.
|
||||
func (a *AMP) RootShare() [32]byte {
|
||||
return a.rootShare
|
||||
}
|
||||
|
||||
// SetID returns the set id contained in the AMP record.
|
||||
func (a *AMP) SetID() [32]byte {
|
||||
return a.setID
|
||||
}
|
||||
|
||||
// ChildIndex returns the child index contained in the AMP record.
|
||||
func (a *AMP) ChildIndex() uint32 {
|
||||
return a.childIndex
|
||||
}
|
||||
|
||||
// AMPEncoder writes the AMP record to the provided io.Writer.
|
||||
func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
|
||||
if v, ok := val.(*AMP); ok {
|
||||
if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := tlv.EBytes32(w, &v.setID, buf); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tlv.ETUint32T(w, v.childIndex, buf)
|
||||
}
|
||||
return tlv.NewTypeForEncodingErr(val, "AMP")
|
||||
}
|
||||
|
||||
const (
|
||||
// minAMPLength is the minimum length of a serialized AMP TLV record,
|
||||
// which occurs when the truncated encoding of child_index takes 0
|
||||
// bytes, leaving only the root_share and set_id.
|
||||
minAMPLength = 64
|
||||
|
||||
// maxAMPLength is the maximum length of a serialized AMP TLV record,
|
||||
// which occurs when the truncated encoding of a child_index takes 2
|
||||
// bytes.
|
||||
maxAMPLength = 68
|
||||
)
|
||||
|
||||
// AMPDecoder reads the AMP record from the provided io.Reader.
|
||||
func AMPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
|
||||
if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {
|
||||
if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)
|
||||
}
|
||||
return tlv.NewTypeForDecodingErr(val, "AMP", l, maxAMPLength)
|
||||
}
|
||||
|
||||
// Record returns a tlv.Record that can be used to encode or decode this record.
|
||||
func (a *AMP) Record() tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,
|
||||
)
|
||||
}
|
||||
|
||||
// PayloadSize returns the size this record takes up in encoded form.
|
||||
func (a *AMP) PayloadSize() uint64 {
|
||||
return 32 + 32 + tlv.SizeTUint32(a.childIndex)
|
||||
}
|
||||
|
||||
// String returns a human-readable description of the amp payload fields.
|
||||
func (a *AMP) String() string {
|
||||
if a == nil {
|
||||
return "<nil>"
|
||||
}
|
||||
|
||||
return fmt.Sprintf("root_share=%x set_id=%x child_index=%d",
|
||||
a.rootShare, a.setID, a.childIndex)
|
||||
}
|
||||
@@ -0,0 +1,440 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"io"
|
||||
|
||||
"github.com/btcsuite/btcd/btcec/v2"
|
||||
"github.com/lightningnetwork/lnd/payments/db/migration1/lnwire"
|
||||
"github.com/lightningnetwork/lnd/tlv"
|
||||
)
|
||||
|
||||
// AverageDummyHopPayloadSize is the size of a standard blinded path dummy hop
|
||||
// payload. In most cases, this is larger than the other payload types and so
|
||||
// to make sure that a sender cannot use this fact to know if a dummy hop is
|
||||
// present or not, we'll make sure to always pad all payloads to at least this
|
||||
// size.
|
||||
const AverageDummyHopPayloadSize = 51
|
||||
|
||||
// BlindedRouteData contains the information that is included in a blinded
|
||||
// route encrypted data blob that is created by the recipient to provide
|
||||
// forwarding information.
|
||||
type BlindedRouteData struct {
|
||||
// Padding is an optional set of bytes that a recipient can use to pad
|
||||
// the data so that the encrypted recipient data blobs are all the same
|
||||
// length.
|
||||
Padding tlv.OptionalRecordT[tlv.TlvType1, []byte]
|
||||
|
||||
// ShortChannelID is the channel ID of the next hop.
|
||||
ShortChannelID tlv.OptionalRecordT[tlv.TlvType2, lnwire.ShortChannelID]
|
||||
|
||||
// NextNodeID is the node ID of the next node on the path. In the
|
||||
// context of blinded path payments, this is used to indicate the
|
||||
// presence of dummy hops that need to be peeled from the onion.
|
||||
NextNodeID tlv.OptionalRecordT[tlv.TlvType4, *btcec.PublicKey]
|
||||
|
||||
// PathID is a secret set of bytes that the blinded path creator will
|
||||
// set so that they can check the value on decryption to ensure that the
|
||||
// path they created was used for the intended purpose.
|
||||
PathID tlv.OptionalRecordT[tlv.TlvType6, []byte]
|
||||
|
||||
// NextBlindingOverride is a blinding point that should be switched
|
||||
// in for the next hop. This is used to combine two blinded paths into
|
||||
// one (which primarily is used in onion messaging, but in theory
|
||||
// could be used for payments as well).
|
||||
NextBlindingOverride tlv.OptionalRecordT[tlv.TlvType8, *btcec.PublicKey]
|
||||
|
||||
// RelayInfo provides the relay parameters for the hop.
|
||||
RelayInfo tlv.OptionalRecordT[tlv.TlvType10, PaymentRelayInfo]
|
||||
|
||||
// Constraints provides the payment relay constraints for the hop.
|
||||
Constraints tlv.OptionalRecordT[tlv.TlvType12, PaymentConstraints]
|
||||
|
||||
// Features is the set of features the payment requires.
|
||||
Features tlv.OptionalRecordT[tlv.TlvType14, lnwire.FeatureVector]
|
||||
}
|
||||
|
||||
// NewNonFinalBlindedRouteData creates the data that's provided for hops within
|
||||
// a blinded route.
|
||||
func NewNonFinalBlindedRouteData(chanID lnwire.ShortChannelID,
|
||||
blindingOverride *btcec.PublicKey, relayInfo PaymentRelayInfo,
|
||||
constraints *PaymentConstraints,
|
||||
features *lnwire.FeatureVector) *BlindedRouteData {
|
||||
|
||||
info := &BlindedRouteData{
|
||||
ShortChannelID: tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType2](chanID),
|
||||
),
|
||||
RelayInfo: tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType10](relayInfo),
|
||||
),
|
||||
}
|
||||
|
||||
if blindingOverride != nil {
|
||||
info.NextBlindingOverride = tlv.SomeRecordT(
|
||||
tlv.NewPrimitiveRecord[tlv.TlvType8](blindingOverride))
|
||||
}
|
||||
|
||||
if constraints != nil {
|
||||
info.Constraints = tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType12](*constraints))
|
||||
}
|
||||
|
||||
if features != nil {
|
||||
info.Features = tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType14](*features),
|
||||
)
|
||||
}
|
||||
|
||||
return info
|
||||
}
|
||||
|
||||
// NewFinalHopBlindedRouteData creates the data that's provided for the final
|
||||
// hop in a blinded route.
|
||||
func NewFinalHopBlindedRouteData(constraints *PaymentConstraints,
|
||||
pathID []byte) *BlindedRouteData {
|
||||
|
||||
var data BlindedRouteData
|
||||
if pathID != nil {
|
||||
data.PathID = tlv.SomeRecordT(
|
||||
tlv.NewPrimitiveRecord[tlv.TlvType6](pathID),
|
||||
)
|
||||
}
|
||||
|
||||
if constraints != nil {
|
||||
data.Constraints = tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType12](*constraints))
|
||||
}
|
||||
|
||||
return &data
|
||||
}
|
||||
|
||||
// NewDummyHopRouteData creates the data that's provided for any hop preceding
|
||||
// a dummy hop. The presence of such a payload indicates to the reader that
|
||||
// they are the intended recipient and should peel the remainder of the onion.
|
||||
func NewDummyHopRouteData(ourPubKey *btcec.PublicKey,
|
||||
relayInfo PaymentRelayInfo,
|
||||
constraints PaymentConstraints) *BlindedRouteData {
|
||||
|
||||
return &BlindedRouteData{
|
||||
NextNodeID: tlv.SomeRecordT(
|
||||
tlv.NewPrimitiveRecord[tlv.TlvType4](ourPubKey),
|
||||
),
|
||||
RelayInfo: tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType10](relayInfo),
|
||||
),
|
||||
Constraints: tlv.SomeRecordT(
|
||||
tlv.NewRecordT[tlv.TlvType12](constraints),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
// DecodeBlindedRouteData decodes the data provided within a blinded route.
|
||||
func DecodeBlindedRouteData(r io.Reader) (*BlindedRouteData, error) {
|
||||
var (
|
||||
d BlindedRouteData
|
||||
|
||||
padding = d.Padding.Zero()
|
||||
scid = d.ShortChannelID.Zero()
|
||||
nextNodeID = d.NextNodeID.Zero()
|
||||
pathID = d.PathID.Zero()
|
||||
blindingOverride = d.NextBlindingOverride.Zero()
|
||||
relayInfo = d.RelayInfo.Zero()
|
||||
constraints = d.Constraints.Zero()
|
||||
features = d.Features.Zero()
|
||||
)
|
||||
|
||||
var tlvRecords lnwire.ExtraOpaqueData
|
||||
if err := lnwire.ReadElements(r, &tlvRecords); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
typeMap, err := tlvRecords.ExtractRecords(
|
||||
&padding, &scid, &nextNodeID, &pathID, &blindingOverride,
|
||||
&relayInfo, &constraints, &features,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
val, ok := typeMap[d.Padding.TlvType()]
|
||||
if ok && val == nil {
|
||||
d.Padding = tlv.SomeRecordT(padding)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.ShortChannelID.TlvType()]; ok && val == nil {
|
||||
d.ShortChannelID = tlv.SomeRecordT(scid)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.NextNodeID.TlvType()]; ok && val == nil {
|
||||
d.NextNodeID = tlv.SomeRecordT(nextNodeID)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.PathID.TlvType()]; ok && val == nil {
|
||||
d.PathID = tlv.SomeRecordT(pathID)
|
||||
}
|
||||
|
||||
val, ok = typeMap[d.NextBlindingOverride.TlvType()]
|
||||
if ok && val == nil {
|
||||
d.NextBlindingOverride = tlv.SomeRecordT(blindingOverride)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.RelayInfo.TlvType()]; ok && val == nil {
|
||||
d.RelayInfo = tlv.SomeRecordT(relayInfo)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.Constraints.TlvType()]; ok && val == nil {
|
||||
d.Constraints = tlv.SomeRecordT(constraints)
|
||||
}
|
||||
|
||||
if val, ok := typeMap[d.Features.TlvType()]; ok && val == nil {
|
||||
d.Features = tlv.SomeRecordT(features)
|
||||
}
|
||||
|
||||
return &d, nil
|
||||
}
|
||||
|
||||
// EncodeBlindedRouteData encodes the blinded route data provided.
|
||||
func EncodeBlindedRouteData(data *BlindedRouteData) ([]byte, error) {
|
||||
var (
|
||||
e lnwire.ExtraOpaqueData
|
||||
recordProducers = make([]tlv.RecordProducer, 0, 5)
|
||||
)
|
||||
|
||||
data.Padding.WhenSome(func(p tlv.RecordT[tlv.TlvType1, []byte]) {
|
||||
recordProducers = append(recordProducers, &p)
|
||||
})
|
||||
|
||||
data.ShortChannelID.WhenSome(func(scid tlv.RecordT[tlv.TlvType2,
|
||||
lnwire.ShortChannelID]) {
|
||||
|
||||
recordProducers = append(recordProducers, &scid)
|
||||
})
|
||||
|
||||
data.NextNodeID.WhenSome(func(f tlv.RecordT[tlv.TlvType4,
|
||||
*btcec.PublicKey]) {
|
||||
|
||||
recordProducers = append(recordProducers, &f)
|
||||
})
|
||||
|
||||
data.PathID.WhenSome(func(pathID tlv.RecordT[tlv.TlvType6, []byte]) {
|
||||
recordProducers = append(recordProducers, &pathID)
|
||||
})
|
||||
|
||||
data.NextBlindingOverride.WhenSome(func(pk tlv.RecordT[tlv.TlvType8,
|
||||
*btcec.PublicKey]) {
|
||||
|
||||
recordProducers = append(recordProducers, &pk)
|
||||
})
|
||||
|
||||
data.RelayInfo.WhenSome(func(r tlv.RecordT[tlv.TlvType10,
|
||||
PaymentRelayInfo]) {
|
||||
|
||||
recordProducers = append(recordProducers, &r)
|
||||
})
|
||||
|
||||
data.Constraints.WhenSome(func(cs tlv.RecordT[tlv.TlvType12,
|
||||
PaymentConstraints]) {
|
||||
|
||||
recordProducers = append(recordProducers, &cs)
|
||||
})
|
||||
|
||||
data.Features.WhenSome(func(f tlv.RecordT[tlv.TlvType14,
|
||||
lnwire.FeatureVector]) {
|
||||
|
||||
recordProducers = append(recordProducers, &f)
|
||||
})
|
||||
|
||||
if err := e.PackRecords(recordProducers...); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return e[:], nil
|
||||
}
|
||||
|
||||
// PadBy adds "n" padding bytes to the BlindedRouteData using the Padding field.
|
||||
// Callers should be aware that the total payload size will change by more than
|
||||
// "n" since the "n" bytes will be prefixed by BigSize type and length fields.
|
||||
// Callers may need to call PadBy iteratively until each encrypted data packet
|
||||
// is the same size and so each call will overwrite the Padding record.
|
||||
// Note that calling PadBy with an n value of 0 will still result in a zero
|
||||
// length TLV entry being added.
|
||||
func (b *BlindedRouteData) PadBy(n int) {
|
||||
b.Padding = tlv.SomeRecordT(
|
||||
tlv.NewPrimitiveRecord[tlv.TlvType1](make([]byte, n)),
|
||||
)
|
||||
}
|
||||
|
||||
// PaymentRelayInfo describes the relay policy for a blinded path.
|
||||
type PaymentRelayInfo struct {
|
||||
// CltvExpiryDelta is the expiry delta for the payment.
|
||||
CltvExpiryDelta uint16
|
||||
|
||||
// FeeRate is the fee rate that will be charged per millionth of a
|
||||
// satoshi.
|
||||
FeeRate uint32
|
||||
|
||||
// BaseFee is the per-htlc fee charged in milli-satoshis.
|
||||
BaseFee lnwire.MilliSatoshi
|
||||
}
|
||||
|
||||
// Record creates a tlv.Record that encodes the payment relay (type 10) type for
|
||||
// an encrypted blob payload.
|
||||
func (i *PaymentRelayInfo) Record() tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
10, &i, func() uint64 {
|
||||
// uint16 + uint32 + tuint32
|
||||
return 2 + 4 + tlv.SizeTUint32(uint32(i.BaseFee))
|
||||
}, encodePaymentRelay, decodePaymentRelay,
|
||||
)
|
||||
}
|
||||
|
||||
func encodePaymentRelay(w io.Writer, val interface{}, buf *[8]byte) error {
|
||||
if t, ok := val.(**PaymentRelayInfo); ok {
|
||||
relayInfo := *t
|
||||
|
||||
// Just write our first 6 bytes directly.
|
||||
binary.BigEndian.PutUint16(buf[:2], relayInfo.CltvExpiryDelta)
|
||||
binary.BigEndian.PutUint32(buf[2:6], relayInfo.FeeRate)
|
||||
if _, err := w.Write(buf[0:6]); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
baseFee := uint32(relayInfo.BaseFee)
|
||||
|
||||
// We can safely reuse buf here because we overwrite its
|
||||
// contents.
|
||||
return tlv.ETUint32(w, &baseFee, buf)
|
||||
}
|
||||
|
||||
return tlv.NewTypeForEncodingErr(val, "**hop.PaymentRelayInfo")
|
||||
}
|
||||
|
||||
func decodePaymentRelay(r io.Reader, val interface{}, buf *[8]byte,
|
||||
l uint64) error {
|
||||
|
||||
if t, ok := val.(**PaymentRelayInfo); ok && l <= 10 {
|
||||
scratch := make([]byte, l)
|
||||
|
||||
n, err := io.ReadFull(r, scratch)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// We expect at least 6 bytes, because we have 2 bytes for
|
||||
// cltv delta and 4 bytes for fee rate.
|
||||
if n < 6 {
|
||||
return tlv.NewTypeForDecodingErr(val,
|
||||
"*hop.paymentRelayInfo", uint64(n), 6)
|
||||
}
|
||||
|
||||
relayInfo := *t
|
||||
|
||||
relayInfo.CltvExpiryDelta = binary.BigEndian.Uint16(
|
||||
scratch[0:2],
|
||||
)
|
||||
relayInfo.FeeRate = binary.BigEndian.Uint32(scratch[2:6])
|
||||
|
||||
// To be able to re-use the DTUint32 function we create a
|
||||
// buffer with just the bytes holding the variable length u32.
|
||||
// If the base fee is zero, this will be an empty buffer, which
|
||||
// is okay.
|
||||
b := bytes.NewBuffer(scratch[6:])
|
||||
|
||||
var baseFee uint32
|
||||
err = tlv.DTUint32(b, &baseFee, buf, l-6)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
relayInfo.BaseFee = lnwire.MilliSatoshi(baseFee)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
return tlv.NewTypeForDecodingErr(val, "*hop.paymentRelayInfo", l, 10)
|
||||
}
|
||||
|
||||
// PaymentConstraints is a set of restrictions on a payment.
|
||||
type PaymentConstraints struct {
|
||||
// MaxCltvExpiry is the maximum expiry height for the payment.
|
||||
MaxCltvExpiry uint32
|
||||
|
||||
// HtlcMinimumMsat is the minimum htlc size for the payment.
|
||||
HtlcMinimumMsat lnwire.MilliSatoshi
|
||||
}
|
||||
|
||||
func (p *PaymentConstraints) Record() tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
12, &p, func() uint64 {
|
||||
// uint32 + tuint64.
|
||||
return 4 + tlv.SizeTUint64(uint64(
|
||||
p.HtlcMinimumMsat,
|
||||
))
|
||||
},
|
||||
encodePaymentConstraints, decodePaymentConstraints,
|
||||
)
|
||||
}
|
||||
|
||||
func encodePaymentConstraints(w io.Writer, val interface{},
|
||||
buf *[8]byte) error {
|
||||
|
||||
if c, ok := val.(**PaymentConstraints); ok {
|
||||
constraints := *c
|
||||
|
||||
binary.BigEndian.PutUint32(buf[:4], constraints.MaxCltvExpiry)
|
||||
if _, err := w.Write(buf[:4]); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// We can safely re-use buf here because we overwrite its
|
||||
// contents.
|
||||
htlcMsat := uint64(constraints.HtlcMinimumMsat)
|
||||
|
||||
return tlv.ETUint64(w, &htlcMsat, buf)
|
||||
}
|
||||
|
||||
return tlv.NewTypeForEncodingErr(val, "**PaymentConstraints")
|
||||
}
|
||||
|
||||
func decodePaymentConstraints(r io.Reader, val interface{}, buf *[8]byte,
|
||||
l uint64) error {
|
||||
|
||||
if c, ok := val.(**PaymentConstraints); ok && l <= 12 {
|
||||
scratch := make([]byte, l)
|
||||
|
||||
n, err := io.ReadFull(r, scratch)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// We expect at least 4 bytes for our uint32.
|
||||
if n < 4 {
|
||||
return tlv.NewTypeForDecodingErr(val,
|
||||
"*paymentConstraints", uint64(n), 4)
|
||||
}
|
||||
|
||||
payConstraints := *c
|
||||
|
||||
payConstraints.MaxCltvExpiry = binary.BigEndian.Uint32(
|
||||
scratch[:4],
|
||||
)
|
||||
|
||||
// This could be empty if our minimum is zero, that's okay.
|
||||
var (
|
||||
b = bytes.NewBuffer(scratch[4:])
|
||||
minHtlc uint64
|
||||
)
|
||||
|
||||
err = tlv.DTUint64(b, &minHtlc, buf, l-4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
payConstraints.HtlcMinimumMsat = lnwire.MilliSatoshi(minHtlc)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
return tlv.NewTypeForDecodingErr(val, "**PaymentConstraints", l, l)
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
const (
|
||||
// CustomTypeStart is the start of the custom tlv type range as defined
|
||||
// in BOLT 01.
|
||||
CustomTypeStart = 65536
|
||||
)
|
||||
|
||||
// CustomSet stores a set of custom key/value pairs.
|
||||
type CustomSet map[uint64][]byte
|
||||
|
||||
// Validate checks that all custom records are in the custom type range.
|
||||
func (c CustomSet) Validate() error {
|
||||
for key := range c {
|
||||
if key < CustomTypeStart {
|
||||
return fmt.Errorf("no custom records with types "+
|
||||
"below %v allowed", CustomTypeStart)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsKeysend checks if the custom records contain the key send type.
|
||||
func (c CustomSet) IsKeysend() bool {
|
||||
return c[KeySendType] != nil
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package record
|
||||
|
||||
const (
|
||||
// KeySendType is the custom record identifier for keysend preimages.
|
||||
KeySendType uint64 = 5482373484
|
||||
)
|
||||
@@ -0,0 +1,99 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"github.com/btcsuite/btcd/btcec/v2"
|
||||
"github.com/lightningnetwork/lnd/tlv"
|
||||
)
|
||||
|
||||
const (
|
||||
// AmtOnionType is the type used in the onion to reference the amount to
|
||||
// send to the next hop.
|
||||
AmtOnionType tlv.Type = 2
|
||||
|
||||
// LockTimeTLV is the type used in the onion to reference the CLTV
|
||||
// value that should be used for the next hop's HTLC.
|
||||
LockTimeOnionType tlv.Type = 4
|
||||
|
||||
// NextHopOnionType is the type used in the onion to reference the ID
|
||||
// of the next hop.
|
||||
NextHopOnionType tlv.Type = 6
|
||||
|
||||
// EncryptedDataOnionType is the type used to include encrypted data
|
||||
// provided by the receiver in the onion for use in blinded paths.
|
||||
EncryptedDataOnionType tlv.Type = 10
|
||||
|
||||
// BlindingPointOnionType is the type used to include receiver provided
|
||||
// ephemeral keys in the onion that are used in blinded paths.
|
||||
BlindingPointOnionType tlv.Type = 12
|
||||
|
||||
// MetadataOnionType is the type used in the onion for the payment
|
||||
// metadata.
|
||||
MetadataOnionType tlv.Type = 16
|
||||
|
||||
// TotalAmtMsatBlindedType is the type used in the onion for the total
|
||||
// amount field that is included in the final hop for blinded payments.
|
||||
TotalAmtMsatBlindedType tlv.Type = 18
|
||||
)
|
||||
|
||||
// NewAmtToFwdRecord creates a tlv.Record that encodes the amount_to_forward
|
||||
// (type 2) for an onion payload.
|
||||
func NewAmtToFwdRecord(amt *uint64) tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
AmtOnionType, amt, func() uint64 {
|
||||
return tlv.SizeTUint64(*amt)
|
||||
},
|
||||
tlv.ETUint64, tlv.DTUint64,
|
||||
)
|
||||
}
|
||||
|
||||
// NewLockTimeRecord creates a tlv.Record that encodes the outgoing_cltv_value
|
||||
// (type 4) for an onion payload.
|
||||
func NewLockTimeRecord(lockTime *uint32) tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
LockTimeOnionType, lockTime, func() uint64 {
|
||||
return tlv.SizeTUint32(*lockTime)
|
||||
},
|
||||
tlv.ETUint32, tlv.DTUint32,
|
||||
)
|
||||
}
|
||||
|
||||
// NewNextHopIDRecord creates a tlv.Record that encodes the short_channel_id
|
||||
// (type 6) for an onion payload.
|
||||
func NewNextHopIDRecord(cid *uint64) tlv.Record {
|
||||
return tlv.MakePrimitiveRecord(NextHopOnionType, cid)
|
||||
}
|
||||
|
||||
// NewEncryptedDataRecord creates a tlv.Record that encodes the encrypted_data
|
||||
// (type 10) record for an onion payload.
|
||||
func NewEncryptedDataRecord(data *[]byte) tlv.Record {
|
||||
return tlv.MakePrimitiveRecord(EncryptedDataOnionType, data)
|
||||
}
|
||||
|
||||
// NewBlindingPointRecord creates a tlv.Record that encodes the blinding_point
|
||||
// (type 12) record for an onion payload.
|
||||
func NewBlindingPointRecord(point **btcec.PublicKey) tlv.Record {
|
||||
return tlv.MakePrimitiveRecord(BlindingPointOnionType, point)
|
||||
}
|
||||
|
||||
// NewMetadataRecord creates a tlv.Record that encodes the metadata (type 10)
|
||||
// for an onion payload.
|
||||
func NewMetadataRecord(metadata *[]byte) tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
MetadataOnionType, metadata,
|
||||
func() uint64 {
|
||||
return uint64(len(*metadata))
|
||||
},
|
||||
tlv.EVarBytes, tlv.DVarBytes,
|
||||
)
|
||||
}
|
||||
|
||||
// NewTotalAmtMsatBlinded creates a tlv.Record that encodes the
|
||||
// total_amount_msat for the final an onion payload within a blinded route.
|
||||
func NewTotalAmtMsatBlinded(amt *uint64) tlv.Record {
|
||||
return tlv.MakeDynamicRecord(
|
||||
TotalAmtMsatBlindedType, amt, func() uint64 {
|
||||
return tlv.SizeTUint64(*amt)
|
||||
},
|
||||
tlv.ETUint64, tlv.DTUint64,
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package record
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/lightningnetwork/lnd/payments/db/migration1/lnwire"
|
||||
"github.com/lightningnetwork/lnd/tlv"
|
||||
)
|
||||
|
||||
// MPPOnionType is the type used in the onion to reference the MPP fields:
|
||||
// total_amt and payment_addr.
|
||||
const MPPOnionType tlv.Type = 8
|
||||
|
||||
// MPP is a record that encodes the fields necessary for multi-path payments.
|
||||
type MPP struct {
|
||||
// paymentAddr is a random, receiver-generated value used to avoid
|
||||
// collisions with concurrent payers.
|
||||
paymentAddr [32]byte
|
||||
|
||||
// totalMsat is the total value of the payment, potentially spread
|
||||
// across more than one HTLC.
|
||||
totalMsat lnwire.MilliSatoshi
|
||||
}
|
||||
|
||||
// NewMPP generates a new MPP record with the given total and payment address.
|
||||
func NewMPP(total lnwire.MilliSatoshi, addr [32]byte) *MPP {
|
||||
return &MPP{
|
||||
paymentAddr: addr,
|
||||
totalMsat: total,
|
||||
}
|
||||
}
|
||||
|
||||
// PaymentAddr returns the payment address contained in the MPP record.
|
||||
func (r *MPP) PaymentAddr() [32]byte {
|
||||
return r.paymentAddr
|
||||
}
|
||||
|
||||
// TotalMsat returns the total value of an MPP payment in msats.
|
||||
func (r *MPP) TotalMsat() lnwire.MilliSatoshi {
|
||||
return r.totalMsat
|
||||
}
|
||||
|
||||
// MPPEncoder writes the MPP record to the provided io.Writer.
|
||||
func MPPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
|
||||
if v, ok := val.(*MPP); ok {
|
||||
err := tlv.EBytes32(w, &v.paymentAddr, buf)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tlv.ETUint64T(w, uint64(v.totalMsat), buf)
|
||||
}
|
||||
return tlv.NewTypeForEncodingErr(val, "MPP")
|
||||
}
|
||||
|
||||
const (
|
||||
// minMPPLength is the minimum length of a serialized MPP TLV record,
|
||||
// which occurs when the truncated encoding of total_amt_msat takes 0
|
||||
// bytes, leaving only the payment_addr.
|
||||
minMPPLength = 32
|
||||
|
||||
// maxMPPLength is the maximum length of a serialized MPP TLV record,
|
||||
// which occurs when the truncated encoding of total_amt_msat takes 8
|
||||
// bytes.
|
||||
maxMPPLength = 40
|
||||
)
|
||||
|
||||
// MPPDecoder reads the MPP record to the provided io.Reader.
|
||||
func MPPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
|
||||
if v, ok := val.(*MPP); ok && minMPPLength <= l && l <= maxMPPLength {
|
||||
if err := tlv.DBytes32(r, &v.paymentAddr, buf, 32); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var total uint64
|
||||
if err := tlv.DTUint64(r, &total, buf, l-32); err != nil {
|
||||
return err
|
||||
}
|
||||
v.totalMsat = lnwire.MilliSatoshi(total)
|
||||
|
||||
return nil
|
||||
}
|
||||
return tlv.NewTypeForDecodingErr(val, "MPP", l, maxMPPLength)
|
||||
}
|
||||
|
||||
// Record returns a tlv.Record that can be used to encode or decode this record.
|
||||
func (r *MPP) Record() tlv.Record {
|
||||
// Fixed-size, 32 byte payment address followed by truncated 64-bit
|
||||
// total msat.
|
||||
size := func() uint64 {
|
||||
return 32 + tlv.SizeTUint64(uint64(r.totalMsat))
|
||||
}
|
||||
|
||||
return tlv.MakeDynamicRecord(
|
||||
MPPOnionType, r, size, MPPEncoder, MPPDecoder,
|
||||
)
|
||||
}
|
||||
|
||||
// PayloadSize returns the size this record takes up in encoded form.
|
||||
func (r *MPP) PayloadSize() uint64 {
|
||||
return 32 + tlv.SizeTUint64(uint64(r.totalMsat))
|
||||
}
|
||||
|
||||
// String returns a human-readable representation of the mpp payload field.
|
||||
func (r *MPP) String() string {
|
||||
if r == nil {
|
||||
return "<nil>"
|
||||
}
|
||||
|
||||
return fmt.Sprintf("total=%v, addr=%x", r.totalMsat, r.paymentAddr)
|
||||
}
|
||||
Reference in new issue
Block a user