Store incoming amounts to payments database (#230)

The `StoreIncomingAmount` action is saved in the payments database as 
an `IncomingPayment` object. The payment database has a new method 
to allow insertion of spontaneous payments, such as swap-ins.

We use the channel origin to set the  incoming payment's `receivedWith`
attribute. If channel origin is not defined, the payment origin is a swap-in.

Author: dpad85

src/commonMain/kotlin/fr/acinq/eclair/db/InMemoryPaymentsDb.kt

@@ -31,6 +31,11 @@ class InMemoryPaymentsDb : PaymentsDb {
         }
     }
 
+    override suspend fun addAndReceivePayment(preimage: ByteVector32, origin: IncomingPayment.Origin, amount: MilliSatoshi, receivedWith: IncomingPayment.ReceivedWith, createdAt: Long, receivedAt: Long) {
+        val paymentHash = preimage.sha256()
+        incoming[paymentHash] = IncomingPayment(preimage, origin, IncomingPayment.Received(amount, receivedWith, receivedAt), createdAt)
+    }
+
     override suspend fun listReceivedPayments(count: Int, skip: Int, filters: Set<PaymentTypeFilter>): List<IncomingPayment> =
         incoming.values
             .asSequence()

src/commonMain/kotlin/fr/acinq/eclair/db/PaymentsDb.kt

@@ -29,6 +29,9 @@ interface IncomingPaymentsDb {
      */
     suspend fun receivePayment(paymentHash: ByteVector32, amount: MilliSatoshi, receivedWith: IncomingPayment.ReceivedWith, receivedAt: Long = currentTimestampMillis())
 
+    /** Add and receive a payment. Use this method when receiving a spontaneous payment, for example a swap-in payment. */
+    suspend fun addAndReceivePayment(preimage: ByteVector32, origin: IncomingPayment.Origin, amount: MilliSatoshi, receivedWith: IncomingPayment.ReceivedWith, createdAt: Long = currentTimestampMillis(), receivedAt: Long = currentTimestampMillis())
+
     /** List received payments (with most recent payments first). */
     suspend fun listReceivedPayments(count: Int, skip: Int, filters: Set<PaymentTypeFilter> = setOf()): List<IncomingPayment>
 }
