Write pending and confirmed sent payments natively

Author: Jasonvdb

lib/android/src/main/java/com/reactnativeldk/Helpers.kt

@@ -1,5 +1,6 @@
 package com.reactnativeldk
 import com.facebook.react.bridge.*
+import org.json.JSONObject
 import org.ldk.enums.Currency
 import org.ldk.enums.Network
 import org.ldk.structs.*
@@ -381,4 +382,18 @@ fun getNetwork(chain: String): Pair<Network, Currency> {
         "mainnet" -> Pair(Network.LDKNetwork_Bitcoin, Currency.LDKCurrency_Bitcoin)
         else -> Pair(Network.LDKNetwork_Bitcoin, Currency.LDKCurrency_Bitcoin)
     }
+}
+
+fun mergeObj(obj1: JSONObject, obj2: HashMap<String, Any>): HashMap<String, Any> {
+    val newObj = HashMap<String, Any>()
+
+    obj1.keys().forEach { key ->
+        newObj[key] = obj1[key]
+    }
+
+    obj2.keys.forEach { key ->
+        newObj[key] = obj2[key]!!
+    }
+
+    return newObj
 }

lib/android/src/main/java/com/reactnativeldk/LdkModule.kt

@@ -13,6 +13,7 @@ import org.ldk.impl.bindings.get_ldk_version
 import org.ldk.structs.*
 import org.ldk.structs.Result_InvoiceParseOrSemanticErrorZ.Result_InvoiceParseOrSemanticErrorZ_OK
 import org.ldk.structs.Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_OK
+import org.ldk.structs.Result_PaymentIdPaymentErrorZ.Result_PaymentIdPaymentErrorZ_OK
 import java.io.File
 import java.net.InetSocketAddress
 import java.nio.file.Files
@@ -113,6 +114,7 @@ enum class LdkFileNames(val fileName: String) {
     channel_manager("channel_manager.bin"),
     scorer("scorer.bin"),
     paymentsClaimed("payments_claimed.json"),
+    paymentsSent("payments_sent.json"),
 }
 
 class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
@@ -685,6 +687,14 @@ class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
             UtilMethods.pay_zero_value_invoice(invoice, amountSats.toLong() * 1000, Retry.timeout(timeoutSeconds.toLong()), channelManager) else
             UtilMethods.pay_invoice(invoice, Retry.timeout(timeoutSeconds.toLong()), channelManager)
         if (res.is_ok) {
+            channelManagerPersister.persistPaymentSent(hashMapOf(
+                "payment_id" to (res as Result_PaymentIdPaymentErrorZ_OK).res.hexEncodedString(),
+                "payment_hash" to invoice.payment_hash().hexEncodedString(),
+                "amount_sat" to if (isZeroValueInvoice) amountSats.toLong() else ((invoice.amount_milli_satoshis() as Option_u64Z.Some).some.toInt() / 1000),
+                "unix_timestamp" to (System.currentTimeMillis() / 1000).toInt(),
+                "state" to "pending"
+            ))
+
             return handleResolve(promise, LdkCallbackResponses.invoice_payment_success)
         }
 

lib/android/src/main/java/com/reactnativeldk/classes/LdkChannelManagerPersister.kt

@@ -33,7 +33,7 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
                 body.putHexString("spontaneous_payment_preimage", it.spontaneous_payment)
             }
             body.putInt("unix_timestamp", (System.currentTimeMillis() / 1000).toInt())
-            body.putBoolean("confirmed", false)
+            body.putString("state", "pending")
 
             persistPaymentClaimed(body)
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_claimable, body)
@@ -45,6 +45,11 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
             body.putHexString("payment_preimage", paymentSent.payment_preimage)
             body.putHexString("payment_hash", paymentSent.payment_hash)
             body.putInt("fee_paid_sat", (paymentSent.fee_paid_msat as Option_u64Z.Some).some.toInt() / 1000)
+            body.putInt("unix_timestamp", (System.currentTimeMillis() / 1000).toInt())
+            body.putString("state", "successful")
+
+            persistPaymentSent(body.toHashMap())
+
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_sent, body)
         }
 
@@ -82,13 +87,30 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
 //            paymentPathFailed.path.iterator().forEach { path.pushMap(it.asJson) }
 //            body.putArray("path_hops", path)
 
