Enhance update_add_htlc with remote peer's custom records

channeldb/channel.go

@@ -2550,6 +2550,12 @@ type HTLC struct {
  // HTLC. It is stored in the ExtraData field, which is used to store
  // a TLV stream of additional information associated with the HTLC.
  BlindingPoint lnwire.BlindingPointRecord
+
+ // CustomRecords is a set of custom TLV records that are associated with
+ // this HTLC. These records are used to store additional information
+ // about the HTLC that is not part of the standard HTLC fields. This
+ // field is encoded within the ExtraData field.
+ CustomRecords lnwire.CustomRecords
 }
 
 // serializeExtraData encodes a TLV stream of extra data to be stored with a
@@ -2568,6 +2574,11 @@ func (h *HTLC) serializeExtraData() error {
  records = append(records, &b)
  })
 
+ records, err := h.CustomRecords.ExtendRecordProducers(records)
+ if err != nil {
+ return err
+ }
+
  return h.ExtraData.PackRecords(records...)
 }
 
@@ -2589,7 +2600,18 @@ func (h *HTLC) deserializeExtraData() error {
 
  if val, ok := tlvMap[h.BlindingPoint.TlvType()]; ok && val == nil {
  h.BlindingPoint = tlv.SomeRecordT(blindingPoint)
+
+ // Remove the entry from the TLV map. Anything left in the map
+ // will be included in the custom records field.
+ delete(tlvMap, h.BlindingPoint.TlvType())
+ }
+
+ // Set the custom records field to the remaining TLV records.
+ customRecords, err := lnwire.NewCustomRecordsFromTlvTypeMap(tlvMap)
+ if err != nil {
+ return err
  }
+ h.CustomRecords = customRecords
 
  return nil
 }

htlcswitch/interceptable_switch.go

@@ -5,6 +5,7 @@ import (
  "fmt"
  "sync"
 
+ "github.com/davecgh/go-spew/spew"
  "github.com/go-errors/errors"
  "github.com/lightningnetwork/lnd/chainntnfs"
  "github.com/lightningnetwork/lnd/channeldb/models"
@@ -622,15 +623,16 @@ func (f *interceptedForward) Packet() InterceptedPacket {
  ChanID: f.packet.incomingChanID,
  HtlcID: f.packet.incomingHTLCID,
  },
- OutgoingChanID: f.packet.outgoingChanID,
- Hash: f.htlc.PaymentHash,
- OutgoingExpiry: f.htlc.Expiry,
- OutgoingAmount: f.htlc.Amount,
- IncomingAmount: f.packet.incomingAmount,
- IncomingExpiry: f.packet.incomingTimeout,
- CustomRecords: f.packet.customRecords,
- OnionBlob: f.htlc.OnionBlob,
- AutoFailHeight: f.autoFailHeight,
+ OutgoingChanID: f.packet.outgoingChanID,
+ Hash: f.htlc.PaymentHash,
+ OutgoingExpiry: f.htlc.Expiry,
+ OutgoingAmount: f.htlc.Amount,
+ IncomingAmount: f.packet.incomingAmount,
+ IncomingExpiry: f.packet.incomingTimeout,
+ CustomRecords: f.packet.customRecords,
+ OnionBlob: f.htlc.OnionBlob,
+ AutoFailHeight: f.autoFailHeight,
+ IncomingWireCustomRecords: f.packet.incomingCustomRecords,
  }
 }
 
@@ -659,50 +661,58 @@ func (f *interceptedForward) ResumeModified(
  htlc.Amount = amount
  })
 
