Add a proper payments database

eclair-core/eclair-cli

@@ -30,8 +30,8 @@ and COMMAND is one of:
   getinfo, connect, open, close, forceclose, updaterelayfee,
   peers, channels, channel, allnodes, allchannels, allupdates,
   receive, parseinvoice, findroute, findroutetonode,
-  send, sendtonode, checkpayment,
-  audit, networkfees, channelstats
+  send, sendtonode, receivedinfo, audit, networkfees,
+  channelstats, sentinfo, invoice, allinvoice, pendinginvoices
 
 Examples
 --------

eclair-core/src/main/resources/reference.conf

@@ -87,7 +87,6 @@ eclair {
 
   payment-handler = "local"
   payment-request-expiry = 1 hour // default expiry for payment requests generated by this node
-  max-pending-payment-requests = 10000000
   min-funding-satoshis = 100000
 
   autoprobe-count = 0 // number of parallel tasks that send test payments to detect invalid channels

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

@@ -1,22 +1,38 @@
+/*
+ * Copyright 2018 ACINQ SAS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package fr.acinq.eclair
 
+import java.util.UUID
 import akka.actor.ActorRef
 import akka.pattern._
 import akka.util.Timeout
 import fr.acinq.bitcoin.Crypto.PublicKey
 import fr.acinq.bitcoin.{ByteVector32, MilliSatoshi, Satoshi}
 import fr.acinq.eclair.channel._
-import fr.acinq.eclair.db.{NetworkFee, Stats}
+import fr.acinq.eclair.db.{NetworkFee, IncomingPayment, OutgoingPayment, Stats}
 import fr.acinq.eclair.io.Peer.{GetPeerInfo, PeerInfo}
 import fr.acinq.eclair.io.{NodeURI, Peer}
 import fr.acinq.eclair.payment.PaymentLifecycle._
-import fr.acinq.eclair.payment.{PaymentLifecycle, PaymentReceived, PaymentRelayed, PaymentRequest, PaymentSent}
 import fr.acinq.eclair.router.{ChannelDesc, RouteRequest, RouteResponse}
-import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, NodeAddress, NodeAnnouncement}
 import scodec.bits.ByteVector
-
 import scala.concurrent.Future
 import scala.concurrent.duration._
+import fr.acinq.eclair.payment.{PaymentReceived, PaymentRelayed, PaymentRequest, PaymentSent}
+import fr.acinq.eclair.wire.{ChannelAnnouncement, ChannelUpdate, NodeAddress, NodeAnnouncement}
 
 case class GetInfoResponse(nodeId: PublicKey, alias: String, chainHash: ByteVector32, blockHeight: Int, publicAddresses: Seq[NodeAddress])
 
@@ -34,32 +50,40 @@ trait Eclair {
 
   def updateRelayFee(channelId: String, feeBaseMsat: Long, feeProportionalMillionths: Long): Future[String]
 
-  def peersInfo(): Future[Iterable[PeerInfo]]
-
   def channelsInfo(toRemoteNode: Option[PublicKey]): Future[Iterable[RES_GETINFO]]
 
   def channelInfo(channelId: ByteVector32): Future[RES_GETINFO]
 
-  def allnodes(): Future[Iterable[NodeAnnouncement]]
-
-  def allchannels(): Future[Iterable[ChannelDesc]]
+  def peersInfo(): Future[Iterable[PeerInfo]]
 
-  def allupdates(nodeId: Option[PublicKey]): Future[Iterable[ChannelUpdate]]
+  def receive(description: String, amountMsat: Option[Long], expire: Option[Long], fallbackAddress: Option[String]): Future[PaymentRequest]
 
-  def receive(description: String, amountMsat: Option[Long], expire: Option[Long]): Future[String]
+  def receivedInfo(paymentHash: ByteVector32): Future[Option[IncomingPayment]]
 
-  def findRoute(targetNodeId: PublicKey, amountMsat: Long, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty): Future[RouteResponse]
+  def send(recipientNodeId: PublicKey, amountMsat: Long, paymentHash: ByteVector32, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, minFinalCltvExpiry: Option[Long] = None): Future[UUID]
 
-  def send(recipientNodeId: PublicKey, amountMsat: Long, paymentHash: ByteVector32, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, minFinalCltvExpiry: Option[Long] = None): Future[PaymentResult]
+  def sentInfo(id: Either[UUID, ByteVector32]): Future[Option[OutgoingPayment]]
 
-  def checkpayment(paymentHash: ByteVector32): Future[Boolean]
+  def findRoute(targetNodeId: PublicKey, amountMsat: Long, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty): Future[RouteResponse]
 
   def audit(from_opt: Option[Long], to_opt: Option[Long]): Future[AuditResponse]
 
   def networkFees(from_opt: Option[Long], to_opt: Option[Long]): Future[Seq[NetworkFee]]
 
   def channelStats(): Future[Seq[Stats]]
 
+  def getInvoice(paymentHash: ByteVector32): Future[Option[PaymentRequest]]
+
+  def pendingInvoices(from_opt: Option[Long], to_opt: Option[Long]): Future[Seq[PaymentRequest]]
+
+  def allInvoices(from_opt: Option[Long], to_opt: Option[Long]): Future[Seq[PaymentRequest]]
+
+  def allNodes(): Future[Iterable[NodeAnnouncement]]
+
+  def allChannels(): Future[Iterable[ChannelDesc]]
+
+  def allUpdates(nodeId: Option[PublicKey]): Future[Iterable[ChannelUpdate]]
+
   def getInfoResponse(): Future[GetInfoResponse]
 
 }
@@ -114,40 +138,43 @@ class EclairImpl(appKit: Kit) extends Eclair {
     sendToChannel(channelId.toString(), CMD_GETINFO).mapTo[RES_GETINFO]
   }
 
-  override def allnodes(): Future[Iterable[NodeAnnouncement]] = (appKit.router ? 'nodes).mapTo[Iterable[NodeAnnouncement]]
+  override def allNodes(): Future[Iterable[NodeAnnouncement]] = (appKit.router ? 'nodes).mapTo[Iterable[NodeAnnouncement]]
 
-  override def allchannels(): Future[Iterable[ChannelDesc]] = {
+  override def allChannels(): Future[Iterable[ChannelDesc]] = {
     (appKit.router ? 'channels).mapTo[Iterable[ChannelAnnouncement]].map(_.map(c => ChannelDesc(c.shortChannelId, c.nodeId1, c.nodeId2)))
   }
 
-  override def allupdates(nodeId: Option[PublicKey]): Future[Iterable[ChannelUpdate]] = nodeId match {
+  override def allUpdates(nodeId: Option[PublicKey]): Future[Iterable[ChannelUpdate]] = nodeId match {
     case None => (appKit.router ? 'updates).mapTo[Iterable[ChannelUpdate]]
     case Some(pk) => (appKit.router ? 'updatesMap).mapTo[Map[ChannelDesc, ChannelUpdate]].map(_.filter(e => e._1.a == pk || e._1.b == pk).values)
   }
 
-  override def receive(description: String, amountMsat: Option[Long], expire: Option[Long]): Future[String] = {
-    (appKit.paymentHandler ? ReceivePayment(description = description, amountMsat_opt = amountMsat.map(MilliSatoshi), expirySeconds_opt = expire)).mapTo[PaymentRequest].map { pr =>
-      PaymentRequest.write(pr)
-    }
+  override def receive(description: String, amountMsat: Option[Long], expire: Option[Long], fallbackAddress: Option[String]): Future[PaymentRequest] = {
+    fallbackAddress.map { fa => fr.acinq.eclair.addressToPublicKeyScript(fa, appKit.nodeParams.chainHash) } // if it's not a bitcoin address throws an exception
+    (appKit.paymentHandler ? ReceivePayment(description = description, amountMsat_opt = amountMsat.map(MilliSatoshi), expirySeconds_opt = expire, fallbackAddress = fallbackAddress)).mapTo[PaymentRequest]
   }
 
   override def findRoute(targetNodeId: PublicKey, amountMsat: Long, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty): Future[RouteResponse] = {
     (appKit.router ? RouteRequest(appKit.nodeParams.nodeId, targetNodeId, amountMsat, assistedRoutes)).mapTo[RouteResponse]
   }
 
-  override def send(recipientNodeId: PublicKey, amountMsat: Long, paymentHash: ByteVector32, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, minFinalCltvExpiry: Option[Long] = None): Future[PaymentResult] = {
+  override def send(recipientNodeId: PublicKey, amountMsat: Long, paymentHash: ByteVector32, assistedRoutes: Seq[Seq[PaymentRequest.ExtraHop]] = Seq.empty, minFinalCltvExpiry: Option[Long] = None): Future[UUID] = {
     val sendPayment = minFinalCltvExpiry match {
       case Some(minCltv) => SendPayment(amountMsat, paymentHash, recipientNodeId, assistedRoutes, finalCltvExpiry = minCltv)
-      case None  => SendPayment(amountMsat, paymentHash, recipientNodeId, assistedRoutes)
+      case None => SendPayment(amountMsat, paymentHash, recipientNodeId, assistedRoutes)
     }
-    (appKit.paymentInitiator ? sendPayment).mapTo[PaymentResult].map {
-      case s: PaymentSucceeded => s
-      case f: PaymentFailed => f.copy(failures = PaymentLifecycle.transformForUser(f.failures))
+    (appKit.paymentInitiator ? sendPayment).mapTo[UUID]
+  }
+
+  override def sentInfo(id: Either[UUID, ByteVector32]): Future[Option[OutgoingPayment]] = Future {
+    id match {
+      case Left(uuid) => appKit.nodeParams.db.payments.getOutgoingPayment(uuid)
+      case Right(paymentHash) => appKit.nodeParams.db.payments.getOutgoingPayment(paymentHash)
     }
   }
 
-  override def checkpayment(paymentHash: ByteVector32): Future[Boolean] = {
-    (appKit.paymentHandler ? CheckPayment(paymentHash)).mapTo[Boolean]
+  override def receivedInfo(paymentHash: ByteVector32): Future[Option[IncomingPayment]] = Future {
+    appKit.nodeParams.db.payments.getIncomingPayment(paymentHash)
   }
 
   override def audit(from_opt: Option[Long], to_opt: Option[Long]): Future[AuditResponse] = {
@@ -170,6 +197,24 @@ class EclairImpl(appKit: Kit) extends Eclair {
 
   override def channelStats(): Future[Seq[Stats]] = Future(appKit.nodeParams.db.audit.stats)
 
+  override def allInvoices(from_opt: Option[Long], to_opt: Option[Long]): Future[Seq[PaymentRequest]] = Future {
+    val from = from_opt.getOrElse(0L)
+    val to = to_opt.getOrElse(Long.MaxValue)
+
+    appKit.nodeParams.db.payments.listPaymentRequests(from, to)
+  }
+
+  override def pendingInvoices(from_opt: Option[Long], to_opt: Option[Long]): Future[Seq[PaymentRequest]] = Future {
+    val from = from_opt.getOrElse(0L)
+    val to = to_opt.getOrElse(Long.MaxValue)
+
+    appKit.nodeParams.db.payments.listPendingPaymentRequests(from, to)
+  }
+
+  override def getInvoice(paymentHash: ByteVector32): Future[Option[PaymentRequest]] = Future {
+    appKit.nodeParams.db.payments.getPaymentRequest(paymentHash)
+  }
+
   /**
     * Sends a request to a channel and expects a response
     *
@@ -187,10 +232,10 @@ class EclairImpl(appKit: Kit) extends Eclair {
 
   override def getInfoResponse: Future[GetInfoResponse] = Future.successful(
     GetInfoResponse(nodeId = appKit.nodeParams.nodeId,
-    alias = appKit.nodeParams.alias,
-    chainHash = appKit.nodeParams.chainHash,
-    blockHeight = Globals.blockCount.intValue(),
-    publicAddresses = appKit.nodeParams.publicAddresses)
+      alias = appKit.nodeParams.alias,
+      chainHash = appKit.nodeParams.chainHash,
+      blockHeight = Globals.blockCount.intValue(),
+      publicAddresses = appKit.nodeParams.publicAddresses)
   )
 
 }

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

@@ -73,7 +73,6 @@ case class NodeParams(keyManager: KeyManager,
                       channelFlags: Byte,
                       watcherType: WatcherType,
                       paymentRequestExpiry: FiniteDuration,
-                      maxPendingPaymentRequests: Int,
                       minFundingSatoshis: Long,
                       routerConf: RouterConf,
                       socksProxy_opt: Option[Socks5ProxyParams]) {
@@ -209,7 +208,6 @@ object NodeParams {
       channelFlags = config.getInt("channel-flags").toByte,
       watcherType = watcherType,
       paymentRequestExpiry = FiniteDuration(config.getDuration("payment-request-expiry").getSeconds, TimeUnit.SECONDS),
-      maxPendingPaymentRequests = config.getInt("max-pending-payment-requests"),
       minFundingSatoshis = config.getLong("min-funding-satoshis"),
       routerConf = RouterConf(
         channelExcludeDuration = FiniteDuration(config.getDuration("router.channel-exclude-duration").getSeconds, TimeUnit.SECONDS),

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

@@ -245,7 +245,7 @@ class Setup(datadir: File,
       authenticator = system.actorOf(SimpleSupervisor.props(Authenticator.props(nodeParams), "authenticator", SupervisorStrategy.Resume))
       switchboard = system.actorOf(SimpleSupervisor.props(Switchboard.props(nodeParams, authenticator, watcher, router, relayer, wallet), "switchboard", SupervisorStrategy.Resume))
       server = system.actorOf(SimpleSupervisor.props(Server.props(nodeParams, authenticator, serverBindingAddress, Some(tcpBound)), "server", SupervisorStrategy.Restart))
-      paymentInitiator = system.actorOf(SimpleSupervisor.props(PaymentInitiator.props(nodeParams.nodeId, router, register), "payment-initiator", SupervisorStrategy.Restart))
+      paymentInitiator = system.actorOf(SimpleSupervisor.props(PaymentInitiator.props(nodeParams, router, register), "payment-initiator", SupervisorStrategy.Restart))
       _ = for (i <- 0 until config.getInt("autoprobe-count")) yield system.actorOf(SimpleSupervisor.props(Autoprobe.props(nodeParams, router, paymentInitiator), s"payment-autoprobe-$i", SupervisorStrategy.Restart))
 
       kit = Kit(

eclair-core/src/main/scala/fr/acinq/eclair/api/ExtraDirectives.scala

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2018 ACINQ SAS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fr.acinq.eclair.api
+
+import akka.http.scaladsl.marshalling.ToResponseMarshaller
+import akka.http.scaladsl.model.{ContentTypes, HttpResponse}
+import akka.http.scaladsl.model.StatusCodes._
+import akka.http.scaladsl.server.{Directives, Route}
+import fr.acinq.eclair.api.JsonSupport._
+import scala.concurrent.{Future}
+import scala.util.{Failure, Success}
+
+trait ExtraDirectives extends Directives {
+
+  // custom directive to fail with HTTP 404 (and JSON response) if the element was not found
+  def completeOrNotFound[T](fut: Future[Option[T]])(implicit marshaller: ToResponseMarshaller[T]): Route = onComplete(fut) {
+    case Success(Some(t)) => complete(t)
+    case Success(None) =>
+      complete(HttpResponse(NotFound).withEntity(ContentTypes.`application/json`, serialization.writePretty(ErrorResponse("Not found"))))
+    case Failure(_) => reject
+  }
+
+}

eclair-core/src/main/scala/fr/acinq/eclair/api/FormParamExtractors.scala

@@ -1,5 +1,23 @@
+/*
+ * Copyright 2018 ACINQ SAS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package fr.acinq.eclair.api
 
+import java.util.UUID
+
 import akka.http.scaladsl.unmarshalling.Unmarshaller
 import fr.acinq.bitcoin.ByteVector32
 import fr.acinq.bitcoin.Crypto.PublicKey
@@ -29,4 +47,8 @@ object FormParamExtractors {
     ShortChannelId(str)
   }
 
+  implicit val javaUUIDUnmarshaller: Unmarshaller[String, UUID] = Unmarshaller.strict { str =>
+    UUID.fromString(str)
+  }
+
 }

eclair-core/src/main/scala/fr/acinq/eclair/api/JsonSerializers.scala

@@ -17,16 +17,15 @@
 package fr.acinq.eclair.api
 
 import java.net.InetSocketAddress
-
-import akka.http.scaladsl.model.MediaType
-import akka.http.scaladsl.model.MediaTypes._
+import java.util.UUID
 import com.google.common.net.HostAndPort
 import de.heikoseeberger.akkahttpjson4s.Json4sSupport
 import de.heikoseeberger.akkahttpjson4s.Json4sSupport.ShouldWritePretty
 import fr.acinq.bitcoin.Crypto.{Point, PrivateKey, PublicKey, Scalar}
 import fr.acinq.bitcoin.{ByteVector32, MilliSatoshi, OutPoint, Transaction}
 import fr.acinq.eclair.channel.State
 import fr.acinq.eclair.crypto.ShaChain
+import fr.acinq.eclair.db.OutgoingPaymentStatus
 import fr.acinq.eclair.payment.PaymentRequest
 import fr.acinq.eclair.router.RouteResponse
 import fr.acinq.eclair.transactions.Direction
@@ -151,9 +150,18 @@ class PaymentRequestSerializer extends CustomSerializer[PaymentRequest](format =
     JField("paymentHash", JString(p.paymentHash.toString())) ::
     JField("expiry", if (p.expiry.isDefined) JLong(p.expiry.get) else JNull) ::
     JField("minFinalCltvExpiry", if (p.minFinalCltvExpiry.isDefined) JLong(p.minFinalCltvExpiry.get) else JNull) ::
+    JField("serialized", JString(PaymentRequest.write(p))) ::
     Nil)
 }))
 
+class JavaUUIDSerializer extends CustomSerializer[UUID](format => ({ null }, {
+  case id: UUID => JString(id.toString)
+}))
+
+class OutgoingPaymentStatusSerializer extends CustomSerializer[OutgoingPaymentStatus.Value](format => ({ null }, {
+  case el: OutgoingPaymentStatus.Value => JString(el.toString)
+}))
+
 object JsonSupport extends Json4sSupport {
 
   implicit val serialization = jackson.Serialization
@@ -182,7 +190,9 @@ object JsonSupport extends Json4sSupport {
     new FailureMessageSerializer +
     new NodeAddressSerializer +
     new DirectionSerializer +
-    new PaymentRequestSerializer
+    new PaymentRequestSerializer +
+    new JavaUUIDSerializer +
+    new OutgoingPaymentStatusSerializer
 
   implicit val shouldWritePretty: ShouldWritePretty = ShouldWritePretty.True
 

eclair-core/src/main/scala/fr/acinq/eclair/api/OldService.scala

@@ -307,7 +307,7 @@ trait OldService extends Logging {
                                 case _ => Future.failed(new IllegalArgumentException("payment identifier must be a payment request or a payment hash"))
                               }
                             }
-                            found <- (paymentHandler ? CheckPayment(ByteVector32.fromValidHex(identifier))).map(found => new JBool(found.asInstanceOf[Boolean]))
+                            found <- Future(appKit.nodeParams.db.payments.getIncomingPayment(ByteVector32.fromValidHex(identifier)).map(_ => JBool(true)).getOrElse(JBool(false)))
                           } yield found)
                           case _ => reject(UnknownParamsRejection(req.id, "[paymentHash] or [paymentRequest]"))
                         }