+            if (paymentPathFailed.payment_id != null) {
+                persistPaymentSent(hashMapOf(
+                    "payment_id" to paymentPathFailed.payment_id!!.hexEncodedString(),
+                    "payment_hash" to paymentPathFailed.payment_hash.hexEncodedString(),
+                    "unix_timestamp" to (System.currentTimeMillis() / 1000).toInt(),
+                    "state" to if (paymentPathFailed.payment_failed_permanently) "failed" else "pending"
+                ))
+            }
+
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_path_failed, body)
         }
 
         (event as? Event.PaymentFailed)?.let { paymentFailed ->
             val body = Arguments.createMap()
             body.putHexString("payment_id", paymentFailed.payment_id)
             body.putHexString("payment_hash", paymentFailed.payment_hash)
+
+            persistPaymentSent(hashMapOf(
+                "payment_id" to paymentFailed.payment_id!!.hexEncodedString(),
+                "payment_hash" to paymentFailed.payment_hash.hexEncodedString(),
+                "unix_timestamp" to (System.currentTimeMillis() / 1000).toInt(),
+                "state" to "failed"
+            ))
+
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_failed, body)
         }
 
@@ -139,7 +161,7 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
                 body.putHexString("spontaneous_payment_preimage", it.spontaneous_payment)
             }
             body.putInt("unix_timestamp", (System.currentTimeMillis() / 1000).toInt())
-            body.putBoolean("confirmed", true)
+            body.putString("state", "successful")
 
             persistPaymentClaimed(body)
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_claimed, body)
@@ -182,14 +204,12 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
         try {
             if (File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsClaimed.fileName).exists()) {
                 val data = File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsClaimed.fileName).readBytes()
-                println(String(data))
                 val existingPayments = JSONArray(String(data))
                 for (i in 0 until existingPayments.length()) {
                     val existingPayment = existingPayments.getJSONObject(i)
-
                     //Replace entry if payment hash exists (Confirmed payment replacing pending)
                     if (existingPayment.getString("payment_hash") == payment.getString("payment_hash")) {
-                        payments[i] = payment.toHashMap()
+                        payments[i] = mergeObj(existingPayment, payment.toHashMap())
                         paymentReplaced = true
                         continue
                     }
@@ -203,17 +223,57 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
                 }
             }
         } catch (e: Exception) {
-            LdkEventEmitter.send(EventTypes.native_log, "Error could not read exisitng claimed payments")
+            LdkEventEmitter.send(EventTypes.native_log, "Error could not read existing claimed payments")
         }
 
         //No existing payment found, append as new payment
         if (!paymentReplaced) {
             payments = payments.plus(payment.toHashMap())
         }
 
-        println("New content")
-        payments.iterator().forEach { println(it) }
-
         File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsClaimed.fileName).writeText(JSONArray(payments).toString())
     }
+
+    fun persistPaymentSent(payment: HashMap<String, Any>) {
+        if (LdkModule.accountStoragePath == "") {
+            LdkEventEmitter.send(EventTypes.native_log, "Error. Failed to persist sent payment to disk (No set storage)")
+            return
+        }
+
+        var payments: Array<HashMap<String, Any>> = arrayOf()
+        var paymentReplaced = false
+
+        try {
+            if (File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsSent.fileName).exists()) {
+                val data = File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsSent.fileName).readBytes()
+                val existingPayments = JSONArray(String(data))
+                for (i in 0 until existingPayments.length()) {
+                    val existingPayment = existingPayments.getJSONObject(i)
+                    //Replace entry if payment ID exists (Confirmed payment replacing pending)
+                    if (existingPayment.getString("payment_id") == payment["payment_id"]) {
+                        var merged = mergeObj(existingPayment, payment)
+                        payments = payments.plus(merged)
+                        paymentReplaced = true
+                        continue
+                    }
+
+                    val map = HashMap<String, Any>()
+                    for (key in existingPayment.keys()) {
+                        map[key] = existingPayment.get(key)
+                    }
+
+                    payments = payments.plus(map)
+                }
+            }
+        } catch (e: Exception) {
+            LdkEventEmitter.send(EventTypes.native_log, "Error could not read existing sent payments")
+        }
+
+        //No existing payment found, append as new payment
+        if (!paymentReplaced) {
+            payments = payments.plus(payment)
+        }
+
+        File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsSent.fileName).writeText(JSONArray(payments).toString())
+    }
 }

lib/ios/Classes/LdkChannelManagerPersister.swift

