feat: Add receive address index APIs

CHANGELOG.md

@@ -1,4 +1,4 @@
-# 0.7.0-rc.37 (Synonym Fork)
+# 0.7.0-rc.38 (Synonym Fork)
 
 ## Bug Fixes
 
@@ -58,6 +58,12 @@
 
 ## Synonym Fork Additions
 
+- Added `AddressInfo` (`index`, `address`, `keychain`) and `KeychainKind`.
+- Added `OnchainPayment` methods `new_address_info`, `new_address_info_for_type`,
+  `address_info_for_type_at_index`, `address_infos_for_type`, and
+  `reveal_receive_addresses_to`. Address peek APIs support external receive and
+  internal change keychains without advancing wallet cursors. Batch address peek
+  requests are capped at 10,000 addresses per call.
 - Added pre-flight probe correlation: `Event::ProbeSuccessful` and `Event::ProbeFailed` (from LDK
   probe lifecycle), plus `ProbeHandle` (`payment_id`, synthetic `payment_hash`) values returned
   for probes actually dispatched by `Bolt11Payment::send_probes`, `send_probes_using_amount`, and

Cargo.toml

@@ -4,7 +4,7 @@ exclude = ["bindings/uniffi-bindgen"]
 
 [package]
 name = "ldk-node"
-version = "0.7.0-rc.37"
+version = "0.7.0-rc.38"
 authors = ["Elias Rohrer <dev@tnull.de>"]
 homepage = "https://lightningdevkit.org/"
 license = "MIT OR Apache-2.0"

Package.swift

@@ -3,8 +3,8 @@
 
 import PackageDescription
 
