Merge branch 'wasm_wollet_builder'

Author: RCasatta

lwk_wasm/src/lib.rs

@@ -52,6 +52,7 @@ mod update;
 mod websocket;
 
 mod wollet;
+mod wollet_builder;
 #[cfg(feature = "simplicity")]
 mod xonly_public_key;
 mod xpub;
@@ -133,6 +134,7 @@ pub use update::Update;
 pub use websocket::WebSocketSerial;
 
 pub use wollet::Wollet;
+pub use wollet_builder::WolletBuilder;
 #[cfg(feature = "simplicity")]
 pub use xonly_public_key::XOnlyPublicKey;
 pub use xpub::Xpub;

lwk_wasm/src/wollet.rs

@@ -14,6 +14,12 @@ pub struct Wollet {
     inner: lwk_wollet::Wollet,
 }
 
+impl From<lwk_wollet::Wollet> for Wollet {
+    fn from(inner: lwk_wollet::Wollet) -> Self {
+        Self { inner }
+    }
+}
+
 impl AsRef<lwk_wollet::Wollet> for Wollet {
     fn as_ref(&self) -> &lwk_wollet::Wollet {
         &self.inner
@@ -35,18 +41,6 @@ impl Wollet {
         Ok(Self { inner })
     }
 
-    /// Experimental: create a "utxo only" `Wollet`
-    #[wasm_bindgen(js_name = "newUtxoOnly")]
-    pub fn new_utxo_only(
-        network: &Network,
-        descriptor: &WolletDescriptor,
-    ) -> Result<Wollet, Error> {
-        let inner = lwk_wollet::WolletBuilder::new(network.into(), descriptor.into())
-            .utxo_only(true)
-            .build()?;
-        Ok(Self { inner })
-    }
-
     /// Get a wallet address with the correspondong derivation index
     ///
     /// If Some return the address at the given index,

lwk_wasm/src/wollet_builder.rs

@@ -0,0 +1,81 @@
+use std::sync::Arc;
+
+use wasm_bindgen::prelude::*;
+
+use crate::{Error, JsStorage, JsStoreLink, Network, Wollet, WolletDescriptor};
+
+/// A builder for constructing [`Wollet`] instances.
+#[wasm_bindgen]
+pub struct WolletBuilder {
+    inner: lwk_wollet::WolletBuilder,
+}
+
+impl From<lwk_wollet::WolletBuilder> for WolletBuilder {
+    fn from(value: lwk_wollet::WolletBuilder) -> Self {
+        Self { inner: value }
+    }
+}
+
+#[wasm_bindgen]
+impl WolletBuilder {
+    /// Create a builder for a watch-only wallet.
+    #[wasm_bindgen(constructor)]
+    pub fn new(network: &Network, descriptor: &WolletDescriptor) -> Self {
+        lwk_wollet::WolletBuilder::new(network.into(), descriptor.into()).into()
+    }
+
+    /// Set the threshold used to merge persisted updates during build.
+    ///
+    /// `None` disables merging (default behavior).
+    #[wasm_bindgen(js_name = withMergeThreshold)]
+    pub fn with_merge_threshold(self, merge_threshold: Option<u32>) -> Self {
+        self.inner
+            .with_merge_threshold(merge_threshold.map(|t| t as usize))
+            .into()
+    }
+
+    /// Experimental: set the wallet as "utxo only".
+    #[wasm_bindgen(js_name = utxoOnly)]
+    pub fn utxo_only(self, utxo_only: bool) -> Self {
+        self.inner.utxo_only(utxo_only).into()
+    }
+
+    /// Persist wallet updates in the given JavaScript storage object.
+    ///
+    /// The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
+    #[wasm_bindgen(js_name = withStore)]
+    pub fn with_store(self, storage: JsStorage) -> Self {
+        self.inner
+            .with_store(Arc::new(JsStoreLink::new(storage)))
+            .into()
+    }
+
+    /// Build the wallet from this builder.
+    pub fn build(self) -> Result<Wollet, Error> {
+        Ok(self.inner.build()?.into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_builder() {
+        let mnemonic = crate::Mnemonic::new(
+            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+        )
+        .unwrap();
+        let network = Network::regtest_default();
+        let signer = crate::Signer::new(&mnemonic, &network).unwrap();
+        let descriptor = signer.wpkh_slip77_descriptor().unwrap();
+
+        let wollet = WolletBuilder::new(&network, &descriptor)
+            .with_merge_threshold(Some(2))
+            .utxo_only(true)
+            .build()
+            .unwrap();
+
+        assert_eq!(wollet.address(Some(0)).unwrap().index(), 0);
+    }
+}

lwk_wasm/tests/node/list_transactions.js

@@ -39,7 +39,7 @@ async function runListTransactionsTest() {
 
         // Fetch transactions using waterfalls and utxos only
         const client_utxo_only = new lwk.EsploraClient(network, "https://waterfalls.liquidwebwallet.org/liquidtestnet/api", true, 4, true);
-        const wollet_utxo_only = lwk.Wollet.newUtxoOnly(network, desc);
+        const wollet_utxo_only = new lwk.WolletBuilder(network, desc).utxoOnly(true).build();
         console.log("Starting UTXO-only full scan...");
         const update_utxo_only = await client_utxo_only.fullScan(wollet_utxo_only);
         if (update_utxo_only) {

lwk_wasm/tests/node/store.js

@@ -0,0 +1,64 @@
+const assert = require('assert');
+const fs = require('fs');
+const lwk = require('lwk_node');
+
+function createStorage() {
+    const store = new Map();
+    return {
+        get(key) {
+            return store.get(key) || null;
+        },
+        put(key, value) {
+            const valueCopy = value ? new Uint8Array(value) : null;
+            store.set(key, valueCopy);
+        },
+        remove(key) {
+            store.delete(key);
+        },
+        _data: store
+    };
+}
+
+function runWolletBuilderStoreTest() {
+    const descriptorString = fs
+        .readFileSync(`${__dirname}/../../test_data/update_with_mnemonic/descriptor.txt`, 'utf8')
+        .trim();
+    const encryptedUpdate = fs
+        .readFileSync(
+            `${__dirname}/../../test_data/update_with_mnemonic/update_serialized_encrypted.txt`,
+            'utf8'
+        )
+        .trim();
+
+    const network = lwk.Network.testnet();
+    const descriptor = new lwk.WolletDescriptor(descriptorString);
+    const update = lwk.Update.deserializeDecryptedBase64(encryptedUpdate, descriptor);
+    const jsStorage = createStorage();
+
+    const wollet = new lwk.WolletBuilder(network, descriptor)
+        .withStore(jsStorage)
+        .build();
+    wollet.applyUpdate(update);
+
+    assert(jsStorage._data.has('000000000000'));
+
+    const expectedAddress = wollet.address(0).address().toString();
+    const expectedTransactions = wollet.transactions().length;
+    const expectedBalance = JSON.stringify(wollet.balance().toJSON());
+
+    const restored = new lwk.WolletBuilder(network, descriptor)
+        .withStore(jsStorage)
+        .build();
+
+    assert.strictEqual(restored.address(0).address().toString(), expectedAddress);
+    assert.strictEqual(1, expectedTransactions);
+    assert.strictEqual(restored.transactions().length, expectedTransactions);
+    assert.strictEqual(JSON.stringify(restored.balance().toJSON()), expectedBalance);
+}
+
+if (require.main === module) {
+    runWolletBuilderStoreTest();
+    console.log("wollet_builder.js: all tests passed");
+}
+
+module.exports = { runWolletBuilderStoreTest };