@@ -52,7 +52,7 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
                 "payment_secret": Data(paymentSecret ?? []).hexEncodedString(),
                 "spontaneous_payment_preimage": Data(spontaneousPayment ?? []).hexEncodedString(),
                 "unix_timestamp": Int(Date().timeIntervalSince1970),
-                "confirmed": false
+                "state": "pending"
             ]
 
             LdkEventEmitter.shared.send(
@@ -68,15 +68,22 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
                 return handleEventError(event)
             }
 
+            let body: [String: Encodable] = [
+                "payment_id": Data(paymentSent.getPaymentId()).hexEncodedString(),
+                "payment_preimage": Data(paymentSent.getPaymentPreimage()).hexEncodedString(),
+                "payment_hash": Data(paymentSent.getPaymentHash()).hexEncodedString(),
+                "fee_paid_sat": (paymentSent.getFeePaidMsat() ?? 0) / 1000,
+                "unix_timestamp": Int(Date().timeIntervalSince1970),
+                "state": "successful"
+            ]
+            
             LdkEventEmitter.shared.send(
                 withEvent: .channel_manager_payment_sent,
-                body: [
-                    "payment_id": Data(paymentSent.getPaymentId()).hexEncodedString(),
-                    "payment_preimage": Data(paymentSent.getPaymentPreimage()).hexEncodedString(),
-                    "payment_hash": Data(paymentSent.getPaymentHash()).hexEncodedString(),
-                    "fee_paid_sat": (paymentSent.getFeePaidMsat() ?? 0) / 1000,
-                ]
+                body: body
             )
+            
+            //Save to disk for tx history
+            persistPaymentSent(body)
             return
         case .OpenChannelRequest:
             //Use if we ever manually accept inbound channels. Setting in initConfig.
@@ -99,11 +106,14 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
                 return handleEventError(event)
             }
 
+            let paymentId = Data(paymentPathSuccessful.getPaymentId()).hexEncodedString()
+            let paymentHash = Data(paymentPathSuccessful.getPaymentHash()).hexEncodedString()
+            
             LdkEventEmitter.shared.send(
                 withEvent: .channel_manager_payment_path_successful,
                 body: [
-                    "payment_id": Data(paymentPathSuccessful.getPaymentId()).hexEncodedString(),
-                    "payment_hash": Data(paymentPathSuccessful.getPaymentHash()).hexEncodedString(),
+                    "payment_id": paymentId,
+                    "payment_hash": paymentHash,
                     "path_hops": paymentPathSuccessful.getPath().getHops().map { $0.asJson },
                 ]
             )
@@ -113,27 +123,53 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
                 return handleEventError(event)
             }
 
+            let paymentId = Data(paymentPathFailed.getPaymentId()).hexEncodedString()
+            let paymentHash = Data(paymentPathFailed.getPaymentHash()).hexEncodedString()
+             
             LdkEventEmitter.shared.send(
                 withEvent: .channel_manager_payment_path_failed,
                 body: [
-                    "payment_id": Data(paymentPathFailed.getPaymentId()).hexEncodedString(),
-                    "payment_hash": Data(paymentPathFailed.getPaymentHash()).hexEncodedString(),
+                    "payment_id": paymentId,
+                    "payment_hash": paymentHash,
                     "payment_failed_permanently": paymentPathFailed.getPaymentFailedPermanently(),
                     "short_channel_id": String(paymentPathFailed.getShortChannelId() ?? 0),
                     "path_hops": paymentPathFailed.getPath().getHops().map { $0.asJson }
                 ]
             )
+            
+            persistPaymentSent(
+                [
+                    "payment_id": paymentId,
+                    "payment_hash": paymentHash,
+                    "unix_timestamp": Int(Date().timeIntervalSince1970),
+                    "state":  paymentPathFailed.getPaymentFailedPermanently() ? "failed" : "pending"
+                ]
+            )
             return
         case .PaymentFailed:
             guard let paymentFailed = event.getValueAsPaymentFailed() else {
                 return handleEventError(event)
             }
 