- //nolint:lll
- err := fn.MapOptionZ(customRecords, func(records record.CustomSet) error {
- if len(records) == 0 {
- return nil
- }
+ err := fn.MapOptionZ(
+  customRecords, func(records record.CustomSet) error {
+  if len(records) == 0 {
+  return nil
+  }
 
- // Type cast and validate custom records.
- htlc.CustomRecords = lnwire.CustomRecords(records)
- err := htlc.CustomRecords.Validate()
- if err != nil {
- return fmt.Errorf("failed to validate custom "+
- "records: %w", err)
- }
+ // Type cast and validate custom records.
+ htlc.CustomRecords = lnwire.CustomRecords(
+ records,
+ )
+ err := htlc.CustomRecords.Validate()
+ if err != nil {
+ return fmt.Errorf("failed to validate "+
+ "custom records: %w", err)
+ }
 
- return nil
- })
+ return nil
+ },
+ )
  if err != nil {
  return fmt.Errorf("failed to encode custom records: %w",
  err)
  }
 
  case *lnwire.UpdateFulfillHTLC:
- //nolint:lll
- err := fn.MapOptionZ(customRecords, func(records record.CustomSet) error {
- if len(records) == 0 {
- return nil
- }
+ err := fn.MapOptionZ(
+  customRecords, func(records record.CustomSet) error {
+  if len(records) == 0 {
+  return nil
+  }
 
- // Type cast and validate custom records.
- htlc.CustomRecords = lnwire.CustomRecords(records)
- err := htlc.CustomRecords.Validate()
- if err != nil {
- return fmt.Errorf("failed to validate custom "+
- "records: %w", err)
- }
+ // Type cast and validate custom records.
+ htlc.CustomRecords = lnwire.CustomRecords(
+ records,
+ )
+ err := htlc.CustomRecords.Validate()
+ if err != nil {
+ return fmt.Errorf("failed to validate "+
+ "custom records: %w", err)
+ }
 
- return nil
- })
+ return nil
+ },
+ )
  if err != nil {
  return fmt.Errorf("failed to encode custom records: %w",
  err)
  }
  }
 
+ log.Tracef("Forwarding packet %v", spew.Sdump(f.packet))
+
  // Forward to the switch. A link quit channel isn't needed, because we
  // are on a different thread now.
  return f.htlcSwitch.ForwardPackets(nil, f.packet)

htlcswitch/interfaces.go

