WIP

Author: thomash-acinq

eclair-core/src/main/scala/fr/acinq/eclair/Eclair.scala

@@ -389,11 +389,11 @@ class EclairImpl(appKit: Kit) extends Eclair with Logging {
 
   override def disableOffer(offer: Offer)(implicit timeout: Timeout): Unit = {
     appKit.offerManager ! OfferManager.DisableOffer(offer)
-    appKit.nodeParams.db.offers.disableOffer(offer)
+    appKit.nodeParams.db.managedOffers.disableOffer(offer)
   }
 
   override def listOffers(onlyActive: Boolean = true)(implicit timeout: Timeout): Future[Seq[Offer]] = Future {
-    appKit.nodeParams.db.offers.listOffers(onlyActive).map(_.offer)
+    appKit.nodeParams.db.managedOffers.listOffers(onlyActive).map(_.offer)
   }
 
   override def newAddress(): Future[String] = {

eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala

@@ -359,6 +359,7 @@ class Setup(val datadir: File,
       register = system.actorOf(SimpleSupervisor.props(Register.props(), "register", SupervisorStrategy.Resume))
       offerManager = system.spawn(Behaviors.supervise(OfferManager(nodeParams, paymentTimeout = 1 minute)).onFailure(typed.SupervisorStrategy.resume), name = "offer-manager")
       defaultOfferHandler = system.spawn(Behaviors.supervise(DefaultHandler(nodeParams, router)).onFailure(typed.SupervisorStrategy.resume), name = "default-offer-handler")
+      _ = for (offer <- nodeParams.db.managedOffers.listOffers(onlyActive = true)) offerManager ! OfferManager.RegisterOffer(offer.offer, None, offer.pathId_opt, defaultOfferHandler)
       paymentHandler = system.actorOf(SimpleSupervisor.props(PaymentHandler.props(nodeParams, register, offerManager), "payment-handler", SupervisorStrategy.Resume))
       triggerer = system.spawn(Behaviors.supervise(AsyncPaymentTriggerer()).onFailure(typed.SupervisorStrategy.resume), name = "async-payment-triggerer")
       peerReadyManager = system.spawn(Behaviors.supervise(PeerReadyManager()).onFailure(typed.SupervisorStrategy.restart), name = "peer-ready-manager")

eclair-core/src/main/scala/fr/acinq/eclair/db/Databases.scala

@@ -43,7 +43,7 @@ trait Databases {
   def channels: ChannelsDb
   def peers: PeersDb
   def payments: PaymentsDb
-  def offers: OffersDb
+  def managedOffers: OffersDb
   def pendingCommands: PendingCommandsDb
   def liquidity: LiquidityDb
   //@formatter:on
@@ -67,7 +67,7 @@ object Databases extends Logging {
                                      channels: SqliteChannelsDb,
                                      peers: SqlitePeersDb,
                                      payments: SqlitePaymentsDb,
-                                     offers: SqliteOffersDb,
+                                     managedOffers: SqliteOffersDb,
                                      pendingCommands: SqlitePendingCommandsDb,
                                      private val backupConnection: Connection) extends Databases with FileBackup {
     override def backup(backupFile: File): Unit = SqliteUtils.using(backupConnection.createStatement()) {
@@ -87,7 +87,7 @@ object Databases extends Logging {
         channels = new SqliteChannelsDb(eclairJdbc),
         peers = new SqlitePeersDb(eclairJdbc),
         payments = new SqlitePaymentsDb(eclairJdbc),
-        offers = new SqliteOffersDb(eclairJdbc),
+        managedOffers = new SqliteOffersDb(eclairJdbc),
         pendingCommands = new SqlitePendingCommandsDb(eclairJdbc),
         backupConnection = eclairJdbc
       )
@@ -100,7 +100,7 @@ object Databases extends Logging {
                                        channels: PgChannelsDb,
                                        peers: PgPeersDb,
                                        payments: PgPaymentsDb,
-                                       offers: PgOffersDb,
+                                       managedOffers: PgOffersDb,
                                        pendingCommands: PgPendingCommandsDb,
                                        dataSource: HikariDataSource,
                                        lock: PgLock) extends Databases with ExclusiveLock {
@@ -161,7 +161,7 @@ object Databases extends Logging {
         channels = new PgChannelsDb,
         peers = new PgPeersDb,
         payments = new PgPaymentsDb,
-        offers = new PgOffersDb,
+        managedOffers = new PgOffersDb,
         pendingCommands = new PgPendingCommandsDb,
         dataSource = ds,
         lock = lock)

eclair-core/src/main/scala/fr/acinq/eclair/db/DualDatabases.scala

@@ -36,7 +36,7 @@ case class DualDatabases(primary: Databases, secondary: Databases) extends Datab
   override val channels: ChannelsDb = DualChannelsDb(primary.channels, secondary.channels)
   override val peers: PeersDb = DualPeersDb(primary.peers, secondary.peers)
   override val payments: PaymentsDb = DualPaymentsDb(primary.payments, secondary.payments)
-  override val offers: OffersDb = DualOffersDb(primary.offers, secondary.offers)
+  override val managedOffers: OffersDb = DualOffersDb(primary.managedOffers, secondary.managedOffers)
   override val pendingCommands: PendingCommandsDb = DualPendingCommandsDb(primary.pendingCommands, secondary.pendingCommands)
   override val liquidity: LiquidityDb = DualLiquidityDb(primary.liquidity, secondary.liquidity)
 

eclair-core/src/main/scala/fr/acinq/eclair/db/OffersDb.scala

@@ -21,10 +21,25 @@ import fr.acinq.eclair.wire.protocol.OfferTypes.Offer
 
 case class OfferData(offer: Offer, pathId_opt: Option[ByteVector32])
 
+/**
+ * Database for offers fully managed by eclair, as opposed to offers managed by a plugin.
+ */
 trait OffersDb {
+  /**
+   * Add an offer managed by eclair.
+   * @param pathId_opt If the offer uses a blinded path, this is the corresponding pathId.
+   */
   def addOffer(offer: Offer, pathId_opt: Option[ByteVector32]): Unit
 
+  /**
+   * Disable an offer. The offer is still stored but new invoice requests and new payment attempts for already emitted
+   * invoices will be rejected. To reenable an offer, use `addOffer`.
+   */
   def disableOffer(offer: Offer): Unit
 
+  /**
+   * List offers managed by eclair.
+   * @param onlyActive Whether to return only active offers or also disabled ones.
+   */
   def listOffers(onlyActive: Boolean): Seq[OfferData]
 }

eclair-core/src/main/scala/fr/acinq/eclair/payment/offer/DefaultHandler.scala

@@ -20,12 +20,16 @@ import akka.actor.typed.Behavior
 import akka.actor.typed.scaladsl.Behaviors
 import akka.actor.{ActorRef, typed}
 import akka.util.Collections
+import fr.acinq.bitcoin.scalacompat.{ByteVector32, Crypto}
 import fr.acinq.eclair.crypto.Sphinx.RouteBlinding.BlindedRoute
+import fr.acinq.eclair.payment.offer.OfferManager.InvoiceRequestActor
 import fr.acinq.eclair.payment.receive.MultiPartHandler.ReceivingRoute
 import fr.acinq.eclair.router.Router
 import fr.acinq.eclair.router.Router.BlindedRouteRequest
 import fr.acinq.eclair.wire.protocol.OfferTypes
-import fr.acinq.eclair.{EncodedNodeId, MilliSatoshi, MilliSatoshiLong, NodeParams}
+import fr.acinq.eclair.{CltvExpiryDelta, EncodedNodeId, MilliSatoshi, MilliSatoshiLong, NodeParams}
+import scodec.bits.ByteVector
+import scodec.codecs.{int32, uint32}
 
 import scala.collection.immutable.{AbstractSeq, LinearSeq}
 
@@ -36,15 +40,15 @@ object DefaultHandler {
         case OfferManager.HandleInvoiceRequest(replyTo, invoiceRequest) =>
           val amount = invoiceRequest.amount.getOrElse(10_000_000.msat)
           invoiceRequest.offer.contactInfos.head match {
-            case OfferTypes.RecipientNodeId(nodeId) =>
-              val route = ReceivingRoute(Seq(nodeId), nodeParams.channelConf.maxExpiryDelta)
-              replyTo ! OfferManager.InvoiceRequestActor.ApproveRequest(amount, Seq(route), None)
+            case OfferTypes.RecipientNodeId(_) =>
+              val route = InvoiceRequestActor.Route(Nil, nodeParams.channelConf.maxExpiryDelta)
+              replyTo ! InvoiceRequestActor.ApproveRequest(amount, Seq(route), hideFees = true)
             case OfferTypes.BlindedPath(BlindedRoute(firstNodeId: EncodedNodeId.WithPublicKey, _, _)) =>
               val routeParams = nodeParams.routerConf.pathFindingExperimentConf.getRandomConf().getDefaultRouteParams
               router ! BlindedRouteRequest(context.spawnAnonymous(waitForRoute(nodeParams, replyTo, amount)), firstNodeId.publicKey, nodeParams.nodeId, amount, routeParams, pathsToFind = 2)
             case OfferTypes.BlindedPath(BlindedRoute(_: EncodedNodeId.ShortChannelIdDir, _, _)) =>
               context.log.error("unexpected managed offer with compact first node id")
-              replyTo ! OfferManager.InvoiceRequestActor.RejectRequest("internal error")
+              replyTo ! InvoiceRequestActor.RejectRequest("internal error")
           }
           Behaviors.same
         case OfferManager.HandlePayment(replyTo, _, _) =>
@@ -54,18 +58,17 @@ object DefaultHandler {
     )
   }
 
-  def waitForRoute(nodeParams: NodeParams, replyTo: typed.ActorRef[OfferManager.InvoiceRequestActor.Command], amount: MilliSatoshi): Behavior[Router.PaymentRouteResponse] = {
+  def waitForRoute(nodeParams: NodeParams, replyTo: typed.ActorRef[InvoiceRequestActor.Command], amount: MilliSatoshi): Behavior[Router.PaymentRouteResponse] = {
     Behaviors.receiveMessage {
       case Router.RouteResponse(routes) =>
         val receivingRoutes = routes.map(route => {
-          val nodes = route.hops.head.nodeId +: route.hops.map(_.nextNodeId)
-          ReceivingRoute(nodes, nodeParams.channelConf.maxExpiryDelta, dummyHops = ???)
+          InvoiceRequestActor.Route(route.hops, nodeParams.channelConf.maxExpiryDelta)
         })
-        replyTo ! OfferManager.InvoiceRequestActor.ApproveRequest(amount, receivingRoutes, None)
+        replyTo ! InvoiceRequestActor.ApproveRequest(amount, receivingRoutes, hideFees = true)
         Behaviors.stopped
       case Router.PaymentRouteNotFound(error) =>
         // TODO: log error
-        replyTo ! OfferManager.InvoiceRequestActor.RejectRequest("internal error")
+        replyTo ! InvoiceRequestActor.RejectRequest("internal error")
         Behaviors.stopped
     }
 

eclair-core/src/main/scala/fr/acinq/eclair/payment/offer/OfferCreator.scala

@@ -112,7 +112,7 @@ private class OfferCreator(context: ActorContext[OfferCreator.Command],
   }
 
   private def registerOffer(offer: Offer, pathId_opt: Option[ByteVector32]): Behavior[Command] = {
-    nodeParams.db.offers.addOffer(offer, pathId_opt)
+    nodeParams.db.managedOffers.addOffer(offer, pathId_opt)
     offerManager ! OfferManager.RegisterOffer(offer, None, pathId_opt, defaultOfferHandler)
     replyTo ! Right(offer)
     Behaviors.stopped

eclair-core/src/main/scala/fr/acinq/eclair/router/Graph.scala

@@ -448,8 +448,8 @@ object Graph {
                          pathsToFind: Int,
                          wr: WeightRatios[PaymentPathWeight],
                          currentBlockHeight: BlockHeight,
-                         boundaries: PaymentPathWeight => Boolean): Seq[WeightedPath] = {
-    val paths = new mutable.ArrayBuffer[WeightedPath](pathsToFind)
+                         boundaries: PaymentPathWeight => Boolean): Seq[WeightedPath[PaymentPathWeight]] = {
+    val paths = new mutable.ArrayBuffer[WeightedPath[PaymentPathWeight]](pathsToFind)
     val verticesToIgnore = new mutable.HashSet[PublicKey]()
     verticesToIgnore.addAll(ignoredVertices)
     for (_ <- 1 to pathsToFind) {

eclair-core/src/test/scala/fr/acinq/eclair/TestDatabases.scala

@@ -33,7 +33,7 @@ sealed trait TestDatabases extends Databases {
   override def channels: ChannelsDb = db.channels
   override def peers: PeersDb = db.peers
   override def payments: PaymentsDb = db.payments
-  override def offers: OffersDb = db.offers
+  override def managedOffers: OffersDb = db.managedOffers
   override def pendingCommands: PendingCommandsDb = db.pendingCommands
   override def liquidity: LiquidityDb = db.liquidity
   def close(): Unit

eclair-core/src/test/scala/fr/acinq/eclair/payment/offer/OfferManagerSpec.scala

@@ -314,7 +314,7 @@ class OfferManagerSpec extends ScalaTestWithActorTestKit(ConfigFactory.load("app
     offerManager ! ReceivePayment(paymentHandler.ref, invoice.paymentHash, paymentPayload, amountAfterFee(1000 msat, 200, amount))
 
     val handlePayment = handler.expectMessageType[HandlePayment]
-    assert(handlePayment.offerId == offer.offerId)
+    assert(handlePayment.offer == offer)
     handlePayment.replyTo ! PaymentActor.AcceptPayment()
     val ProcessPayment(incomingPayment, hiddenRelayFees) = paymentHandler.expectMessageType[ProcessPayment]
     assert(Crypto.sha256(incomingPayment.paymentPreimage) == invoice.paymentHash)