-let tag = "v0.7.0-rc.37"
-let checksum = "31ca289fb94221bf1a0077532a868d1e19912f19760735697023066b1160eea7"
+let tag = "v0.7.0-rc.38"
+let checksum = "9b4e5427af6f534df17514da643b33a60df96ebf1a1993b8d1ee734a953c2fe4"
 let url = "https://github.com/synonymdev/ldk-node/releases/download/\(tag)/LDKNodeFFI.xcframework.zip"
 
 let package = Package(

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

@@ -3,4 +3,4 @@ android.useAndroidX=true
 android.enableJetifier=true
 kotlin.code.style=official
 group=com.synonym
-version=0.7.0-rc.37
+version=0.7.0-rc.38

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

@@ -1511,6 +1511,16 @@ internal typealias UniffiVTableCallbackInterfaceVssHeaderProviderUniffiByValue =
 
 
 
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -2551,6 +2561,21 @@ internal interface UniffiLib : Library {
         `destinationAddress`: RustBufferByValue,
         uniffiCallStatus: UniffiRustCallStatus,
     ): RustBufferByValue
+    fun uniffi_ldk_node_fn_method_onchainpayment_address_info_for_type_at_index(
+        `ptr`: Pointer?,
+        `addressType`: RustBufferByValue,
+        `keychain`: RustBufferByValue,
+        `index`: Int,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
+    fun uniffi_ldk_node_fn_method_onchainpayment_address_infos_for_type(
+        `ptr`: Pointer?,
+        `addressType`: RustBufferByValue,
+        `keychain`: RustBufferByValue,
+        `startIndex`: Int,
+        `count`: Int,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
     fun uniffi_ldk_node_fn_method_onchainpayment_bump_fee_by_rbf(
         `ptr`: Pointer?,
         `txid`: RustBufferByValue,
@@ -2591,6 +2616,21 @@ internal interface UniffiLib : Library {
         `addressType`: RustBufferByValue,
         uniffiCallStatus: UniffiRustCallStatus,
     ): RustBufferByValue
+    fun uniffi_ldk_node_fn_method_onchainpayment_new_address_info(
+        `ptr`: Pointer?,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
+    fun uniffi_ldk_node_fn_method_onchainpayment_new_address_info_for_type(
+        `ptr`: Pointer?,
+        `addressType`: RustBufferByValue,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): RustBufferByValue
+    fun uniffi_ldk_node_fn_method_onchainpayment_reveal_receive_addresses_to(
+        `ptr`: Pointer?,
+        `addressType`: RustBufferByValue,
+        `index`: Int,
+        uniffiCallStatus: UniffiRustCallStatus,
+    ): Unit
     fun uniffi_ldk_node_fn_method_onchainpayment_select_utxos_with_algorithm(
         `ptr`: Pointer?,
         `targetAmountSats`: Long,
@@ -3324,6 +3364,10 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_accelerate_by_cpfp(
     ): Short
+    fun uniffi_ldk_node_checksum_method_onchainpayment_address_info_for_type_at_index(
+    ): Short
+    fun uniffi_ldk_node_checksum_method_onchainpayment_address_infos_for_type(
+    ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_bump_fee_by_rbf(
     ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_calculate_cpfp_fee_rate(
@@ -3338,6 +3382,12 @@ internal interface UniffiLib : Library {
     ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_new_address_for_type(
     ): Short
+    fun uniffi_ldk_node_checksum_method_onchainpayment_new_address_info(
+    ): Short
+    fun uniffi_ldk_node_checksum_method_onchainpayment_new_address_info_for_type(
+    ): Short
+    fun uniffi_ldk_node_checksum_method_onchainpayment_reveal_receive_addresses_to(
+    ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_select_utxos_with_algorithm(
     ): Short
     fun uniffi_ldk_node_checksum_method_onchainpayment_send_all_to_address(
@@ -3914,6 +3964,12 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_ldk_node_checksum_method_onchainpayment_accelerate_by_cpfp() != 31954.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_ldk_node_checksum_method_onchainpayment_address_info_for_type_at_index() != 42692.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_ldk_node_checksum_method_onchainpayment_address_infos_for_type() != 3701.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_ldk_node_checksum_method_onchainpayment_bump_fee_by_rbf() != 53877.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -3935,6 +3991,15 @@ private fun uniffiCheckApiChecksums(lib: UniffiLib) {
     if (lib.uniffi_ldk_node_checksum_method_onchainpayment_new_address_for_type() != 9083.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if (lib.uniffi_ldk_node_checksum_method_onchainpayment_new_address_info() != 9889.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_ldk_node_checksum_method_onchainpayment_new_address_info_for_type() != 62171.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if (lib.uniffi_ldk_node_checksum_method_onchainpayment_reveal_receive_addresses_to() != 44189.toShort()) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if (lib.uniffi_ldk_node_checksum_method_onchainpayment_select_utxos_with_algorithm() != 14084.toShort()) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -8060,6 +8125,37 @@ open class OnchainPayment: Disposable, OnchainPaymentInterface {
         })
     }
 
+    @Throws(NodeException::class)
+    override fun `addressInfoForTypeAtIndex`(`addressType`: AddressType, `keychain`: KeychainKind, `index`: kotlin.UInt): AddressInfo {
+        return FfiConverterTypeAddressInfo.lift(callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_onchainpayment_address_info_for_type_at_index(
+                    it,
+                    FfiConverterTypeAddressType.lower(`addressType`),
+                    FfiConverterTypeKeychainKind.lower(`keychain`),
+                    FfiConverterUInt.lower(`index`),
+                    uniffiRustCallStatus,
+                )
+            }
+        })
+    }
+
+    @Throws(NodeException::class)
+    override fun `addressInfosForType`(`addressType`: AddressType, `keychain`: KeychainKind, `startIndex`: kotlin.UInt, `count`: kotlin.UInt): List<AddressInfo> {
+        return FfiConverterSequenceTypeAddressInfo.lift(callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_onchainpayment_address_infos_for_type(
+                    it,
+                    FfiConverterTypeAddressType.lower(`addressType`),
+                    FfiConverterTypeKeychainKind.lower(`keychain`),
+                    FfiConverterUInt.lower(`startIndex`),
+                    FfiConverterUInt.lower(`count`),
+                    uniffiRustCallStatus,
+                )
+            }
+        })
+    }
+
     @Throws(NodeException::class)
     override fun `bumpFeeByRbf`(`txid`: Txid, `feeRate`: FeeRate): Txid {
         return FfiConverterTypeTxid.lift(callWithPointer {
@@ -8156,6 +8252,45 @@ open class OnchainPayment: Disposable, OnchainPaymentInterface {
         })
     }
 
+    @Throws(NodeException::class)
+    override fun `newAddressInfo`(): AddressInfo {
+        return FfiConverterTypeAddressInfo.lift(callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_onchainpayment_new_address_info(
+                    it,
+                    uniffiRustCallStatus,
+                )
+            }
+        })
+    }
+
+    @Throws(NodeException::class)
+    override fun `newAddressInfoForType`(`addressType`: AddressType): AddressInfo {
+        return FfiConverterTypeAddressInfo.lift(callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_onchainpayment_new_address_info_for_type(
+                    it,
+                    FfiConverterTypeAddressType.lower(`addressType`),
+                    uniffiRustCallStatus,
+                )
+            }
+        })
+    }
+
+    @Throws(NodeException::class)
+    override fun `revealReceiveAddressesTo`(`addressType`: AddressType, `index`: kotlin.UInt) {
+        callWithPointer {
+            uniffiRustCallWithError(NodeExceptionErrorHandler) { uniffiRustCallStatus ->
+                UniffiLib.INSTANCE.uniffi_ldk_node_fn_method_onchainpayment_reveal_receive_addresses_to(
+                    it,
+                    FfiConverterTypeAddressType.lower(`addressType`),
+                    FfiConverterUInt.lower(`index`),
+                    uniffiRustCallStatus,
+                )
+            }
+        }
+    }
+
     @Throws(NodeException::class)
     override fun `selectUtxosWithAlgorithm`(`targetAmountSats`: kotlin.ULong, `feeRate`: FeeRate?, `algorithm`: CoinSelectionAlgorithm, `utxos`: List<SpendableUtxo>?): List<SpendableUtxo> {
         return FfiConverterSequenceTypeSpendableUtxo.lift(callWithPointer {
@@ -9047,6 +9182,31 @@ object FfiConverterTypeVssHeaderProvider: FfiConverter<VssHeaderProvider, Pointe
 
 
 
+object FfiConverterTypeAddressInfo: FfiConverterRustBuffer<AddressInfo> {
+    override fun read(buf: ByteBuffer): AddressInfo {
+        return AddressInfo(
+            FfiConverterUInt.read(buf),
+            FfiConverterTypeAddress.read(buf),
+            FfiConverterTypeKeychainKind.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: AddressInfo) = (
+            FfiConverterUInt.allocationSize(value.`index`) +
+            FfiConverterTypeAddress.allocationSize(value.`address`) +
+            FfiConverterTypeKeychainKind.allocationSize(value.`keychain`)
+    )
+
+    override fun write(value: AddressInfo, buf: ByteBuffer) {
+        FfiConverterUInt.write(value.`index`, buf)
+        FfiConverterTypeAddress.write(value.`address`, buf)
+        FfiConverterTypeKeychainKind.write(value.`keychain`, buf)
+    }
+}
+
+
+
+
 object FfiConverterTypeAddressTypeBalance: FfiConverterRustBuffer<AddressTypeBalance> {
     override fun read(buf: ByteBuffer): AddressTypeBalance {
         return AddressTypeBalance(
@@ -11214,6 +11374,24 @@ object FfiConverterTypeEvent : FfiConverterRustBuffer<Event>{
 
 
 
+object FfiConverterTypeKeychainKind: FfiConverterRustBuffer<KeychainKind> {
+    override fun read(buf: ByteBuffer) = try {
+        KeychainKind.entries[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: KeychainKind) = 4UL
+
+    override fun write(value: KeychainKind, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
 object FfiConverterTypeLSPS1PaymentState: FfiConverterRustBuffer<Lsps1PaymentState> {
     override fun read(buf: ByteBuffer) = try {
         Lsps1PaymentState.entries[buf.getInt() - 1]
@@ -13732,6 +13910,31 @@ object FfiConverterSequenceString: FfiConverterRustBuffer<List<kotlin.String>> {
 
 
 
+object FfiConverterSequenceTypeAddressInfo: FfiConverterRustBuffer<List<AddressInfo>> {
+    override fun read(buf: ByteBuffer): List<AddressInfo> {
+        val len = buf.getInt()
+        return List<AddressInfo>(len) {
+            FfiConverterTypeAddressInfo.read(buf)
+        }
+    }
+
+    override fun allocationSize(value: List<AddressInfo>): ULong {
+        val sizeForLength = 4UL
+        val sizeForItems = value.sumOf { FfiConverterTypeAddressInfo.allocationSize(it) }
+        return sizeForLength + sizeForItems
+    }
+
+    override fun write(value: List<AddressInfo>, buf: ByteBuffer) {
+        buf.putInt(value.size)
+        value.iterator().forEach {
+            FfiConverterTypeAddressInfo.write(it, buf)
+        }
+    }
+}
+
+
+
+
 object FfiConverterSequenceTypeChannelDetails: FfiConverterRustBuffer<List<ChannelDetails>> {
     override fun read(buf: ByteBuffer): List<ChannelDetails> {
         val len = buf.getInt()