+            let paymentId = Data(paymentFailed.getPaymentId()).hexEncodedString()
+            let paymentHash = Data(paymentFailed.getPaymentHash()).hexEncodedString()
+            
             LdkEventEmitter.shared.send(
                 withEvent: .channel_manager_payment_failed,
                 body: [
-                    "payment_id": Data(paymentFailed.getPaymentId()).hexEncodedString(),
-                    "payment_hash": Data(paymentFailed.getPaymentHash()).hexEncodedString(),
+                    "payment_id": paymentId,
+                    "payment_hash": paymentHash,
+                ]
+            )
+            
+            //MARK: Mark as failed
+            
+            persistPaymentSent(
+                [
+                    "payment_id": paymentId,
+                    "payment_hash": paymentHash,
+                    "unix_timestamp": Int(Date().timeIntervalSince1970),
+                    "state":  "failed"
                 ]
             )
             return
@@ -208,7 +244,7 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
                 "payment_secret": Data(paymentSecret ?? []).hexEncodedString(),
                 "spontaneous_payment_preimage": Data(spontaneousPayment ?? []).hexEncodedString(),
                 "unix_timestamp": Int(Date().timeIntervalSince1970),
-                "confirmed": true
+                "state": "successful"
             ]
 
             LdkEventEmitter.shared.send(
@@ -271,7 +307,9 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
             return Result_NoneErrorZ.initWithErr(e: .Other)
         }
     }
-    
+
+    /// Saves claiming/claimed payment to disk. If payment hash exists already then the payment values are merged into the existing entry as an update
+    /// - Parameter payment: payment obj
     private func persistPaymentClaimed(_ payment: [String: Any]) {
         guard let claimedPaymentsStorage = Ldk.accountStoragePath?.appendingPathComponent(LdkFileNames.paymentsClaimed.rawValue) else {
             LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error. Failed to persist claimed payment to disk (No set storage)")
@@ -296,7 +334,7 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
             for (index, existingPayment) in payments.enumerated() {
                 if let existingPaymentHash = existingPayment["payment_hash"] as? String, let newPaymentHash = payment["payment_hash"] as? String {
                     if existingPaymentHash == newPaymentHash {
-                        payments[index] = payment
+                        payments[index] = mergeObj(payments[index], payment) //Merges update into orginal entry
                         paymentReplaced = true
                     }
                 }
@@ -321,4 +359,56 @@ class LdkChannelManagerPersister: Persister, ExtendedChannelManagerPersister {
             LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error writing payment claimed to file: \(error)")
         }
     }
+    
+    /// Saves sending/sent payment to disk. If payment ID exists already then the payment values are merged into the existing entry as an update
+    /// - Parameter payment: payment obj
+    func persistPaymentSent(_ payment: [String: Any]) {
+        guard let sentPaymentsStorage = Ldk.accountStoragePath?.appendingPathComponent(LdkFileNames.paymentsSent.rawValue) else {
+            LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error. Failed to persist sent payment to disk (No set storage)")
+            return
+        }
+        
+        var payments: [[String: Any]] = []
+        
+        do {
+            if FileManager.default.fileExists(atPath: sentPaymentsStorage.path) {
+                let data = try Data(contentsOf: URL(fileURLWithPath: sentPaymentsStorage.path), options: .mappedIfSafe)
+                
+                if let existingContent = try JSONSerialization.jsonObject(with: data, options: []) as? [[String: Any]] {
+                    payments = existingContent
+                } else {
+                    LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error could not read existing sent payments")
+                }
+            }
+                        
+            //Replace entry if payment hash exists (Confirmed payment replacing pending)
+            var paymentReplaced = false
+            for (index, existingPayment) in payments.enumerated() {
+                if let existingPaymentId = existingPayment["payment_id"] as? String, let newPaymentId = payment["payment_id"] as? String {
+                    if existingPaymentId == newPaymentId {
+                        payments[index] = mergeObj(payments[index], payment) //Merges update into orginal entry
+                        paymentReplaced = true
+                    }
+                }
+            }
+            
+            //No existing payment found, append as new payment
+            if !paymentReplaced {
+                payments.append(payment)
+            }
+            
+            guard let jsonData = try? JSONSerialization.data(withJSONObject: payments, options: []) else {
+                LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error could not serialize sent payments")
+                return
+            }
+            
+            guard let jsonString = String(data: jsonData, encoding: .utf8) else {
+                return
+            }
+            
+            try jsonString.write(to: sentPaymentsStorage, atomically: true, encoding: .utf8)
+        } catch {
+            LdkEventEmitter.shared.send(withEvent: .native_log, body: "Error writing payment sent to file: \(error)")
+        }
+    }
 }