@@ -115,8 +118,8 @@ data class IncomingPayment(val preimage: ByteVector32, val origin: Origin, val r
         /** KeySend payments are spontaneous donations for which we didn't create an invoice. */
         object KeySend : Origin()
 
-        /** Swap-in works by sending an on-chain transaction to a swap server, which will pay us in exchange. */
-        data class SwapIn(val amount: MilliSatoshi, val address: String, val paymentRequest: PaymentRequest?) : Origin()
+        /** Swap-in works by sending an on-chain transaction to a swap server, which will pay us in exchange. We may not know the origin address. */
+        data class SwapIn(val address: String?) : Origin()
 
         fun matchesFilters(filters: Set<PaymentTypeFilter>): Boolean = when (this) {
             is Invoice -> filters.isEmpty() || filters.contains(PaymentTypeFilter.Normal)
@@ -132,7 +135,7 @@ data class IncomingPayment(val preimage: ByteVector32, val origin: Origin, val r
 
         /** Payment was received via existing lightning channels. */
         object LightningPayment : ReceivedWith() {
-            override val fees: MilliSatoshi = 0.msat
+            override val fees: MilliSatoshi = 0.msat // with Lightning, the fee is paid by the sender
         }
 
         /** Payment was received via a new channel opened to us. */

src/commonMain/kotlin/fr/acinq/eclair/io/Peer.kt

@@ -304,7 +304,7 @@ class Peer(
 
     fun openListenerEventSubscription() = listenerEventChannel.openSubscription()
 
-    private suspend fun sendToPeer(msg: LightningMessage) {
+    suspend fun sendToPeer(msg: LightningMessage) {
         val encoded = LightningMessage.encode(msg)
         // Avoids polluting the logs with pongs
         if (msg !is Pong) logger.info { "n:$remoteNodeId sending $msg" }
@@ -367,6 +367,40 @@ class Peer(
                 action is ChannelAction.Storage.StoreHtlcInfos -> {
                     action.htlcs.forEach { db.channels.addHtlcInfo(actualChannelId, it.commitmentNumber, it.paymentHash, it.cltvExpiry) }
                 }
+                action is ChannelAction.Storage.StoreIncomingAmount -> {
+                    logger.info { "storing incoming amount=${action.amount} with origin=${action.origin}" }
+                    when (action.origin) {
+                        null -> {
+                            logger.warning { "n:$remoteNodeId c:$actualChannelId incoming amount with empty origin, store minimal information" }
+                            val fakePreimage = actualChannelId.sha256()
+                            db.payments.addAndReceivePayment(
+                                preimage = fakePreimage,
+                                origin = IncomingPayment.Origin.SwapIn(address = ""),
+                                amount = action.amount,
+                                receivedWith = IncomingPayment.ReceivedWith.NewChannel(fees = 0.msat, channelId = actualChannelId)
+                            )
+                        }
+                        is ChannelOrigin.PayToOpenOrigin -> {
+                            if (db.payments.getIncomingPayment(action.origin.paymentHash) != null) {
+                                db.payments.receivePayment(paymentHash = action.origin.paymentHash, amount = action.amount, receivedWith = IncomingPayment.ReceivedWith.NewChannel(
+                                    fees = action.origin.fee.toMilliSatoshi(),
+                                    channelId = actualChannelId
+                                ))
+                            } else {
+                                logger.warning { "n:$remoteNodeId c:$actualChannelId ignored pay-to-open storage, no payments in db for hash=${action.origin.paymentHash}" }
+                            }
+                        }
+                        is ChannelOrigin.SwapInOrigin -> {
+                            val fakePreimage = actualChannelId.sha256()
+                            db.payments.addAndReceivePayment(
+                                preimage = fakePreimage,
+                                origin = IncomingPayment.Origin.SwapIn(address = action.origin.bitcoinAddress),
+                                amount = action.amount,
+                                receivedWith = IncomingPayment.ReceivedWith.NewChannel(fees = action.origin.fee.toMilliSatoshi(), channelId = actualChannelId)
+                            )
+                        }
+                    }
+                }
                 action is ChannelAction.Storage.GetHtlcInfos -> {
                     val htlcInfos = db.channels.listHtlcInfos(actualChannelId, action.commitmentNumber).map { ChannelAction.Storage.HtlcInfo(actualChannelId, action.commitmentNumber, it.first, it.second) }
                     input.send(WrappedChannelEvent(actualChannelId, ChannelEvent.GetHtlcInfosResponse(action.revokedCommitTxId, htlcInfos)))

src/commonTest/kotlin/fr/acinq/eclair/db/PaymentsDbTestsCommon.kt

@@ -34,6 +34,24 @@ class PaymentsDbTestsCommon : EclairTestSuite() {
         assertEquals(pending.copy(received = IncomingPayment.Received(200_000.msat, IncomingPayment.ReceivedWith.LightningPayment, 110)), received)
     }
 
+    @Test
+    fun `add and receive incoming payments`() = runSuspendTest {
+        val db = InMemoryPaymentsDb()
+        val preimage = randomBytes32()
+        val channelId = randomBytes32()
+        val amount = MilliSatoshi(50_000_000)
+        val origin = IncomingPayment.Origin.SwapIn("1PwLgmRdDjy5GAKWyp8eyAC4SFzWuboLLb")
+        val receivedWith = IncomingPayment.ReceivedWith.NewChannel(fees = MilliSatoshi(1234), channelId = channelId)
+        assertNull(db.getIncomingPayment(randomBytes32()))
+
+        db.addAndReceivePayment(preimage = preimage, origin = origin, amount = amount, receivedWith = receivedWith)
+        val payment = db.getIncomingPayment(Crypto.sha256(preimage).toByteVector32())
+        assertNotNull(payment)
+        assertEquals(origin, payment.origin)
+        assertNotNull(payment.received)
+        assertEquals(receivedWith, payment.received?.receivedWith)
+    }
+
     @Test
     fun `reject duplicate payment hash`() = runSuspendTest {
         val (db, preimage, pr) = createFixture()
@@ -73,7 +91,7 @@ class PaymentsDbTestsCommon : EclairTestSuite() {
 
         val preimage2 = randomBytes32()
         val received2 = createInvoice(preimage2)
-        db.addIncomingPayment(preimage2, IncomingPayment.Origin.SwapIn(150_000.msat, "1PwLgmRdDjy5GAKWyp8eyAC4SFzWuboLLb", received2))
+        db.addIncomingPayment(preimage2, IncomingPayment.Origin.SwapIn("1PwLgmRdDjy5GAKWyp8eyAC4SFzWuboLLb"))
         db.receivePayment(received2.paymentHash, 180_000.msat, IncomingPayment.ReceivedWith.NewChannel(100.msat, channelId = null), 60)
         val payment2 = db.getIncomingPayment(received2.paymentHash)!!
 
@@ -279,7 +297,7 @@ class PaymentsDbTestsCommon : EclairTestSuite() {
 
         val (preimage1, preimage2, preimage3, preimage4) = listOf(randomBytes32(), randomBytes32(), randomBytes32(), randomBytes32())
         val incoming1 = IncomingPayment(preimage1, IncomingPayment.Origin.Invoice(createInvoice(preimage1)), null, createdAt = 20)
-        val incoming2 = IncomingPayment(preimage2, IncomingPayment.Origin.SwapIn(20_000.msat, "1PwLgmRdDjy5GAKWyp8eyAC4SFzWuboLLb", null), null, createdAt = 21)
+        val incoming2 = IncomingPayment(preimage2, IncomingPayment.Origin.SwapIn("1PwLgmRdDjy5GAKWyp8eyAC4SFzWuboLLb"), null, createdAt = 21)
         val incoming3 = IncomingPayment(preimage3, IncomingPayment.Origin.Invoice(createInvoice(preimage3)), null, createdAt = 22)
         val incoming4 = IncomingPayment(preimage4, IncomingPayment.Origin.Invoice(createInvoice(preimage4)), null, createdAt = 23)
         listOf(incoming1, incoming2, incoming3, incoming4).forEach { db.addIncomingPayment(it.preimage, it.origin, it.createdAt) }