feat(config): add runtime-adjustable wallet sync intervals

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ldk-node"
-version = "0.7.0-rc.6"
+version = "0.7.0-rc.8"
 authors = ["Elias Rohrer <[email protected]>"]
 homepage = "https://lightningdevkit.org/"
 license = "MIT OR Apache-2.0"

Package.swift

@@ -3,8 +3,8 @@
 
 import PackageDescription
 
-let tag = "v0.7.0-rc.6"
-let checksum = "4ea23aedbf918a1c93539168f34e626cbe867c1d5e827b7b7fd0e84225970b91"
+let tag = "v0.7.0-rc.8"
+let checksum = "7ce9e6eb4335f40b5bb4e17e2eb94ab10e41845b41b635e47b7baca66a30b819"
 let url = "https://github.com/synonymdev/ldk-node/releases/download/\(tag)/LDKNodeFFI.xcframework.zip"
 
 let package = Package(

bindings/kotlin/ldk-node-android/gradle.properties

@@ -2,4 +2,4 @@ org.gradle.jvmargs=-Xmx1536m
 android.useAndroidX=true
 android.enableJetifier=true
 kotlin.code.style=official
-libraryVersion=0.7.0-rc.6
+libraryVersion=0.7.0-rc.8

bindings/kotlin/ldk-node-android/lib/src/main/kotlin/org/lightningdevkit/ldknode/ldk_node.android.kt

@@ -1485,6 +1485,12 @@ internal typealias UniffiVTableCallbackInterfaceVssHeaderProviderUniffiByValue =
 
 
 
+
+
+
+
+
+
 
 
 
@@ -2195,6 +2201,10 @@ internal interface UniffiLib : Library {
         `persist`: Byte,
         uniffiCallStatus: UniffiRustCallStatus,
     ): Unit
+    fun uniffi_ldk_node_fn_method_node_current_sync_intervals(
+        `ptr`: Pointer?,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
     fun uniffi_ldk_node_fn_method_node_disconnect(
         `ptr`: Pointer?,
         `nodeId`: RustBufferByValue,
@@ -2351,6 +2361,11 @@ internal interface UniffiLib : Library {
         `channelConfig`: RustBufferByValue,
         uniffiCallStatus: UniffiRustCallStatus,
     ): Unit
+    fun uniffi_ldk_node_fn_method_node_update_sync_intervals(
+        `ptr`: Pointer?,
+        `intervals`: RustBufferByValue,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): Unit
     fun uniffi_ldk_node_fn_method_node_verify_signature(
         `ptr`: Pointer?,
         `msg`: RustBufferByValue,
@@ -2657,6 +2672,9 @@ internal interface UniffiLib : Library {
         `ptr`: Pointer?,
         `request`: RustBufferByValue,
     ): Long
+    fun uniffi_ldk_node_fn_func_battery_saving_sync_intervals(
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
     fun uniffi_ldk_node_fn_func_default_config(
         uniffiCallStatus: UniffiRustCallStatus,
     ): RustBufferByValue
@@ -2881,6 +2899,8 @@ internal interface UniffiLib : Library {
         `handle`: Long,
         uniffiCallStatus: UniffiRustCallStatus,
     ): Unit
+    fun uniffi_ldk_node_checksum_func_battery_saving_sync_intervals(
+    ): Short
     fun uniffi_ldk_node_checksum_func_default_config(
     ): Short
     fun uniffi_ldk_node_checksum_func_derive_node_secret_from_mnemonic(
@@ -3095,6 +3115,8 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_ldk_node_checksum_method_node_connect(
     ): Short
+    fun uniffi_ldk_node_checksum_method_node_current_sync_intervals(
+    ): Short
     fun uniffi_ldk_node_checksum_method_node_disconnect(
     ): Short
     fun uniffi_ldk_node_checksum_method_node_event_handled(
@@ -3159,6 +3181,8 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_ldk_node_checksum_method_node_update_channel_config(
     ): Short
+    fun uniffi_ldk_node_checksum_method_node_update_sync_intervals(
+    ): Short
     fun uniffi_ldk_node_checksum_method_node_verify_signature(
     ): Short
     fun uniffi_ldk_node_checksum_method_node_wait_next_event(
@@ -3274,6 +3298,9 @@ private fun uniffiCheckContractApiVersion(lib: UniffiLib) {
 
 
 private fun uniffiCheckApiChecksums(lib: UniffiLib) {
+    if (lib.uniffi_ldk_node_checksum_func_battery_saving_sync_intervals() != 25473.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_ldk_node_checksum_func_default_config() != 55381.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -3595,6 +3622,9 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_ldk_node_checksum_method_node_connect() != 34120.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_ldk_node_checksum_method_node_current_sync_intervals() != 51918.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_ldk_node_checksum_method_node_disconnect() != 43538.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -3691,6 +3721,9 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_ldk_node_checksum_method_node_update_channel_config() != 37852.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_ldk_node_checksum_method_node_update_sync_intervals() != 42322.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_ldk_node_checksum_method_node_verify_signature() != 20486.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -6844,6 +6877,17 @@ open class Node: Disposable, NodeInterface {
         }
     }
 
+    override fun `currentSyncIntervals`(): RuntimeSyncIntervals {
+        return FfiConverterTypeRuntimeSyncIntervals.lift(callWithPointer {
+            uniffiRustCall { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_node_current_sync_intervals(
+                    it,
+                    uniffiRustCallStatus,
+                )
+            }
+        })
+    }
+
     @Throws(NodeException::class)
     override fun `disconnect`(`nodeId`: PublicKey) {
         callWithPointer {
@@ -7246,6 +7290,19 @@ open class Node: Disposable, NodeInterface {
         }
     }
 
+    @Throws(NodeException::class)
+    override fun `updateSyncIntervals`(`intervals`: RuntimeSyncIntervals) {
+        callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_node_update_sync_intervals(
+                    it,
+                    FfiConverterTypeRuntimeSyncIntervals.lower(`intervals`),
+                    uniffiRustCallStatus,
+                )
+            }
+        }
+    }
+
     override fun `verifySignature`(`msg`: List<kotlin.UByte>, `sig`: kotlin.String, `pkey`: PublicKey): kotlin.Boolean {
         return FfiConverterBoolean.lift(callWithPointer {
             uniffiRustCall { uniffiRustCallStatus ->
@@ -9659,6 +9716,31 @@ object FfiConverterTypeRoutingFees: FfiConverterRustBuffer<RoutingFees> {
 
 
 
+object FfiConverterTypeRuntimeSyncIntervals: FfiConverterRustBuffer<RuntimeSyncIntervals> {
+    override fun read(buf: ByteBuffer): RuntimeSyncIntervals {
+        return RuntimeSyncIntervals(
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+            FfiConverterULong.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: RuntimeSyncIntervals) = (
+            FfiConverterULong.allocationSize(value.`onchainWalletSyncIntervalSecs`) +
+            FfiConverterULong.allocationSize(value.`lightningWalletSyncIntervalSecs`) +
+            FfiConverterULong.allocationSize(value.`feeRateCacheUpdateIntervalSecs`)
+    )
+
+    override fun write(value: RuntimeSyncIntervals, buf: ByteBuffer) {
+        FfiConverterULong.write(value.`onchainWalletSyncIntervalSecs`, buf)
+        FfiConverterULong.write(value.`lightningWalletSyncIntervalSecs`, buf)
+        FfiConverterULong.write(value.`feeRateCacheUpdateIntervalSecs`, buf)
+    }
+}
+
+
+
+
 object FfiConverterTypeSpendableUtxo: FfiConverterRustBuffer<SpendableUtxo> {
     override fun read(buf: ByteBuffer): SpendableUtxo {
         return SpendableUtxo(
@@ -11067,6 +11149,7 @@ object FfiConverterTypeNodeError : FfiConverterRustBuffer<NodeException> {
             60 -> NodeException.NoSpendableOutputs(FfiConverterString.read(buf))
             61 -> NodeException.CoinSelectionFailed(FfiConverterString.read(buf))
             62 -> NodeException.InvalidMnemonic(FfiConverterString.read(buf))
+            63 -> NodeException.BackgroundSyncNotEnabled(FfiConverterString.read(buf))
             else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
         }
     }
@@ -11325,6 +11408,10 @@ object FfiConverterTypeNodeError : FfiConverterRustBuffer<NodeException> {
                 buf.putInt(62)
                 Unit
             }
+            is NodeException.BackgroundSyncNotEnabled -> {
+                buf.putInt(63)
+                Unit
+            }
         }.let { /* this makes the `when` an expression, which ensures it is exhaustive */ }
     }
 }
@@ -13781,6 +13868,14 @@ typealias FfiConverterTypeUserChannelId = FfiConverterString
 
 
 
+fun `batterySavingSyncIntervals`(): RuntimeSyncIntervals {
+    return FfiConverterTypeRuntimeSyncIntervals.lift(uniffiRustCall { uniffiRustCallStatus ->
+        UniffiLib.INSTANCE.uniffi_ldk_node_fn_func_battery_saving_sync_intervals(
+            uniffiRustCallStatus,
+        )
+    })
+}
+
 fun `defaultConfig`(): Config {
     return FfiConverterTypeConfig.lift(uniffiRustCall { uniffiRustCallStatus ->
         UniffiLib.INSTANCE.uniffi_ldk_node_fn_func_default_config(

bindings/kotlin/ldk-node-android/lib/src/main/kotlin/org/lightningdevkit/ldknode/ldk_node.common.kt

@@ -424,6 +424,8 @@ interface NodeInterface {
     @Throws(NodeException::class)
     fun `connect`(`nodeId`: PublicKey, `address`: SocketAddress, `persist`: kotlin.Boolean)
 
+    fun `currentSyncIntervals`(): RuntimeSyncIntervals
+
     @Throws(NodeException::class)
     fun `disconnect`(`nodeId`: PublicKey)
 
@@ -502,6 +504,9 @@ interface NodeInterface {
     @Throws(NodeException::class)
     fun `updateChannelConfig`(`userChannelId`: UserChannelId, `counterpartyNodeId`: PublicKey, `channelConfig`: ChannelConfig)
 
+    @Throws(NodeException::class)
+    fun `updateSyncIntervals`(`intervals`: RuntimeSyncIntervals)
+
     fun `verifySignature`(`msg`: List<kotlin.UByte>, `sig`: kotlin.String, `pkey`: PublicKey): kotlin.Boolean
 
     fun `waitNextEvent`(): Event
@@ -1099,6 +1104,17 @@ data class RoutingFees (
 
 
 
+@kotlinx.serialization.Serializable
+data class RuntimeSyncIntervals (
+    val `onchainWalletSyncIntervalSecs`: kotlin.ULong, 
+    val `lightningWalletSyncIntervalSecs`: kotlin.ULong, 
+    val `feeRateCacheUpdateIntervalSecs`: kotlin.ULong
+) {
+    companion object
+}
+
+
+
 @kotlinx.serialization.Serializable
 data class SpendableUtxo (
     val `outpoint`: OutPoint, 
@@ -1783,6 +1799,8 @@ sealed class NodeException(message: String): kotlin.Exception(message) {
 
     class InvalidMnemonic(message: String) : NodeException(message)
 
+    class BackgroundSyncNotEnabled(message: String) : NodeException(message)
+
 }
 
 

bindings/kotlin/ldk-node-jvm/gradle.properties

@@ -1,3 +1,3 @@
 org.gradle.jvmargs=-Xmx1536m
 kotlin.code.style=official
-libraryVersion=0.7.0-rc.6
+libraryVersion=0.7.0-rc.8

bindings/ldk_node.udl

@@ -1,6 +1,7 @@
 namespace ldk_node {
 	Mnemonic generate_entropy_mnemonic(WordCount? word_count);
 	Config default_config();
+	RuntimeSyncIntervals battery_saving_sync_intervals();
 	[Throws=NodeError]
 	sequence<u8> derive_node_secret_from_mnemonic(string mnemonic, string? passphrase);
 };
@@ -29,6 +30,12 @@ dictionary BackgroundSyncConfig {
 	u64 fee_rate_cache_update_interval_secs;
 };
 
+dictionary RuntimeSyncIntervals {
+	u64 onchain_wallet_sync_interval_secs;
+	u64 lightning_wallet_sync_interval_secs;
+	u64 fee_rate_cache_update_interval_secs;
+};
+
 dictionary EsploraSyncConfig {
 	BackgroundSyncConfig? background_sync_config;
 };
@@ -185,6 +192,9 @@ interface Node {
 	boolean verify_signature([ByRef]sequence<u8> msg, [ByRef]string sig, [ByRef]PublicKey pkey);
 	[Throws=NodeError]
 	bytes export_pathfinding_scores();
+	[Throws=NodeError]
+	void update_sync_intervals(RuntimeSyncIntervals intervals);
+	RuntimeSyncIntervals current_sync_intervals();
 };
 
 [Enum]
@@ -383,6 +393,7 @@ enum NodeError {
     "NoSpendableOutputs",
     "CoinSelectionFailed",
 	"InvalidMnemonic",
+	"BackgroundSyncNotEnabled",
 };
 
 dictionary NodeStatus {