Include payment metadata in all invoices

We include a payment metadata in every invoice we generate. This lets us
see whether our payers support it or not, which is important data to have
before we make it mandatory and use it for storage-less invoices.

Author: t-bast

eclair-core/src/main/scala/fr/acinq/eclair/payment/PaymentPacket.scala

@@ -213,7 +213,10 @@ object OutgoingPaymentPacket {
    *         - the trampoline onion to include in final payload of a normal onion
    */
   def buildTrampolineToLegacyPacket(invoice: PaymentRequest, hops: Seq[NodeHop], finalPayload: PaymentOnion.FinalPayload): (MilliSatoshi, CltvExpiry, Sphinx.PacketAndSecrets) = {
-    val (firstAmount, firstExpiry, payloads) = hops.drop(1).reverse.foldLeft((finalPayload.amount, finalPayload.expiry, Seq[PaymentOnion.PerHopPayload](finalPayload))) {
+    // NB: the final payload will never reach the recipient, since the next-to-last trampoline hop will convert that to a legacy payment
+    // We use the smallest final payload possible, otherwise we may overflow the trampoline onion size.
+    val dummyFinalPayload = PaymentOnion.createSinglePartPayload(finalPayload.amount, finalPayload.expiry, finalPayload.paymentSecret, None)
+    val (firstAmount, firstExpiry, payloads) = hops.drop(1).reverse.foldLeft((finalPayload.amount, finalPayload.expiry, Seq[PaymentOnion.PerHopPayload](dummyFinalPayload))) {
       case ((amount, expiry, payloads), hop) =>
         // The next-to-last trampoline hop must include invoice data to indicate the conversion to a legacy payment.
         val payload = if (payloads.length == 1) {

eclair-core/src/main/scala/fr/acinq/eclair/payment/receive/MultiPartHandler.scala

@@ -22,7 +22,7 @@ import akka.actor.typed.scaladsl.Behaviors
 import akka.actor.typed.scaladsl.adapter.ClassicActorContextOps
 import akka.actor.{ActorContext, ActorRef, PoisonPill, Status}
 import akka.event.{DiagnosticLoggingAdapter, LoggingAdapter}
-import fr.acinq.bitcoin.{ByteVector32, Crypto}
+import fr.acinq.bitcoin.{ByteVector32, ByteVector64, Crypto}
 import fr.acinq.eclair.channel.{CMD_FAIL_HTLC, CMD_FULFILL_HTLC, RES_SUCCESS}
 import fr.acinq.eclair.db._
 import fr.acinq.eclair.payment.Monitoring.{Metrics, Tags}
@@ -71,7 +71,13 @@ class MultiPartHandler(nodeParams: NodeParams, register: ActorRef, db: IncomingP
               Metrics.PaymentFailed.withTag(Tags.Direction, Tags.Directions.Received).withTag(Tags.Failure, Tags.FailureType(cmdFail)).increment()
               PendingCommandsDb.safeSend(register, nodeParams.db.pendingCommands, p.add.channelId, cmdFail)
             case None =>
-              log.info("received payment for amount={} totalAmount={}", p.add.amountMsat, p.payload.totalAmount)
+              // We log whether the sender included the payment metadata field.
+              // We always set it in our invoices to test whether senders support it.
+              // Once all incoming payments correctly set that field, we can make it mandatory.
+              p.payload.paymentMetadata match {
+                case Some(paymentMetadata) => log.info("received payment for amount={} totalAmount={} paymentMetadata={}", p.add.amountMsat, p.payload.totalAmount, paymentMetadata.toHex)
+                case None => log.info("received payment for amount={} totalAmount={} without payment metadata", p.add.amountMsat, p.payload.totalAmount)
+              }
               pendingPayments.get(p.add.paymentHash) match {
                 case Some((_, handler)) =>
                   handler ! MultiPartPaymentFSM.HtlcPart(p.payload.totalAmount, p.add)
@@ -223,12 +229,25 @@ object MultiPartHandler {
               val paymentPreimage = paymentPreimage_opt.getOrElse(randomBytes32())
               val paymentHash = Crypto.sha256(paymentPreimage)
               val expirySeconds = expirySeconds_opt.getOrElse(nodeParams.paymentRequestExpiry.toSeconds)
+              val paymentMetadata = Some(ByteVector64.Zeroes.bytes)
               val invoiceFeatures = {
                 val activatedInvoiceFeatures = nodeParams.features.invoiceFeatures().activated.map { case (f, s) => f.supportBit(s) }.toSet
                 val allInvoiceFeatures = if (nodeParams.enableTrampolinePayment) activatedInvoiceFeatures + Features.TrampolinePayment.optional else activatedInvoiceFeatures
                 allInvoiceFeatures.toSeq
               }
-              val paymentRequest = PaymentRequest(nodeParams.chainHash, amount_opt, paymentHash, nodeParams.privateKey, description, nodeParams.minFinalExpiryDelta, fallbackAddress_opt, expirySeconds = Some(expirySeconds), extraHops = extraHops, features = PaymentRequestFeatures(invoiceFeatures: _*))
+              val paymentRequest = PaymentRequest(
+                nodeParams.chainHash,
+                amount_opt,
+                paymentHash,
+                nodeParams.privateKey,
+                description,
+                nodeParams.minFinalExpiryDelta,
+                fallbackAddress_opt,
+                expirySeconds = Some(expirySeconds),
+                extraHops = extraHops,
+                paymentMetadata = paymentMetadata,
+                features = PaymentRequestFeatures(invoiceFeatures: _*)
+              )
               context.log.debug("generated payment request={} from amount={}", PaymentRequest.write(paymentRequest), amount_opt)
               nodeParams.db.payments.addIncomingPayment(paymentRequest, paymentPreimage, paymentType)
               paymentRequest

eclair-core/src/test/scala/fr/acinq/eclair/payment/PaymentInitiatorSpec.scala

@@ -28,6 +28,7 @@ import fr.acinq.eclair.payment.OutgoingPaymentPacket.Upstream
 import fr.acinq.eclair.payment.PaymentPacketSpec._
 import fr.acinq.eclair.payment.PaymentRequest.{ExtraHop, PaymentRequestFeatures}
 import fr.acinq.eclair.payment.send.MultiPartPaymentLifecycle.SendMultiPartPayment
+import fr.acinq.eclair.payment.send.PaymentError.UnsupportedFeatures
 import fr.acinq.eclair.payment.send.PaymentInitiator._
 import fr.acinq.eclair.payment.send.{PaymentError, PaymentInitiator, PaymentLifecycle}
 import fr.acinq.eclair.router.RouteNotFound
@@ -122,6 +123,7 @@ class PaymentInitiatorSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike
     val fail = sender.expectMsgType[PaymentFailed]
     assert(fail.id === id)
     assert(fail.failures.head.isInstanceOf[LocalFailure])
+    assert(fail.failures.head.asInstanceOf[LocalFailure].t === UnsupportedFeatures(pr.features.features))
   }
 
   test("forward payment with pre-defined route") { f =>