Merge pull request #136 from synonymdev/native-tx-writes

Native transaction persistence

Author: Jasonvdb

example/App.tsx

@@ -413,11 +413,19 @@ const App = (): ReactElement => {
 					<Button
 						title={'Get claimed payments'}
 						onPress={async (): Promise<void> => {
-							setMessage('Getting all LDK payments...');
+							setMessage('Getting all claimed payments...');
 							const res = await lm.getLdkPaymentsClaimed();
 							setMessage(JSON.stringify(res));
 						}}
 					/>
+					<Button
+						title={'Get sent payments'}
+						onPress={async (): Promise<void> => {
+							setMessage('Getting all sent payments...');
+							const res = await lm.getLdkPaymentsSent();
+							setMessage(JSON.stringify(res));
+						}}
+					/>
 
 					<Button
 						title={'Create invoice'}

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
@@ -111,7 +112,9 @@ enum class LdkCallbackResponses {
 enum class LdkFileNames(val fileName: String) {
     network_graph("network_graph.bin"),
     channel_manager("channel_manager.bin"),
-    scorer("scorer.bin")
+    scorer("scorer.bin"),
+    paymentsClaimed("payments_claimed.json"),
+    paymentsSent("payments_sent.json"),
 }
 
 class LdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
@@ -684,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

@@ -1,7 +1,9 @@
 package com.reactnativeldk.classes
 
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
 import com.reactnativeldk.*
+import org.json.JSONArray
 import org.ldk.batteries.ChannelManagerConstructor
 import org.ldk.structs.Event
 import org.ldk.structs.Option_u64Z
@@ -30,6 +32,10 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
             (paymentClaimable.purpose as? PaymentPurpose.SpontaneousPayment)?.let {
                 body.putHexString("spontaneous_payment_preimage", it.spontaneous_payment)
             }
+            body.putInt("unix_timestamp", (System.currentTimeMillis() / 1000).toInt())
+            body.putString("state", "pending")
+
+            persistPaymentClaimed(body)
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_claimable, body)
         }
 
@@ -39,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)
         }
 
@@ -76,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)
         }
 
@@ -132,6 +160,10 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
             (paymentClaimed.purpose as? PaymentPurpose.SpontaneousPayment)?.let {
                 body.putHexString("spontaneous_payment_preimage", it.spontaneous_payment)
             }
+            body.putInt("unix_timestamp", (System.currentTimeMillis() / 1000).toInt())
+            body.putString("state", "successful")
+
+            persistPaymentClaimed(body)
             return LdkEventEmitter.send(EventTypes.channel_manager_payment_claimed, body)
         }
     }
@@ -159,4 +191,89 @@ class LdkChannelManagerPersister: ChannelManagerConstructor.EventHandler {
             LdkEventEmitter.send(EventTypes.native_log, "Persisted scorer to disk")
         }
     }
+
+    private fun persistPaymentClaimed(payment: WritableMap) {
+        if (LdkModule.accountStoragePath == "") {
+            LdkEventEmitter.send(EventTypes.native_log, "Error. Failed to persist claimed payment to disk (No set storage)")
+            return
+        }
+
+        var payments: Array<HashMap<String, Any>> = arrayOf()
+        var paymentReplaced = false
+
+        try {
+            if (File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsClaimed.fileName).exists()) {
+                val data = File(LdkModule.accountStoragePath + "/" + LdkFileNames.paymentsClaimed.fileName).readBytes()
+                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] = mergeObj(existingPayment, payment.toHashMap())
+                        paymentReplaced = true
+                        continue
+                    }
+
+                    val map = HashMap<String, Any>()
+                    for (key in existingPayment.keys()) {
+                        map[key] = existingPayments.getJSONObject(i).get(key)
+                    }
+
+                    payments = payments.plus(map)
+                }
+            }
+        } catch (e: Exception) {
+            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())
+        }
+
+        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())
+    }
 }