feat: expose Wallet::create_single method

Author: thunderbiscuit

bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/CreatingWalletTest.kt

@@ -42,6 +42,16 @@ class CreatingWalletTest {
         )
     }
 
+    // Create a wallet with a single descriptor.
+    @Test
+    fun createWalletWithSingleDescriptor() {
+        Wallet.createSingle(
+            descriptor = BIP86_DESCRIPTOR,
+            network = Network.TESTNET,
+            persister = conn
+        )
+    }
+
     // Create a wallet with a public multipath descriptor.
     @Test
     fun createWalletWithMultipathDescriptor() {

bdk-android/lib/src/androidTest/kotlin/org/bitcoindevkit/WalletTest.kt

@@ -45,4 +45,24 @@ class WalletTest {
             actual = wallet.balance().total.toSat()
         )
     }
+
+    // Single-descriptor wallets return an address on the external keychain even if a change descriptor is not provided
+    // and the wallet.revealNextAddress(KeychainKind.INTERNAL) or wallet.peekAddress(KeychainKind.EXTERNAL, 0u) APIs are
+    // used.
+    @Test
+    fun singleDescriptorWalletCanCreateAddresses() {
+        val wallet: Wallet = Wallet.createSingle(
+            descriptor = BIP84_DESCRIPTOR,
+            network = Network.TESTNET,
+            persister = conn
+        )
+        val address1 = wallet.peekAddress(KeychainKind.EXTERNAL, 0u)
+        val address2 = wallet.peekAddress(KeychainKind.INTERNAL, 0u)
+
+        assertEquals(
+            expected = address1.address,
+            actual = address2.address,
+            "Addresses should be the same"
+        )
+    }
 }

bdk-ffi/src/wallet.rs

@@ -67,6 +67,48 @@ impl Wallet {
         })
     }
 
+    /// Build a new single descriptor `Wallet`.
+    ///
+    /// If you have previously created a wallet, use `Wallet::load` instead.
+    ///
+    /// # Note
+    ///
+    /// Only use this method when creating a wallet designed to be used with a single
+    /// descriptor and keychain. Otherwise the recommended way to construct a new wallet is
+    /// by using `Wallet::new`. It's worth noting that not all features are available
+    /// with single descriptor wallets, for example setting a `change_policy` on `TxBuilder`
+    /// and related methods such as `do_not_spend_change`. This is because all payments are
+    /// received on the external keychain (including change), and without a change keychain
+    /// BDK lacks enough information to distinguish between change and outside payments.
+    ///
+    /// Additionally because this wallet has no internal (change) keychain, all methods that
+    /// require a `KeychainKind` as input, e.g. `reveal_next_address` should only be called
+    /// using the `External` variant. In most cases passing `Internal` is treated as the
+    /// equivalent of `External` but this behavior must not be relied on.
+    #[uniffi::constructor(default(lookahead = 25))]
+    pub fn create_single(
+        descriptor: Arc<Descriptor>,
+        network: Network,
+        persister: Arc<Persister>,
+        lookahead: u32,
+    ) -> Result<Self, CreateWithPersistError> {
+        let descriptor = descriptor.to_string_with_secret();
+        let mut persist_lock = persister.inner.lock().unwrap();
+        let deref = persist_lock.deref_mut();
+
+        let wallet: PersistedWallet<PersistenceType> = BdkWallet::create_single(descriptor)
+            .network(network)
+            .lookahead(lookahead)
+            .create_wallet(deref)
+            .map_err(|e| CreateWithPersistError::Persist {
+                error_message: e.to_string(),
+            })?;
+
+        Ok(Wallet {
+            inner_mutex: Mutex::new(wallet),
+        })
+    }
+
     /// Build a new `Wallet` from a two-path descriptor.
     ///
     /// This function parses a multipath descriptor with exactly 2 paths and creates a wallet using the existing receive and change wallet creation logic.