@@ -357,6 +357,10 @@ type InterceptedPacket struct {
  // OnionBlob is the onion packet for the next hop
  OnionBlob [lnwire.OnionPacketSize]byte
 
+ // IncomingWireCustomRecords are user-defined records that were defined
+ // by the peer that forwarded this htlc to us.
+ IncomingWireCustomRecords record.CustomSet
+
  // AutoFailHeight is the block height at which this intercept will be
  // failed back automatically.
  AutoFailHeight int32

htlcswitch/link.go

@@ -29,7 +29,9 @@ import (
  "github.com/lightningnetwork/lnd/lnwallet/chainfee"
  "github.com/lightningnetwork/lnd/lnwire"
  "github.com/lightningnetwork/lnd/queue"
+ "github.com/lightningnetwork/lnd/record"
  "github.com/lightningnetwork/lnd/ticker"
+ "github.com/lightningnetwork/lnd/tlv"
 )
 
 func init() {
@@ -3354,6 +3356,27 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg,
  continue
  }
 
+ var customRecords record.CustomSet
+ err = fn.MapOptionZ(
+ pd.CustomRecords, func(b tlv.Blob) error {
+ r, err := lnwire.ParseCustomRecords(b)
+ if err != nil {
+ return err
+ }
+
+ customRecords = record.CustomSet(r)
+
+ return nil
+ },
+ )
+ if err != nil {
+ l.fail(LinkFailureError{
+ code: ErrInternalError,
+ }, err.Error())
+
+ return
+ }
+
  switch fwdPkg.State {
  case channeldb.FwdStateProcessed:
  // This add was not forwarded on the previous
@@ -3367,7 +3390,7 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg,
  }
 
  // Otherwise, it was already processed, we can
- // can collect it and continue.
+ // collect it and continue.
  addMsg := &lnwire.UpdateAddHTLC{
  Expiry: fwdInfo.OutgoingCTLV,
  Amount: fwdInfo.AmountToForward,
@@ -3387,19 +3410,21 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg,
 
  inboundFee := l.cfg.FwrdingPolicy.InboundFee
 
+ //nolint:lll
  updatePacket := &htlcPacket{
- incomingChanID: l.ShortChanID(),
- incomingHTLCID: pd.HtlcIndex,
- outgoingChanID: fwdInfo.NextHop,
- sourceRef: pd.SourceRef,
- incomingAmount: pd.Amount,
- amount: addMsg.Amount,
- htlc: addMsg,
- obfuscator: obfuscator,
- incomingTimeout: pd.Timeout,
- outgoingTimeout: fwdInfo.OutgoingCTLV,
- customRecords: pld.CustomRecords(),
- inboundFee: inboundFee,
+ incomingChanID: l.ShortChanID(),
+ incomingHTLCID: pd.HtlcIndex,
+ outgoingChanID: fwdInfo.NextHop,
+ sourceRef: pd.SourceRef,
+ incomingAmount: pd.Amount,
+ amount: addMsg.Amount,
+ htlc: addMsg,
+ obfuscator: obfuscator,
+ incomingTimeout: pd.Timeout,
+ outgoingTimeout: fwdInfo.OutgoingCTLV,
+ customRecords: pld.CustomRecords(),
+ inboundFee: inboundFee,
+ incomingCustomRecords: customRecords,
  }
  switchPackets = append(
  switchPackets, updatePacket,
@@ -3455,19 +3480,21 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg,
  if fwdPkg.State == channeldb.FwdStateLockedIn {
  inboundFee := l.cfg.FwrdingPolicy.InboundFee
 
+ //nolint:lll
  updatePacket := &htlcPacket{
- incomingChanID: l.ShortChanID(),
- incomingHTLCID: pd.HtlcIndex,
- outgoingChanID: fwdInfo.NextHop,
- sourceRef: pd.SourceRef,
- incomingAmount: pd.Amount,
- amount: addMsg.Amount,
- htlc: addMsg,
- obfuscator: obfuscator,
- incomingTimeout: pd.Timeout,
- outgoingTimeout: fwdInfo.OutgoingCTLV,
- customRecords: pld.CustomRecords(),
- inboundFee: inboundFee,
+ incomingChanID: l.ShortChanID(),
+ incomingHTLCID: pd.HtlcIndex,
+ outgoingChanID: fwdInfo.NextHop,
+ sourceRef: pd.SourceRef,
+ incomingAmount: pd.Amount,
+ amount: addMsg.Amount,
+ htlc: addMsg,
+ obfuscator: obfuscator,
+ incomingTimeout: pd.Timeout,
+ outgoingTimeout: fwdInfo.OutgoingCTLV,
+ customRecords: pld.CustomRecords(),
+ inboundFee: inboundFee,
+ incomingCustomRecords: customRecords,
  }
 
  fwdPkg.FwdFilter.Set(idx)

htlcswitch/packet.go

@@ -98,6 +98,10 @@ type htlcPacket struct {
  // were included in the payload.
  customRecords record.CustomSet
 
+ // incomingCustomRecords are custom type range TLVs that are included
+ // in the incoming update_add_htlc.
+ incomingCustomRecords record.CustomSet
+
  // originalOutgoingChanID is used when sending back failure messages.
  // It is only used for forwarded Adds on option_scid_alias channels.
  // This is to avoid possible confusion if a payer uses the public SCID

itest/list_on_test.go

@@ -430,6 +430,10 @@ var allTestCases = []*lntest.TestCase{
  Name: "forward interceptor modified htlc",
  TestFunc: testForwardInterceptorModifiedHtlc,
  },
+ {
+ Name: "forward interceptor wire records",
+ TestFunc: testForwardInterceptorWireRecords,
+ },
  {
  Name: "zero conf channel open",
  TestFunc: testZeroConfChannelOpen,