Emit storage actions at channel opening/closing (#219)

pm47 · t-bast · web-flow · commit 7dfe46aa30a4 · 2021-03-17T14:53:04.000+01:00
The goal is to use those use those events to populate the payments and make it seem like:
- Phoenix receives money when an incoming channel with `pushMsat &gt; 0` is created
- Phoenix sends money when a channel is closed.

For channel creation, we emit the action only when we know for sure that the channel will be created (that is, when we move to `WaitForFundingConfirmed`).

Co-authored-by: Bastien Teinturier &lt;31281497+t-bast@users.noreply.github.com&gt;
diff --git a/src/commonMain/kotlin/fr/acinq/eclair/channel/Channel.kt b/src/commonMain/kotlin/fr/acinq/eclair/channel/Channel.kt
@@ -41,7 +41,8 @@ sealed class ChannelEvent {
         val localParams: LocalParams,
         val remoteInit: Init,
         val channelFlags: Byte,
-        val channelVersion: ChannelVersion
+        val channelVersion: ChannelVersion,
+        val channelOrigin: ChannelOrigin? = null
     ) : ChannelEvent() {
         init {
             require(channelVersion.hasStaticRemotekey) { "channel version $channelVersion is invalid (static_remote_key is not set)" }
@@ -91,6 +92,8 @@ sealed class ChannelAction {
         data class HtlcInfo(val channelId: ByteVector32, val commitmentNumber: Long, val paymentHash: ByteVector32, val cltvExpiry: CltvExpiry)
         data class StoreHtlcInfos(val htlcs: List<HtlcInfo>) : Storage()
         data class GetHtlcInfos(val revokedCommitTxId: ByteVector32, val commitmentNumber: Long) : Storage()
+        data class StoreIncomingAmount(val amount: MilliSatoshi, val origin: ChannelOrigin?) : Storage()
+        data class StoreOutgoingAmount(val amount: MilliSatoshi) : Storage()
     }
 
     data class ProcessIncomingHtlc(val add: UpdateAddHtlc) : ChannelAction()
@@ -152,7 +155,20 @@ sealed class ChannelState {
     fun process(event: ChannelEvent): Pair<ChannelState, List<ChannelAction>> {
         return try {
             val (newState, actions) = processInternal(event)
-            Pair(newState, newState.updateActions(actions))
+            val actions1 = when {
+                this is WaitForFundingCreated && newState is WaitForFundingConfirmed -> {
+                    actions + ChannelAction.Storage.StoreIncomingAmount(pushAmount, channelOrigin)
+                }
+                // we only want to fire the PaymentSent event when we transition to Closing for the first time
+                this is WaitForInit && newState is Closing -> actions
+                this is Closing && newState is Closing -> actions
+                this is ChannelStateWithCommitments && newState is Closing -> {
+                    actions + ChannelAction.Storage.StoreOutgoingAmount(this.commitments.localCommit.spec.toLocal)
+                }
+                else -> actions
+            }
+            val actions2 = newState.updateActions(actions1)
+            Pair(newState, actions2)
         } catch (t: Throwable) {
             handleLocalError(event, t)
         }
@@ -174,6 +190,7 @@ sealed class ChannelState {
                 it is ChannelAction.Message.Send && it.message is RevokeAndAck -> it.copy(message = it.message.copy(channelData = Serialization.encrypt(privateKey.value, this)))
                 it is ChannelAction.Message.Send && it.message is ClosingSigned -> it.copy(message = it.message.copy(channelData = Serialization.encrypt(privateKey.value, this)))
                 else -> it
+
             }
         }
         else -> actions
@@ -544,10 +561,10 @@ data class WaitForInit(override val staticParams: StaticParams, override val cur
                     // In order to allow TLV extensions and keep backwards-compatibility, we include an empty upfront_shutdown_script.
                     // See https://github.com/lightningnetwork/lightning-rfc/pull/714.
                     tlvStream = TlvStream(
-                        if (event.channelVersion.isSet(ChannelVersion.ZERO_RESERVE_BIT)) {
-                            listOf(ChannelTlv.UpfrontShutdownScript(ByteVector.empty), ChannelTlv.ChannelVersionTlv(event.channelVersion))
-                        } else {
-                            listOf(ChannelTlv.UpfrontShutdownScript(ByteVector.empty))
+                        buildList {
+                            add(ChannelTlv.UpfrontShutdownScript(ByteVector.empty))
+                            if (event.channelVersion.isSet(ChannelVersion.ZERO_RESERVE_BIT)) add(ChannelTlv.ChannelVersionTlv(event.channelVersion))
+                            if (event.channelOrigin != null) add(ChannelTlv.ChannelOriginTlv(event.channelOrigin))
                         }
                     )
                 )
@@ -1108,6 +1125,7 @@ data class WaitForOpenChannel(
                                 return Pair(Aborted(staticParams, currentTip, currentOnChainFeerates), listOf(ChannelAction.Message.Send(Error(temporaryChannelId, err.value.message))))
                             }
                         }
+                        val channelOrigin = event.message.tlvStream.records.filterIsInstance<ChannelTlv.ChannelOriginTlv>().firstOrNull()?.channelOrigin
 
                         val fundingPubkey = keyManager.fundingPublicKey(localParams.fundingKeyPath).publicKey
                         val channelKeyPath = keyManager.channelKeyPath(localParams, channelVersion)
@@ -1160,6 +1178,7 @@ data class WaitForOpenChannel(
                             event.message.firstPerCommitmentPoint,
                             event.message.channelFlags,
                             channelVersion,
+                            channelOrigin,
                             accept
                         )
                         Pair(nextState, listOf(ChannelAction.Message.Send(accept)))
@@ -1198,6 +1217,7 @@ data class WaitForFundingCreated(
     val remoteFirstPerCommitmentPoint: PublicKey,
     val channelFlags: Byte,
     val channelVersion: ChannelVersion,
+    val channelOrigin: ChannelOrigin?,
     val lastSent: AcceptChannel
 ) : ChannelState() {
     override fun processInternal(event: ChannelEvent): Pair<ChannelState, List<ChannelAction>> {
@@ -1271,7 +1291,16 @@ data class WaitForFundingCreated(
                                         logger.info { "c:$channelId will wait for $fundingMinDepth confirmations" }
                                         val watchSpent = WatchSpent(channelId, commitInput.outPoint.txid, commitInput.outPoint.index.toInt(), commitments.commitInput.txOut.publicKeyScript, BITCOIN_FUNDING_SPENT)
                                         val watchConfirmed = WatchConfirmed(channelId, commitInput.outPoint.txid, commitments.commitInput.txOut.publicKeyScript, fundingMinDepth.toLong(), BITCOIN_FUNDING_DEPTHOK)
-                                        val nextState = WaitForFundingConfirmed(staticParams, currentTip, currentOnChainFeerates, commitments, null, currentBlockHeight.toLong(), null, Either.Right(fundingSigned))
+                                        val nextState = WaitForFundingConfirmed(
+                                            staticParams,
+                                            currentTip,
+                                            currentOnChainFeerates,
+                                            commitments,
+                                            null,
+                                            currentBlockHeight.toLong(),
+                                            null,
+                                            Either.Right(fundingSigned)
+                                        )
                                         val actions = listOf(
                                             ChannelAction.Blockchain.SendWatch(watchSpent),
                                             ChannelAction.Blockchain.SendWatch(watchConfirmed),
diff --git a/src/commonMain/kotlin/fr/acinq/eclair/channel/ChannelTypes.kt b/src/commonMain/kotlin/fr/acinq/eclair/channel/ChannelTypes.kt
@@ -417,6 +417,7 @@ data class ClosingTxProposed(val unsignedTx: Transaction, val localClosingSigned
 /** This gives the reason for creating a new channel */
 @Serializable
 sealed class ChannelOrigin {
-    data class PayToOpenOrigin(val paymentHash: ByteVector32) : ChannelOrigin()
-    data class SwapInOrigin(val bitcoinAddress: String) : ChannelOrigin()
+    abstract val fee: Satoshi
+    data class PayToOpenOrigin(val paymentHash: ByteVector32, override val fee: Satoshi) : ChannelOrigin()
+    data class SwapInOrigin(val bitcoinAddress: String, override val fee: Satoshi) : ChannelOrigin()
 }
diff --git a/src/commonMain/kotlin/fr/acinq/eclair/wire/ChannelTlv.kt b/src/commonMain/kotlin/fr/acinq/eclair/wire/ChannelTlv.kt
@@ -2,6 +2,7 @@ package fr.acinq.eclair.wire
 
 import fr.acinq.bitcoin.ByteVector
 import fr.acinq.bitcoin.ByteVector32
+import fr.acinq.bitcoin.Satoshi
 import fr.acinq.bitcoin.io.Input
 import fr.acinq.bitcoin.io.Output
 import fr.acinq.eclair.channel.ChannelOrigin
@@ -74,14 +75,20 @@ sealed class ChannelTlv : Tlv {
         }
 
         companion object : TlvValueReader<ChannelOriginTlv> {
-            const val tag: Long = 0x47000003
+            const val tag: Long = 0x47000005
 
             override fun read(input: Input): ChannelOriginTlv {
                 val origin = when (LightningCodecs.u16(input)) {
-                    1 -> ChannelOrigin.PayToOpenOrigin(ByteVector32(LightningCodecs.bytes(input, 32)))
+                    1 -> ChannelOrigin.PayToOpenOrigin(
+                        paymentHash = ByteVector32(LightningCodecs.bytes(input, 32)),
+                        fee = Satoshi(LightningCodecs.u64(input))
+                    )
                     2 -> {
                         val len = LightningCodecs.bigSize(input)
-                        ChannelOrigin.SwapInOrigin(LightningCodecs.bytes(input, len).decodeToString())
+                        ChannelOrigin.SwapInOrigin(
+                            bitcoinAddress = LightningCodecs.bytes(input, len).decodeToString(),
+                            fee = Satoshi(LightningCodecs.u64(input))
+                        )
                     }
                     else -> TODO("Unsupported channel origin discriminator")
                 }
diff --git a/src/commonMain/kotlin/fr/acinq/eclair/wire/LightningMessages.kt b/src/commonMain/kotlin/fr/acinq/eclair/wire/LightningMessages.kt
@@ -1235,4 +1235,4 @@ data class SwapInConfirmed(
             )
         }
     }
-}
+}
diff --git a/src/commonTest/kotlin/fr/acinq/eclair/channel/TestsHelper.kt b/src/commonTest/kotlin/fr/acinq/eclair/channel/TestsHelper.kt
@@ -66,7 +66,8 @@ object TestsHelper {
         channelVersion: ChannelVersion = ChannelVersion.STANDARD,
         currentHeight: Int = TestConstants.defaultBlockHeight,
         fundingAmount: Satoshi = TestConstants.fundingAmount,
-        pushMsat: MilliSatoshi = TestConstants.pushMsat
+        pushMsat: MilliSatoshi = TestConstants.pushMsat,
+        channelOrigin: ChannelOrigin? = null
     ): Triple<WaitForAcceptChannel, WaitForOpenChannel, OpenChannel> {
         var alice: ChannelState = WaitForInit(
             StaticParams(TestConstants.Alice.nodeParams, TestConstants.Bob.keyManager.nodeId),
@@ -96,7 +97,8 @@ object TestsHelper {
                 aliceChannelParams,
                 bobInit,
                 channelFlags,
-                channelVersion
+                channelVersion,
+                channelOrigin
             )
         )
         alice = ra.first
diff --git a/src/commonTest/kotlin/fr/acinq/eclair/channel/states/ClosingTestsCommon.kt b/src/commonTest/kotlin/fr/acinq/eclair/channel/states/ClosingTestsCommon.kt
@@ -1546,7 +1546,8 @@ class ClosingTestsCommon : EclairTestSuite() {
             val alice1 = run {
                 val (alice1, actions1) = alice.process(ChannelEvent.ExecuteCommand(CMD_FORCECLOSE))
                 assertTrue(alice1 is Closing)
-                assertEquals(6, actions1.size)
+                assertEquals(7, actions1.size)
+                assertTrue(actions1.contains(ChannelAction.Storage.StoreOutgoingAmount(alice1.commitments.localCommit.spec.toLocal)))
 
                 val error = actions1.hasOutgoingMessage<Error>()
                 assertEquals(ForcedLocalCommit(alice.channelId).message, error.toAscii())
@@ -1572,7 +1573,8 @@ class ClosingTestsCommon : EclairTestSuite() {
             val bob1 = run {
                 val (bob1, actions1) = bob.process(ChannelEvent.ExecuteCommand(CMD_FORCECLOSE))
                 assertTrue(bob1 is Closing)
-                assertEquals(6, actions1.size)
+                assertEquals(7, actions1.size)
+                assertTrue(actions1.contains(ChannelAction.Storage.StoreOutgoingAmount(bob1.commitments.localCommit.spec.toLocal)))
 
                 val error = actions1.hasOutgoingMessage<Error>()
                 assertEquals(ForcedLocalCommit(alice.channelId).message, error.toAscii())
diff --git a/src/commonTest/kotlin/fr/acinq/eclair/channel/states/WaitForFundingCreatedTestsCommon.kt b/src/commonTest/kotlin/fr/acinq/eclair/channel/states/WaitForFundingCreatedTestsCommon.kt
@@ -29,6 +29,19 @@ class WaitForFundingCreatedTestsCommon : EclairTestSuite() {
         actions1.has<ChannelAction.Storage.StoreState>()
     }
 
+    @Test
+    fun `recv FundingCreated (with channel origin)`() {
+        val (_, bob, fundingCreated) = init(ChannelVersion.STANDARD, TestConstants.fundingAmount, TestConstants.pushMsat, ChannelOrigin.PayToOpenOrigin(ByteVector32.One, 42.sat))
+        val (bob1, actions1) = bob.process(ChannelEvent.MessageReceived(fundingCreated))
+        assertTrue { bob1 is WaitForFundingConfirmed }
+        actions1.findOutgoingMessage<FundingSigned>()
+        actions1.hasWatch<WatchSpent>()
+        actions1.hasWatch<WatchConfirmed>()
+        actions1.has<ChannelAction.ChannelId.IdSwitch>()
+        actions1.has<ChannelAction.Storage.StoreState>()
+        actions1.contains(ChannelAction.Storage.StoreIncomingAmount(TestConstants.pushMsat, ChannelOrigin.PayToOpenOrigin(ByteVector32.One, 42.sat)))
+    }
+
     @Test
     fun `recv FundingCreated (funder can't pay fees)`() {
         val (_, bob, fundingCreated) = init(ChannelVersion.STANDARD, 1_000_100.sat, 1_000_000.sat.toMilliSatoshi())
@@ -64,8 +77,8 @@ class WaitForFundingCreatedTestsCommon : EclairTestSuite() {
     }
 
     companion object {
-        fun init(channelVersion: ChannelVersion, fundingAmount: Satoshi, pushAmount: MilliSatoshi): Triple<WaitForFundingSigned, WaitForFundingCreated, FundingCreated> {
-            val (a, b, open) = TestsHelper.init(channelVersion, 0, fundingAmount, pushAmount)
+        fun init(channelVersion: ChannelVersion, fundingAmount: Satoshi, pushAmount: MilliSatoshi, channelOrigin: ChannelOrigin? = null): Triple<WaitForFundingSigned, WaitForFundingCreated, FundingCreated> {
+            val (a, b, open) = TestsHelper.init(channelVersion, 0, fundingAmount, pushAmount, channelOrigin)
             val (b1, actions) = b.process(ChannelEvent.MessageReceived(open))
             val accept = actions.findOutgoingMessage<AcceptChannel>()
             val (a1, actions2) = a.process(ChannelEvent.MessageReceived(accept))
diff --git a/src/commonTest/kotlin/fr/acinq/eclair/wire/OpenTlvTestsCommon.kt b/src/commonTest/kotlin/fr/acinq/eclair/wire/OpenTlvTestsCommon.kt
@@ -5,7 +5,7 @@ import fr.acinq.eclair.channel.ChannelOrigin
 import fr.acinq.eclair.channel.ChannelVersion
 import fr.acinq.eclair.crypto.assertArrayEquals
 import fr.acinq.eclair.tests.utils.EclairTestSuite
-import fr.acinq.eclair.utils.toByteVector
+import fr.acinq.eclair.utils.sat
 import fr.acinq.secp256k1.Hex
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -39,8 +39,14 @@ class OpenTlvTestsCommon : EclairTestSuite() {
     @Test
     fun `channel origin TLV`() {
         val testCases = listOf(
-            Pair(ChannelOrigin.PayToOpenOrigin(ByteVector32.fromValidHex("187bf923f7f11ef732b73c417eb5a57cd4667b20a6f130ff505cd7ad3ab87281")), Hex.decode("fe47000003 22 0001 187bf923f7f11ef732b73c417eb5a57cd4667b20a6f130ff505cd7ad3ab87281")),
-            Pair(ChannelOrigin.SwapInOrigin("3AuM8hSkXBetjdHxWthRFiH6hYhqF2Prjr"), Hex.decode("fe47000003 25 0002 223341754d3868536b584265746a644878577468524669483668596871463250726a72")),
+            Pair(
+                ChannelOrigin.PayToOpenOrigin(ByteVector32.fromValidHex("187bf923f7f11ef732b73c417eb5a57cd4667b20a6f130ff505cd7ad3ab87281"), 1234.sat),
+                Hex.decode("fe47000005 2a 0001 187bf923f7f11ef732b73c417eb5a57cd4667b20a6f130ff505cd7ad3ab87281 00000000000004d2")
+            ),
+            Pair(
+                ChannelOrigin.SwapInOrigin("3AuM8hSkXBetjdHxWthRFiH6hYhqF2Prjr", 420.sat),
+                Hex.decode("fe47000005 2d 0002 223341754d3868536b584265746a644878577468524669483668596871463250726a72 00000000000001a4")
+            )
         )
 
         @Suppress("UNCHECKED_CAST")

Original file line number	Diff line number	Diff line change
`@@ -1235,4 +1235,4 @@ data class SwapInConfirmed(`
`1235`	`1235`	`)`
`1236`	`1236`	`}`
`1237`	`1237`	`}`
`1238`		`-}`
	`1238`	`+}`