lwk_node 0.11.0 → 0.12.0

package/lwk_wasm.js

@@ -207,18 +207,18 @@ function debugString(val) {
     return className;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_4.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
 }
 
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -228,6 +228,24 @@ function passArrayJsValueToWasm0(array, malloc) {
     WASM_VECTOR_LEN = array.length;
     return ptr;
 }
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * @returns {Promise<HIDDevice>}
  */
@@ -252,38 +270,20 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
-function __wbg_adapter_36(arg0, arg1, arg2) {
-    wasm.closure451_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_34(arg0, arg1, arg2) {
+    wasm.closure696_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_43(arg0, arg1, arg2) {
-    wasm.closure1348_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_41(arg0, arg1, arg2) {
+    wasm.closure1367_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_526(arg0, arg1, arg2, arg3) {
-    wasm.closure2120_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_543(arg0, arg1, arg2, arg3) {
+    wasm.closure2127_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -312,7 +312,7 @@ const AddressFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_address_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`elements::Address`]
+ * An Elements (Liquid) address
  */
 class Address {
 
@@ -338,7 +338,7 @@ class Address {
     /**
      * Creates an `Address`
      *
-     * If you know the network, you can use [`Address::parse()`] to validate that the network is consistent.
+     * If you know the network, you can use `parse()` to validate that the network is consistent.
      * @param {string} s
      */
     constructor(s) {
@@ -369,6 +369,7 @@ class Address {
         return Address.__wrap(ret[0]);
     }
     /**
+     * Return the script pubkey of the address.
      * @returns {Script}
      */
     scriptPubkey() {
@@ -376,6 +377,7 @@ class Address {
         return Script.__wrap(ret);
     }
     /**
+     * Return true if the address is blinded, in other words, if it has a blinding key.
      * @returns {boolean}
      */
     isBlinded() {
@@ -383,6 +385,7 @@ class Address {
         return ret !== 0;
     }
     /**
+     * Return true if the address is for mainnet.
      * @returns {boolean}
      */
     isMainnet() {
@@ -390,6 +393,7 @@ class Address {
         return ret !== 0;
     }
     /**
+     * Return the unconfidential address, in other words, the address without the blinding key.
      * @returns {Address}
      */
     toUnconfidential() {
@@ -397,6 +401,8 @@ class Address {
         return Address.__wrap(ret);
     }
     /**
+     * Return the string representation of the address.
+     * This representation can be used to recreate the address via `new()`
      * @returns {string}
      */
     toString() {
@@ -469,7 +475,9 @@ const AddressResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_addressresult_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::AddressResult`]
+ * Value returned from asking an address to the wallet.
+ * Containing the confidential address and its
+ * derivation index (the last element in the derivation path)
  */
 class AddressResult {
 
@@ -493,6 +501,7 @@ class AddressResult {
         wasm.__wbg_addressresult_free(ptr, 0);
     }
     /**
+     * Return the address.
      * @returns {Address}
      */
     address() {
@@ -500,6 +509,7 @@ class AddressResult {
         return Address.__wrap(ret);
     }
     /**
+     * Return the derivation index of the address.
      * @returns {number}
      */
     index() {
@@ -513,7 +523,26 @@ const Amp0Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_amp0_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::amp0::Amp0`]
+ * Context for actions related to an AMP0 (sub)account
+ *
+ * <div class="warning">
+ * <b>WARNING:</b>
+ *
+ * AMP0 is based on a legacy system, and some things do not fit precisely the way LWK allows to do
+ * things.
+ *
+ * Callers must be careful with the following:
+ * * <b>Addresses: </b>
+ *   to get addresses use [`Amp0::address()`]. This ensures
+ *   that all addresses used are correctly monitored by the AMP0 server.
+ * * <b>Syncing: </b>
+ *   to sync the AMP0 [`crate::Wollet`], use [`Amp0::last_index()`] and [`crate::clients::blocking::BlockchainBackend::full_scan_to_index()`]. This ensures that all utxos are synced, even if there are gaps between higher than the GAP LIMIT.
+ *
+ * <i>
+ * Failing to do the above might lead to inconsistent states, where funds are not shown or they
+ * cannot be spent!
+ * </i>
+ * </div>
  */
 class Amp0 {
 
@@ -546,14 +575,13 @@ class Amp0 {
      */
     static newWithNetwork(network, username, password, amp_id) {
         _assertClass(network, Network);
-        var ptr0 = network.__destroy_into_raw();
-        const ptr1 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr2 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.amp0_newWithNetwork(ptr0, ptr1, len1, ptr2, len2, ptr3, len3);
+        const ret = wasm.amp0_newWithNetwork(network.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
         return ret;
     }
     /**
@@ -563,14 +591,14 @@ class Amp0 {
      * @param {string} amp_id
      * @returns {Promise<Amp0>}
      */
-    static netTestnet(username, password, amp_id) {
+    static newTestnet(username, password, amp_id) {
         const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.amp0_netTestnet(ptr0, len0, ptr1, len1, ptr2, len2);
+        const ret = wasm.amp0_newTestnet(ptr0, len0, ptr1, len1, ptr2, len2);
         return ret;
     }
     /**
@@ -651,11 +679,168 @@ class Amp0 {
 }
 module.exports.Amp0 = Amp0;
 
+const Amp0ConnectedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp0connected_free(ptr >>> 0, 1));
+/**
+ * Session connecting to AMP0
+ */
+class Amp0Connected {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp0Connected.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp0ConnectedFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp0ConnectedFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp0connected_free(ptr, 0);
+    }
+    /**
+     * Connect and register to AMP0
+     * @param {Network} network
+     * @param {Amp0SignerData} signer_data
+     */
+    constructor(network, signer_data) {
+        _assertClass(network, Network);
+        _assertClass(signer_data, Amp0SignerData);
+        const ret = wasm.amp0connected_new(network.__wbg_ptr, signer_data.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Obtain a login challenge
+     *
+     * This must be signed with [`amp0_sign_challenge()`].
+     * @returns {Promise<string>}
+     */
+    get_challenge() {
+        const ret = wasm.amp0connected_get_challenge(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Log in
+     *
+     * `sig` must be obtained from [`amp0_sign_challenge()`] called with the value returned
+     * by [`Amp0Connected::get_challenge()`]
+     * @param {string} sig
+     * @returns {Promise<Amp0LoggedIn>}
+     */
+    login(sig) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(sig, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0connected_login(ptr, ptr0, len0);
+        return ret;
+    }
+}
+module.exports.Amp0Connected = Amp0Connected;
+
+const Amp0LoggedInFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp0loggedin_free(ptr >>> 0, 1));
+/**
+ * Session logged in AMP0
+ */
+class Amp0LoggedIn {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp0LoggedIn.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp0LoggedInFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp0LoggedInFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp0loggedin_free(ptr, 0);
+    }
+    /**
+     * List of AMP IDs.
+     * @returns {string[]}
+     */
+    get_amp_ids() {
+        const ret = wasm.amp0loggedin_get_amp_ids(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get the next account for AMP0 account creation
+     *
+     * This must be given to [`amp0_account_xpub()`] to obtain the xpub to pass to
+     * [`Amp0LoggedIn::create_amp0_account()`]
+     * @returns {number}
+     */
+    next_account() {
+        const ret = wasm.amp0loggedin_next_account(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a new AMP0 account
+     *
+     * `account_xpub` must be obtained from [`amp0_account_xpub()`] called with the value obtained from
+     * [`Amp0LoggedIn::next_account()`]
+     * @param {number} pointer
+     * @param {string} account_xpub
+     * @returns {Promise<string>}
+     */
+    create_amp0_account(pointer, account_xpub) {
+        const ptr0 = passStringToWasm0(account_xpub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0loggedin_create_amp0_account(this.__wbg_ptr, pointer, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Create a new Watch-Only entry for this wallet
+     * @param {string} username
+     * @param {string} password
+     * @returns {Promise<void>}
+     */
+    create_watch_only(username, password) {
+        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0loggedin_create_watch_only(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+}
+module.exports.Amp0LoggedIn = Amp0LoggedIn;
+
 const Amp0PsetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_amp0pset_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::amp0::Amp0Pset`]
+ * A PSET to use with AMP0
+ *
+ * When asking AMP0 to cosign, the caller must pass some extra data that does not belong to the
+ * PSET. This struct holds and manage the necessary data.
+ *
+ * If you're not dealing with AMP0, do not use this struct.
  */
 class Amp0Pset {
 
@@ -717,11 +902,39 @@ class Amp0Pset {
 }
 module.exports.Amp0Pset = Amp0Pset;
 
+const Amp0SignerDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp0signerdata_free(ptr >>> 0, 1));
+
+class Amp0SignerData {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp0SignerData.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp0SignerDataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp0SignerDataFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp0signerdata_free(ptr, 0);
+    }
+}
+module.exports.Amp0SignerData = Amp0SignerData;
+
 const Amp2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_amp2_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::amp2::Amp2`]
+ * Context for actions interacting with Asset Management Platform version 2
  */
 class Amp2 {
 
@@ -745,26 +958,29 @@ class Amp2 {
         wasm.__wbg_amp2_free(ptr, 0);
     }
     /**
+     * Create a new AMP2 client with the default url and server key for the testnet network.
      * @returns {Amp2}
      */
-    static new_testnet() {
-        const ret = wasm.amp2_new_testnet();
+    static newTestnet() {
+        const ret = wasm.amp2_newTestnet();
         return Amp2.__wrap(ret);
     }
     /**
+     * Get an AMP2 wallet descriptor from the keyorigin xpub string obtained from a signer
      * @param {string} keyorigin_xpub
      * @returns {Amp2Descriptor}
      */
-    descriptor_from_str(keyorigin_xpub) {
+    descriptorFromStr(keyorigin_xpub) {
         const ptr0 = passStringToWasm0(keyorigin_xpub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.amp2_descriptor_from_str(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.amp2_descriptorFromStr(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return Amp2Descriptor.__wrap(ret[0]);
     }
     /**
+     * Register an AMP2 wallet with the AMP2 server
      * @param {Amp2Descriptor} desc
      * @returns {Promise<string>}
      */
@@ -774,6 +990,7 @@ class Amp2 {
         return ret;
     }
     /**
+     * Ask the AMP2 server to cosign a PSET
      * @param {Pset} pset
      * @returns {Promise<Pset>}
      */
@@ -789,7 +1006,7 @@ const Amp2DescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_amp2descriptor_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::amp2::Amp2Descriptor`]
+ * An Asset Management Platform version 2 descriptor
  */
 class Amp2Descriptor {
 
@@ -813,6 +1030,7 @@ class Amp2Descriptor {
         wasm.__wbg_amp2descriptor_free(ptr, 0);
     }
     /**
+     * Return the descriptor as a `WolletDescriptor`
      * @returns {WolletDescriptor}
      */
     descriptor() {
@@ -820,6 +1038,7 @@ class Amp2Descriptor {
         return WolletDescriptor.__wrap(ret);
     }
     /**
+     * Return the string representation of the descriptor.
      * @returns {string}
      */
     toString() {
@@ -841,7 +1060,7 @@ const AssetAmountFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetamount_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::AssetAmount`]
+ * An asset identifier and an amount in satoshi units
  */
 class AssetAmount {
 
@@ -885,7 +1104,7 @@ const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetid_free(ptr >>> 0, 1));
 /**
- * A valid asset identifier. wrapper of [`elements::AssetId`]
+ * A valid asset identifier.
  *
  * 32 bytes encoded as hex string.
  */
@@ -926,6 +1145,8 @@ class AssetId {
         return this;
     }
     /**
+     * Return the string representation of the asset identifier (64 hex characters).
+     * This representation can be used to recreate the asset identifier via `new()`
      * @returns {string}
      */
     toString() {
@@ -947,7 +1168,7 @@ const AssetIdsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetids_free(ptr >>> 0, 1));
 /**
- * A collection of asset identifiers. wrapper of [`Vec<elements::AssetId>`]
+ * An ordered collection of asset identifiers.
  */
 class AssetIds {
 
@@ -971,6 +1192,7 @@ class AssetIds {
         wasm.__wbg_assetids_free(ptr, 0);
     }
     /**
+     * Return an empty list of asset identifiers.
      * @returns {AssetIds}
      */
     static empty() {
@@ -981,6 +1203,7 @@ class AssetIds {
         return AssetIds.__wrap(ret[0]);
     }
     /**
+     * Return the string representation of this list of asset identifiers.
      * @returns {string}
      */
     toString() {
@@ -1001,7 +1224,11 @@ module.exports.AssetIds = AssetIds;
 const AssetMetaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetmeta_free(ptr >>> 0, 1));
-
+/**
+ * Data related to an asset in the registry:
+ * - contract: the contract of the asset
+ * - tx: the issuance transaction of the asset
+ */
 class AssetMeta {
 
     static __wrap(ptr) {
@@ -1024,6 +1251,7 @@ class AssetMeta {
         wasm.__wbg_assetmeta_free(ptr, 0);
     }
     /**
+     * Return the contract of the asset.
      * @returns {Contract}
      */
     contract() {
@@ -1031,6 +1259,7 @@ class AssetMeta {
         return Contract.__wrap(ret);
     }
     /**
+     * Return the issuance transaction of the asset.
      * @returns {Transaction}
      */
     tx() {
@@ -1040,11 +1269,83 @@ class AssetMeta {
 }
 module.exports.AssetMeta = AssetMeta;
 
+const BalanceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_balance_free(ptr >>> 0, 1));
+/**
+ * A signed balance of assets, to represent a balance with negative values such
+ * as the results of a transaction from the perspective of a wallet.
+ */
+class Balance {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Balance.prototype);
+        obj.__wbg_ptr = ptr;
+        BalanceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BalanceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_balance_free(ptr, 0);
+    }
+    /**
+     * Convert the balance to a JsValue for serialization
+     *
+     * Note: the amounts are strings since `JSON.stringify` cannot handle `BigInt`s.
+     * Use `entries()` to get the raw data.
+     * @returns {any}
+     */
+    toJSON() {
+        const ret = wasm.balance_toJSON(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Returns the balance as an array of [key, value] pairs.
+     * @returns {any}
+     */
+    entries() {
+        const ret = wasm.balance_entries(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Return the string representation of the balance.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.balance_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.Balance = Balance;
+
 const BipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bip_free(ptr >>> 0, 1));
 /**
- * wrapper over [`lwk_common::Bip`]
+ * The bip variant for a descriptor like specified in the bips (49, 84, 87)
  */
 class Bip {
 
@@ -1092,6 +1393,7 @@ class Bip {
         return Bip.__wrap(ret);
     }
     /**
+     * Return the string representation of the bip variant, such as "bip49", "bip84" or "bip87"
      * @returns {string}
      */
     toString() {
@@ -1113,7 +1415,7 @@ const ContractFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_contract_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::Contract`]
+ * A contract defining metadata of an asset such the name and the ticker
  */
 class Contract {
 
@@ -1163,6 +1465,7 @@ class Contract {
         return this;
     }
     /**
+     * Return the string representation of the contract.
      * @returns {string}
      */
     toString() {
@@ -1178,6 +1481,7 @@ class Contract {
         }
     }
     /**
+     * Return the domain of the issuer of the contract.
      * @returns {string}
      */
     domain() {
@@ -1193,6 +1497,10 @@ class Contract {
         }
     }
     /**
+     * Make a copy of the contract.
+     *
+     * This is needed to pass it to a function that requires a `Contract` (without borrowing)
+     * but you need the same contract after that call.
      * @returns {Contract}
      */
     clone() {
@@ -1206,7 +1514,10 @@ const EsploraClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_esploraclient_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`asyncr::EsploraClient`]
+ * A blockchain backend implementation based on the
+ * [esplora HTTP API](https://github.com/blockstream/esplora/blob/master/API.md).
+ * But can also use the [waterfalls](https://github.com/RCasatta/waterfalls)
+ * endpoint to speed up the scan if supported by the server.
  */
 class EsploraClient {
 
@@ -1230,7 +1541,7 @@ class EsploraClient {
         wasm.__wbg_esploraclient_free(ptr, 0);
     }
     /**
-     * Creates a client, wrapper of [`asyncr::EsploraClient`]
+     * Creates an Esplora client with the given options
      * @param {Network} network
      * @param {string} url
      * @param {boolean} waterfalls
@@ -1250,6 +1561,16 @@ class EsploraClient {
         return this;
     }
     /**
+     * Scan the blockchain for the scripts generated by a watch-only wallet
+     *
+     * This method scans both external and internal address chains, stopping after finding
+     * 20 consecutive unused addresses (the gap limit) as recommended by
+     * [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki#address-gap-limit).
+     *
+     * Returns `Some(Update)` if any changes were found during scanning, or `None` if no changes
+     * were detected.
+     *
+     * To scan beyond the gap limit use `full_scan_to_index()` instead.
      * @param {Wollet} wollet
      * @returns {Promise<Update | undefined>}
      */
@@ -1260,6 +1581,19 @@ class EsploraClient {
     }
     /**
      * Scan the blockchain for the scripts generated by a watch-only wallet up to a specified derivation index
+     *
+     * While `full_scan()` stops after finding 20 consecutive unused addresses (the gap limit),
+     * this method will scan at least up to the given derivation index. This is useful to prevent
+     * missing funds in cases where outputs exist beyond the gap limit.
+     *
+     * Will scan both external and internal address chains up to the given index for maximum safety,
+     * even though internal addresses may not need such deep scanning.
+     *
+     * If transactions are found beyond the gap limit during this scan, subsequent calls to
+     * `full_scan()` will automatically scan up to the highest used index, preventing any
+     * previously-found transactions from being missed.
+     *
+     * See `full_scan_to_index()` for a blocking version of this method.
      * @param {Wollet} wollet
      * @param {number} index
      * @returns {Promise<Update | undefined>}
@@ -1270,6 +1604,7 @@ class EsploraClient {
         return ret;
     }
     /**
+     * Broadcast a transaction to the network so that a miner can include it in a block.
      * @param {Transaction} tx
      * @returns {Promise<Txid>}
      */
@@ -1279,6 +1614,7 @@ class EsploraClient {
         return ret;
     }
     /**
+     * Broadcast a PSET by extracting the transaction from the PSET and broadcasting it.
      * @param {Pset} pset
      * @returns {Promise<Txid>}
      */
@@ -1288,13 +1624,14 @@ class EsploraClient {
         return ret;
     }
     /**
+     * Set the waterfalls server recipient key. This is used to encrypt the descriptor when calling the waterfalls endpoint.
      * @param {string} recipient
      * @returns {Promise<void>}
      */
-    set_waterfalls_server_recipient(recipient) {
+    setWaterfallsServerRecipient(recipient) {
         const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.esploraclient_set_waterfalls_server_recipient(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.esploraclient_setWaterfallsServerRecipient(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
 }
@@ -1304,7 +1641,7 @@ const IssuanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_issuance_free(ptr >>> 0, 1));
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::Issuance`]
+ * The details of an issuance or reissuance.
  */
 class Issuance {
 
@@ -1328,6 +1665,7 @@ class Issuance {
         wasm.__wbg_issuance_free(ptr, 0);
     }
     /**
+     * Return the asset id or None if it's a null issuance
      * @returns {AssetId | undefined}
      */
     asset() {
@@ -1335,6 +1673,7 @@ class Issuance {
         return ret === 0 ? undefined : AssetId.__wrap(ret);
     }
     /**
+     * Return the token id or None if it's a null issuance
      * @returns {AssetId | undefined}
      */
     token() {
@@ -1342,6 +1681,7 @@ class Issuance {
         return ret === 0 ? undefined : AssetId.__wrap(ret);
     }
     /**
+     * Return the previous output index or None if it's a null issuance
      * @returns {number | undefined}
      */
     prevVout() {
@@ -1349,6 +1689,7 @@ class Issuance {
         return ret === 0x100000001 ? undefined : ret;
     }
     /**
+     * Return the previous transaction id or None if it's a null issuance
      * @returns {Txid | undefined}
      */
     prevTxid() {
@@ -1356,6 +1697,7 @@ class Issuance {
         return ret === 0 ? undefined : Txid.__wrap(ret);
     }
     /**
+     * Return true if this is effectively an issuance
      * @returns {boolean}
      */
     isIssuance() {
@@ -1363,6 +1705,7 @@ class Issuance {
         return ret !== 0;
     }
     /**
+     * Return true if this is effectively a reissuance
      * @returns {boolean}
      */
     isReissuance() {
@@ -1376,7 +1719,7 @@ const JadeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jade_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`asyncr::Jade`]
+ * A Jade hardware wallet usable via Web Serial
  */
 class Jade {
 
@@ -1529,7 +1872,7 @@ const JadeWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jadewebsocket_free(ptr >>> 0, 1));
 /**
- * WebSocket-based Wrapper of [`asyncr::Jade`]
+ * WebSocket-based `Jade` useful for testing in the browser with the Jade emulator.
  */
 class JadeWebSocket {
 
@@ -1774,7 +2117,9 @@ const MnemonicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mnemonic_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`bip39::Mnemonic`]
+ * A mnemonic secret code used as a master secret for a bip39 wallet.
+ *
+ * Supported number of words are 12, 15, 18, 21, and 24.
  */
 class Mnemonic {
 
@@ -1813,6 +2158,10 @@ class Mnemonic {
         return this;
     }
     /**
+     * Return the string representation of the Mnemonic.
+     * This representation can be used to recreate the Mnemonic via `new()`
+     *
+     * Note this is secret information, do not log it.
      * @returns {string}
      */
     toString() {
@@ -1860,7 +2209,7 @@ const NetworkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_network_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::ElementsNetwork`]
+ * The network of the elements blockchain such as mainnet, testnet or regtest.
  */
 class Network {
 
@@ -1918,6 +2267,7 @@ class Network {
         return Network.__wrap(ret);
     }
     /**
+     * Return the default esplora client for this network
      * @returns {EsploraClient}
      */
     defaultEsploraClient() {
@@ -1925,6 +2275,7 @@ class Network {
         return EsploraClient.__wrap(ret);
     }
     /**
+     * Return true if the network is a mainnet network
      * @returns {boolean}
      */
     isMainnet() {
@@ -1932,6 +2283,7 @@ class Network {
         return ret !== 0;
     }
     /**
+     * Return true if the network is a testnet network
      * @returns {boolean}
      */
     isTestnet() {
@@ -1939,6 +2291,7 @@ class Network {
         return ret !== 0;
     }
     /**
+     * Return true if the network is a regtest network
      * @returns {boolean}
      */
     isRegtest() {
@@ -1946,6 +2299,7 @@ class Network {
         return ret !== 0;
     }
     /**
+     * Return a string representation of the network, like "liquid", "liquid-testnet" or "liquid-regtest"
      * @returns {string}
      */
     toString() {
@@ -1961,6 +2315,7 @@ class Network {
         }
     }
     /**
+     * Return the policy asset for this network
      * @returns {AssetId}
      */
     policyAsset() {
@@ -1968,6 +2323,7 @@ class Network {
         return AssetId.__wrap(ret);
     }
     /**
+     * Return the transaction builder for this network
      * @returns {TxBuilder}
      */
     txBuilder() {
@@ -1975,6 +2331,7 @@ class Network {
         return TxBuilder.__wrap(ret);
     }
     /**
+     * Return the default explorer URL for this network
      * @returns {string}
      */
     defaultExplorerUrl() {
@@ -2021,6 +2378,7 @@ class OptionWalletTxOut {
         wasm.__wbg_optionwallettxout_free(ptr, 0);
     }
     /**
+     * Return a copy of the WalletTxOut if it exists, otherwise None
      * @returns {WalletTxOut | undefined}
      */
     get() {
@@ -2034,7 +2392,7 @@ const OutPointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_outpoint_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`elements::OutPoint`]
+ * A reference to a transaction output
  */
 class OutPoint {
 
@@ -2080,6 +2438,7 @@ class OutPoint {
         return this;
     }
     /**
+     * Return the transaction identifier.
      * @returns {Txid}
      */
     txid() {
@@ -2087,6 +2446,7 @@ class OutPoint {
         return Txid.__wrap(ret);
     }
     /**
+     * Return the output index.
      * @returns {number}
      */
     vout() {
@@ -2100,7 +2460,9 @@ const PrecisionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_precision_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_common::precision::Precision`]
+ * Helper to convert satoshi values of an asset to the value with the given precision and viceversa.
+ *
+ * For example 100 satoshi with precision 2 is "1.00"
  */
 class Precision {
 
@@ -2116,7 +2478,8 @@ class Precision {
         wasm.__wbg_precision_free(ptr, 0);
     }
     /**
-     * Creates a Precision
+     * Create a new Precision, useful to encode e decode values for assets with precision.
+     * erroring if the given precision is greater than the allowed maximum (8)
      * @param {number} precision
      */
     constructor(precision) {
@@ -2129,6 +2492,9 @@ class Precision {
         return this;
     }
     /**
+     * Convert the given satoshi value to the formatted value according to our precision
+     *
+     * For example 100 satoshi with precision 2 is "1.00"
      * @param {bigint} sats
      * @returns {string}
      */
@@ -2145,6 +2511,9 @@ class Precision {
         }
     }
     /**
+     * Convert the given string with precision to satoshi units.
+     *
+     * For example the string "1.00" of an asset with precision 2 is 100 satoshi.
      * @param {string} sats
      * @returns {bigint}
      */
@@ -2164,7 +2533,7 @@ const PsetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_pset_free(ptr >>> 0, 1));
 /**
- * Partially Signed Elements Transaction, wrapper of [`PartiallySignedTransaction`]
+ * Partially Signed Elements Transaction
  */
 class Pset {
 
@@ -2188,7 +2557,7 @@ class Pset {
         wasm.__wbg_pset_free(ptr, 0);
     }
     /**
-     * Creates a `Pset`
+     * Creates a `Pset` from its base64 string representation.
      * @param {string} base64
      */
     constructor(base64) {
@@ -2203,6 +2572,8 @@ class Pset {
         return this;
     }
     /**
+     * Return a base64 string representation of the Pset.
+     * The string can be used to re-create the Pset via `new()`
      * @returns {string}
      */
     toString() {
@@ -2218,6 +2589,8 @@ class Pset {
         }
     }
     /**
+     * Extract the Transaction from a Pset by filling in
+     * the available signature information in place.
      * @returns {Transaction}
      */
     extractTx() {
@@ -2228,6 +2601,7 @@ class Pset {
         return Transaction.__wrap(ret[0]);
     }
     /**
+     * Attempt to merge with another `Pset`.
      * @param {Pset} other
      */
     combine(other) {
@@ -2239,6 +2613,7 @@ class Pset {
         }
     }
     /**
+     * Return a copy of the inputs of this PSET
      * @returns {PsetInput[]}
      */
     inputs() {
@@ -2248,6 +2623,7 @@ class Pset {
         return v1;
     }
     /**
+     * Return a copy of the outputs of this PSET
      * @returns {PsetOutput[]}
      */
     outputs() {
@@ -2263,7 +2639,11 @@ const PsetBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_psetbalance_free(ptr >>> 0, 1));
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetBalance`]
+ * The details regarding balance and amounts in a PSET:
+ *
+ * - The fee of the transaction in the PSET
+ * - The net balance of the assets in the PSET from the point of view of the wallet
+ * - The outputs going out of the wallet
  */
 class PsetBalance {
 
@@ -2295,14 +2675,11 @@ class PsetBalance {
     }
     /**
      * The net balance for every asset with respect of the wallet asking the pset details
-     * @returns {any}
+     * @returns {Balance}
      */
     balances() {
         const ret = wasm.psetbalance_balances(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+        return Balance.__wrap(ret);
     }
     /**
      * @returns {Recipient[]}
@@ -2320,7 +2697,11 @@ const PsetDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_psetdetails_free(ptr >>> 0, 1));
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetDetails`]
+ * The details of a Partially Signed Elements Transaction:
+ *
+ * - the net balance from the point of view of the wallet
+ * - the available and missing signatures for each input
+ * - for issuances and reissuances transactions contains the issuance or reissuance details
  */
 class PsetDetails {
 
@@ -2344,6 +2725,8 @@ class PsetDetails {
         wasm.__wbg_psetdetails_free(ptr, 0);
     }
     /**
+     * Return the balance of the PSET from the point of view of the wallet
+     * that generated this via `psetDetails()`
      * @returns {PsetBalance}
      */
     balance() {
@@ -2361,6 +2744,7 @@ class PsetDetails {
         return v1;
     }
     /**
+     * Set of fingerprints for which the PSET is missing a signature
      * @returns {string[]}
      */
     fingerprintsMissing() {
@@ -2370,6 +2754,7 @@ class PsetDetails {
         return v1;
     }
     /**
+     * List of fingerprints for which the PSET has a signature
      * @returns {string[]}
      */
     fingerprintsHas() {
@@ -2422,16 +2807,16 @@ class PsetInput {
      * Prevout TXID of the input
      * @returns {Txid}
      */
-    previous_txid() {
-        const ret = wasm.psetinput_previous_txid(this.__wbg_ptr);
+    previousTxid() {
+        const ret = wasm.psetinput_previousTxid(this.__wbg_ptr);
         return Txid.__wrap(ret);
     }
     /**
      * Prevout vout of the input
      * @returns {number}
      */
-    previous_vout() {
-        const ret = wasm.psetinput_previous_vout(this.__wbg_ptr);
+    previousVout() {
+        const ret = wasm.psetinput_previousVout(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2483,8 +2868,8 @@ class PsetOutput {
     /**
      * @returns {Script}
      */
-    script_pubkey() {
-        const ret = wasm.psetoutput_script_pubkey(this.__wbg_ptr);
+    scriptPubkey() {
+        const ret = wasm.psetoutput_scriptPubkey(this.__wbg_ptr);
         return Script.__wrap(ret);
     }
 }
@@ -2494,7 +2879,7 @@ const PsetSignaturesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_psetsignatures_free(ptr >>> 0, 1));
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetSignatures`]
+ * The details of the signatures in a PSET, divided in available and missing signatures.
  */
 class PsetSignatures {
 
@@ -2596,7 +2981,9 @@ module.exports.Recipient = Recipient;
 const RegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_registry_free(ptr >>> 0, 1));
-
+/**
+ * A Registry, a repository to store and retrieve asset metadata, like the name or the ticker of an asset.
+ */
 class Registry {
 
     static __wrap(ptr) {
@@ -2619,6 +3006,9 @@ class Registry {
         wasm.__wbg_registry_free(ptr, 0);
     }
     /**
+     * Create a new registry cache specifying the URL of the registry,
+     * fetch the assets metadata identified by the given asset ids and cache them for later local retrieval.
+     * Use `default_for_network()` to get the default registry for the given network.
      * @param {string} url
      * @param {AssetIds} asset_ids
      * @returns {Promise<Registry>}
@@ -2631,6 +3021,9 @@ class Registry {
         return ret;
     }
     /**
+     * Return the default registry for the given network,
+     * fetch the assets metadata identified by the given asset ids and cache them for later local retrieval.
+     * Use `new()` to specify a custom URL
      * @param {Network} network
      * @param {AssetIds} asset_ids
      * @returns {Promise<Registry>}
@@ -2642,6 +3035,9 @@ class Registry {
         return ret;
     }
     /**
+     * Create a new registry cache, using only the hardcoded assets.
+     *
+     * Hardcoded assets are the policy assets (LBTC, tLBTC, rLBTC) and the USDT asset on mainnet.
      * @param {Network} network
      * @returns {Registry}
      */
@@ -2654,6 +3050,7 @@ class Registry {
         return Registry.__wrap(ret[0]);
     }
     /**
+     * Fetch the contract and the issuance transaction of the given asset id from the registry
      * @param {AssetId} asset_id
      * @param {EsploraClient} client
      * @returns {Promise<AssetMeta>}
@@ -2665,6 +3062,7 @@ class Registry {
         return ret;
     }
     /**
+     * Post a contract to the registry for registration.
      * @param {RegistryPost} data
      * @returns {Promise<void>}
      */
@@ -2674,6 +3072,7 @@ class Registry {
         return ret;
     }
     /**
+     * Return the asset metadata related to the given asset id if it exists in this registry.
      * @param {AssetId} asset_id
      * @returns {RegistryData | undefined}
      */
@@ -2683,6 +3082,8 @@ class Registry {
         return ret === 0 ? undefined : RegistryData.__wrap(ret);
     }
     /**
+     * Return the asset metadata related to the given token id,
+     * in other words `token_id` is the reissuance token of the returned asset
      * @param {AssetId} token_id
      * @returns {RegistryData | undefined}
      */
@@ -2692,6 +3093,10 @@ class Registry {
         return ret === 0 ? undefined : RegistryData.__wrap(ret);
     }
     /**
+     * Add the contracts information of the assets used in the Pset
+     * if available in this registry.
+     * Without the contract information, the partially signed transaction
+     * is valid but will not show asset information when signed with an hardware wallet.
      * @param {Pset} pset
      * @returns {Pset}
      */
@@ -2790,7 +3195,9 @@ module.exports.RegistryData = RegistryData;
 const RegistryPostFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_registrypost_free(ptr >>> 0, 1));
-
+/**
+ * The data to post to the registry to publish a contract for an asset id
+ */
 class RegistryPost {
 
     __destroy_into_raw() {
@@ -2805,6 +3212,7 @@ class RegistryPost {
         wasm.__wbg_registrypost_free(ptr, 0);
     }
     /**
+     * Create a new registry post object to be used to publish a contract for an asset id in the registry.
      * @param {Contract} contract
      * @param {AssetId} asset_id
      */
@@ -2819,6 +3227,7 @@ class RegistryPost {
         return this;
     }
     /**
+     * Return a string representation of the registry post (mostly for debugging).
      * @returns {string}
      */
     toString() {
@@ -2840,7 +3249,7 @@ const ScriptFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_script_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`elements::Script`]
+ * An Elements (Liquid) script
  */
 class Script {
 
@@ -2864,7 +3273,7 @@ class Script {
         wasm.__wbg_script_free(ptr, 0);
     }
     /**
-     * Creates a `Script`
+     * Creates a `Script` from its hex string representation.
      * @param {string} s
      */
     constructor(s) {
@@ -2879,6 +3288,7 @@ class Script {
         return this;
     }
     /**
+     * Return the consensus encoded bytes of the script.
      * @returns {Uint8Array}
      */
     bytes() {
@@ -2888,6 +3298,9 @@ class Script {
         return v1;
     }
     /**
+     * Return the string of the script showing op codes and their arguments.
+     *
+     * For example: "OP_DUP OP_HASH160 OP_PUSHBYTES_20 088ac47276d105b91cf9aa27a00112421dd5f23c OP_EQUALVERIFY OP_CHECKSIG"
      * @returns {string}
      */
     asm() {
@@ -2903,6 +3316,8 @@ class Script {
         }
     }
     /**
+     * Return the string representation of the script (hex encoding of its consensus encoded bytes).
+     * This representation can be used to recreate the script via `new()`
      * @returns {string}
      */
     toString() {
@@ -2924,7 +3339,7 @@ const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
 /**
- * A Software signer, wrapper of [`lwk_signer::SwSigner`]
+ * A Software signer.
  */
 class Signer {
 
@@ -2939,6 +3354,65 @@ class Signer {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signer_free(ptr, 0);
     }
+    /**
+     * AMP0 signer data for login
+     * @returns {Amp0SignerData}
+     */
+    amp0SignerData() {
+        const ret = wasm.signer_amp0SignerData(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Amp0SignerData.__wrap(ret[0]);
+    }
+    /**
+     * AMP0 sign login challenge
+     * @param {string} challenge
+     * @returns {string}
+     */
+    amp0SignChallenge(challenge) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(challenge, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.signer_amp0SignChallenge(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * AMP0 account xpub
+     * @param {number} account
+     * @returns {string}
+     */
+    amp0AccountXpub(account) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.signer_amp0AccountXpub(this.__wbg_ptr, account);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Creates a `Signer`
      * @param {Mnemonic} mnemonic
@@ -2995,6 +3469,7 @@ class Signer {
         }
     }
     /**
+     * Return the witness public key hash, slip77 descriptor of this signer
      * @returns {WolletDescriptor}
      */
     wpkhSlip77Descriptor() {
@@ -3005,6 +3480,7 @@ class Signer {
         return WolletDescriptor.__wrap(ret[0]);
     }
     /**
+     * Return the extended public key of the signer
      * @returns {Xpub}
      */
     getMasterXpub() {
@@ -3015,6 +3491,7 @@ class Signer {
         return Xpub.__wrap(ret[0]);
     }
     /**
+     * Return keyorigin and xpub, like "[73c5da0a/84h/1h/0h]tpub..."
      * @param {Bip} bip
      * @returns {string}
      */
@@ -3038,6 +3515,7 @@ class Signer {
         }
     }
     /**
+     * Return the mnemonic of the signer
      * @returns {Mnemonic}
      */
     mnemonic() {
@@ -3092,7 +3570,7 @@ const TipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_tip_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::Tip`]
+ * Blockchain tip, the highest valid block in the blockchain
  */
 class Tip {
 
@@ -3151,9 +3629,9 @@ const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0, 1));
 /**
- * A Liquid transaction, wrapper of [`elements::Transaction`]
+ * A Liquid transaction
  *
- * See [`crate::WalletTx`] for the transaction as seen from the perspective of the wallet
+ * See `WalletTx` for the transaction as seen from the perspective of the wallet
  * where you can actually see unblinded amounts and tx net-balance.
  */
 class Transaction {
@@ -3193,6 +3671,7 @@ class Transaction {
         return this;
     }
     /**
+     * Return the transaction identifier.
      * @returns {Txid}
      */
     txid() {
@@ -3200,6 +3679,7 @@ class Transaction {
         return Txid.__wrap(ret);
     }
     /**
+     * Return the consensus encoded bytes of the transaction.
      * @returns {Uint8Array}
      */
     bytes() {
@@ -3209,6 +3689,8 @@ class Transaction {
         return v1;
     }
     /**
+     * Return the fee of the transaction in the given asset.
+     * At the moment the only asset that can be used as fee is the policy asset (LBTC for mainnet).
      * @param {AssetId} policy_asset
      * @returns {bigint}
      */
@@ -3218,6 +3700,7 @@ class Transaction {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Return the hex representation of the transaction. More precisely, they are the consensus encoded bytes of the transaction converted in hex.
      * @returns {string}
      */
     toString() {
@@ -3239,7 +3722,7 @@ const TxBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_txbuilder_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::TxBuilder`]
+ * A transaction builder
  */
 class TxBuilder {
 
@@ -3399,7 +3882,18 @@ class TxBuilder {
         return TxBuilder.__wrap(ret[0]);
     }
     /**
-     * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
+     * Issue an asset
+     *
+     * There will be `asset_sats` units of this asset that will be received by
+     * `asset_receiver` if it's set, otherwise to an address of the wallet generating the issuance.
+     *
+     * There will be `token_sats` reissuance tokens that allow token holder to reissue the created
+     * asset. Reissuance token will be received by `token_receiver` if it's some, or to an
+     * address of the wallet generating the issuance if none.
+     *
+     * If a `contract` is provided, it's metadata will be committed in the generated asset id.
+     *
+     * Can't be used if `reissue_asset` has been called
      * @param {bigint} asset_sats
      * @param {Address | null | undefined} asset_receiver
      * @param {bigint} token_sats
@@ -3431,7 +3925,17 @@ class TxBuilder {
         return TxBuilder.__wrap(ret[0]);
     }
     /**
-     * Reissue an asset, wrapper of [`lwk_wollet::TxBuilder::reissue_asset()`]
+     * Reissue an asset
+     *
+     * reissue the asset defined by `asset_to_reissue`, provided the reissuance token is owned
+     * by the wallet generating te reissuance.
+     *
+     * Generated transaction will create `satoshi_to_reissue` new asset units, and they will be
+     * sent to the provided `asset_receiver` address if some, or to an address from the wallet
+     * generating the reissuance transaction if none.
+     *
+     * If the issuance transaction does not involve this wallet,
+     * pass the issuance transaction in `issuance_tx`.
      * @param {AssetId} asset_to_reissue
      * @param {bigint} satoshi_to_reissue
      * @param {Address | null} [asset_receiver]
@@ -3459,7 +3963,17 @@ class TxBuilder {
         return TxBuilder.__wrap(ret[0]);
     }
     /**
-     * Manual coin selection, wrapper of [`lwk_wollet::TxBuilder::set_wallet_utxos()`]
+     * Switch to manual coin selection by giving a list of internal UTXOs to use.
+     *
+     * All passed UTXOs are added to the transaction.
+     * No other wallet UTXO is added to the transaction, caller is supposed to add enough UTXOs to
+     * cover for all recipients and fees.
+     *
+     * This method never fails, any error will be raised in [`TxBuilder::finish`].
+     *
+     * Possible errors:
+     * * OutPoint doesn't belong to the wallet
+     * * Insufficient funds (remember to include L-BTC utxos for fees)
      * @param {OutPoint[]} outpoints
      * @returns {TxBuilder}
      */
@@ -3471,6 +3985,7 @@ class TxBuilder {
         return TxBuilder.__wrap(ret);
     }
     /**
+     * Return a string representation of the transaction builder (mostly for debugging)
      * @returns {string}
      */
     toString() {
@@ -3486,6 +4001,8 @@ class TxBuilder {
         }
     }
     /**
+     * Set data to create a PSET from which you
+     * can create a LiquiDEX proposal
      * @param {OutPoint} utxo
      * @param {Address} address
      * @param {bigint} satoshi
@@ -3507,6 +4024,7 @@ class TxBuilder {
         return TxBuilder.__wrap(ret[0]);
     }
     /**
+     * Set data to take LiquiDEX proposals
      * @param {ValidatedLiquidexProposal[]} proposals
      * @returns {TxBuilder}
      */
@@ -3527,7 +4045,7 @@ const TxOutSecretsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_txoutsecrets_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`elements::TxOutSecrets`]
+ * Contains unblinded information such as the asset and the value of a transaction output
  */
 class TxOutSecrets {
 
@@ -3551,6 +4069,7 @@ class TxOutSecrets {
         wasm.__wbg_txoutsecrets_free(ptr, 0);
     }
     /**
+     * Return the asset of the output.
      * @returns {AssetId}
      */
     asset() {
@@ -3558,6 +4077,7 @@ class TxOutSecrets {
         return AssetId.__wrap(ret);
     }
     /**
+     * Return the asset blinding factor as a hex string.
      * @returns {string}
      */
     assetBlindingFactor() {
@@ -3573,6 +4093,7 @@ class TxOutSecrets {
         }
     }
     /**
+     * Return the value of the output.
      * @returns {bigint}
      */
     value() {
@@ -3580,6 +4101,7 @@ class TxOutSecrets {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Return the value blinding factor as a hex string.
      * @returns {string}
      */
     valueBlindingFactor() {
@@ -3595,6 +4117,7 @@ class TxOutSecrets {
         }
     }
     /**
+     * Return true if the output is explicit (no blinding factors).
      * @returns {boolean}
      */
     isExplicit() {
@@ -3670,7 +4193,7 @@ class Txid {
         wasm.__wbg_txid_free(ptr, 0);
     }
     /**
-     * Creates a `Txid`
+     * Creates a `Txid` from its hex string representation (64 characters).
      * @param {string} tx_id
      */
     constructor(tx_id) {
@@ -3685,6 +4208,8 @@ class Txid {
         return this;
     }
     /**
+     * Return the string representation of the transaction identifier as shown in the explorer.
+     * This representation can be used to recreate the transaction identifier via `new()`
      * @returns {string}
      */
     toString() {
@@ -3706,7 +4231,16 @@ const UnvalidatedLiquidexProposalFinalization = (typeof FinalizationRegistry ===
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_unvalidatedliquidexproposal_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::LiquidexProposal<Unvalidated>`]
+ * LiquiDEX swap proposal
+ *
+ * A LiquiDEX swap proposal is a transaction with one input and one output created by the "maker".
+ * The transaction "swaps" the input for the output, meaning that the "maker" sends the input and
+ * receives the output.
+ * However the transaction is incomplete (unbalanced and without a fee output), thus it cannot be
+ * broadcast.
+ * The "taker" can "complete" the transaction (using [`crate::TxBuilder::liquidex_take()`]) by
+ * adding more inputs and more outputs to balance the amounts, meaning that the "taker" sends the
+ * output and receives the input.
  */
 class UnvalidatedLiquidexProposal {
 
@@ -3746,10 +4280,10 @@ class UnvalidatedLiquidexProposal {
      * @param {Pset} pset
      * @returns {UnvalidatedLiquidexProposal}
      */
-    static from_pset(pset) {
+    static fromPset(pset) {
         _assertClass(pset, Pset);
         var ptr0 = pset.__destroy_into_raw();
-        const ret = wasm.unvalidatedliquidexproposal_from_pset(ptr0);
+        const ret = wasm.unvalidatedliquidexproposal_fromPset(ptr0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3758,9 +4292,9 @@ class UnvalidatedLiquidexProposal {
     /**
      * @returns {ValidatedLiquidexProposal}
      */
-    insecure_validate() {
+    insecureValidate() {
         const ptr = this.__destroy_into_raw();
-        const ret = wasm.unvalidatedliquidexproposal_insecure_validate(ptr);
+        const ret = wasm.unvalidatedliquidexproposal_insecureValidate(ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3802,7 +4336,8 @@ const UpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_update_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::Update`]
+ * An Update contains the delta of information to be applied to the wallet to reach the latest status.
+ * It's created passing a reference to the wallet to the blockchain client
  */
 class Update {
 
@@ -3841,6 +4376,7 @@ class Update {
         return this;
     }
     /**
+     * Serialize an update to a byte array
      * @returns {Uint8Array}
      */
     serialize() {
@@ -3853,6 +4389,9 @@ class Update {
         return v1;
     }
     /**
+     * Serialize an update to a base64 encoded string,
+     * encrypted with a key derived from the descriptor.
+     * Decrypt using `deserialize_decrypted_base64()`
      * @param {WolletDescriptor} desc
      * @returns {string}
      */
@@ -3876,6 +4415,9 @@ class Update {
         }
     }
     /**
+     * Deserialize an update from a base64 encoded string,
+     * decrypted with a key derived from the descriptor.
+     * Create the base64 using `serialize_encrypted_base64()`
      * @param {string} base64
      * @param {WolletDescriptor} desc
      * @returns {Update}
@@ -3891,6 +4433,7 @@ class Update {
         return Update.__wrap(ret[0]);
     }
     /**
+     * Whether this update only changes the tip
      * @returns {boolean}
      */
     onlyTip() {
@@ -3898,6 +4441,7 @@ class Update {
         return ret !== 0;
     }
     /**
+     * Prune the update, removing unneeded data from transactions.
      * @param {Wollet} wollet
      */
     prune(wollet) {
@@ -3911,7 +4455,7 @@ const ValidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === '
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_validatedliquidexproposal_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::LiquidexProposal<Validated>`]
+ * Created by validating `UnvalidatedLiquidexProposal` via `validate()` or `insecure_validate()`
  */
 class ValidatedLiquidexProposal {
 
@@ -3977,7 +4521,9 @@ const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wallettx_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::WalletTx`]
+ * Value returned by asking transactions to the wallet. Contains details about a transaction
+ * from the perspective of the wallet, for example the net-balance of the transaction for the
+ * wallet.
  */
 class WalletTx {
 
@@ -4001,6 +4547,7 @@ class WalletTx {
         wasm.__wbg_wallettx_free(ptr, 0);
     }
     /**
+     * Return a copy of the transaction.
      * @returns {Transaction}
      */
     tx() {
@@ -4008,6 +4555,7 @@ class WalletTx {
         return Transaction.__wrap(ret);
     }
     /**
+     * Return the height of the block containing the transaction if it's confirmed.
      * @returns {number | undefined}
      */
     height() {
@@ -4015,16 +4563,15 @@ class WalletTx {
         return ret === 0x100000001 ? undefined : ret;
     }
     /**
-     * @returns {any}
+     * Return the net balance of the transaction for the wallet.
+     * @returns {Balance}
      */
     balance() {
         const ret = wasm.wallettx_balance(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
+        return Balance.__wrap(ret);
     }
     /**
+     * Return the transaction identifier.
      * @returns {Txid}
      */
     txid() {
@@ -4032,6 +4579,7 @@ class WalletTx {
         return Txid.__wrap(ret);
     }
     /**
+     * Return the fee of the transaction.
      * @returns {bigint}
      */
     fee() {
@@ -4039,6 +4587,7 @@ class WalletTx {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Return the type of the transaction. Can be "issuance", "reissuance", "burn", "redeposit", "incoming", "outgoing" or "unknown".
      * @returns {string}
      */
     txType() {
@@ -4054,6 +4603,7 @@ class WalletTx {
         }
     }
     /**
+     * Return the timestamp of the block containing the transaction if it's confirmed.
      * @returns {number | undefined}
      */
     timestamp() {
@@ -4061,6 +4611,9 @@ class WalletTx {
         return ret === 0x100000001 ? undefined : ret;
     }
     /**
+     * Return a list with the same number of elements as the inputs of the transaction.
+     * The element in the list is a `WalletTxOut` (the output spent to create the input)
+     * if it belongs to the wallet, while it is None for inputs owned by others
      * @returns {OptionWalletTxOut[]}
      */
     inputs() {
@@ -4070,6 +4623,9 @@ class WalletTx {
         return v1;
     }
     /**
+     * Return a list with the same number of elements as the outputs of the transaction.
+     * The element in the list is a `WalletTxOut` if it belongs to the wallet,
+     * while it is None for inputs owned by others
      * @returns {OptionWalletTxOut[]}
      */
     outputs() {
@@ -4079,6 +4635,8 @@ class WalletTx {
         return v1;
     }
     /**
+     * Return the URL to the transaction on the given explorer including the information
+     * needed to unblind the transaction in the explorer UI.
      * @param {string} explorer_url
      * @returns {string}
      */
@@ -4103,7 +4661,7 @@ const WalletTxOutFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wallettxout_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::WalletTxOut`]
+ * Details of a wallet transaction output used in `WalletTx`
  */
 class WalletTxOut {
 
@@ -4127,6 +4685,7 @@ class WalletTxOut {
         wasm.__wbg_wallettxout_free(ptr, 0);
     }
     /**
+     * Return the outpoint (txid and vout) of this `WalletTxOut`.
      * @returns {OutPoint}
      */
     outpoint() {
@@ -4134,6 +4693,7 @@ class WalletTxOut {
         return OutPoint.__wrap(ret);
     }
     /**
+     * Return the script pubkey of the address of this `WalletTxOut`.
      * @returns {Script}
      */
     scriptPubkey() {
@@ -4141,6 +4701,7 @@ class WalletTxOut {
         return Script.__wrap(ret);
     }
     /**
+     * Return the height of the block containing this output if it's confirmed.
      * @returns {number | undefined}
      */
     height() {
@@ -4148,6 +4709,7 @@ class WalletTxOut {
         return ret === 0x100000001 ? undefined : ret;
     }
     /**
+     * Return the unblinded values of this `WalletTxOut`.
      * @returns {TxOutSecrets}
      */
     unblinded() {
@@ -4155,6 +4717,7 @@ class WalletTxOut {
         return TxOutSecrets.__wrap(ret);
     }
     /**
+     * Return the wildcard index used to derive the address of this `WalletTxOut`.
      * @returns {number}
      */
     wildcardIndex() {
@@ -4162,6 +4725,7 @@ class WalletTxOut {
         return ret >>> 0;
     }
     /**
+     * Return the chain of this `WalletTxOut`. Can be "Chain::External" or "Chain::Internal" (change).
      * @returns {Chain}
      */
     extInt() {
@@ -4169,6 +4733,7 @@ class WalletTxOut {
         return ret;
     }
     /**
+     * Return the address of this `WalletTxOut`.
      * @returns {Address}
      */
     address() {
@@ -4182,7 +4747,7 @@ const WolletFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wollet_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::Wollet`]
+ * A watch-only wallet defined by a CT descriptor.
  */
 class Wollet {
 
@@ -4237,6 +4802,9 @@ class Wollet {
         return AddressResult.__wrap(ret[0]);
     }
     /**
+     * Get the full derivation path for an address
+     *
+     * Note: will be removed once we add the full path to lwk_wollet::AddressResult
      * @param {number} index
      * @returns {Uint32Array}
      */
@@ -4250,6 +4818,21 @@ class Wollet {
         return v1;
     }
     /**
+     * Apply an update containing blockchain data
+     *
+     * To update the wallet you need to first obtain the blockchain data relevant for the wallet.
+     * This can be done using a `full_scan()`, which
+     * returns an `Update` that contains new transaction and other data relevant for the
+     * wallet.
+     * The update must then be applied to the `Wollet` so that wollet methods such as
+     * `balance()` or `transactions()` include the new data.
+     *
+     * However getting blockchain data involves network calls, so between the full scan start and
+     * when the update is applied it might elapse a significant amount of time.
+     * In that interval, applying any update, or any transaction using `apply_transaction()`,
+     * will cause this function to return a `Error::UpdateOnDifferentStatus`.
+     * Callers should either avoid applying updates and transactions, or they can catch the error
+     * and wait for a new full scan to be completed and applied.
      * @param {Update} update
      */
     applyUpdate(update) {
@@ -4260,26 +4843,45 @@ class Wollet {
         }
     }
     /**
+     * Apply a transaction to the wallet state
+     *
+     * Wallet transactions are normally obtained using a `full_scan()`
+     * and applying the result with `apply_update()`. However a
+     * full scan involves network calls and it can take a significant amount of time.
+     *
+     * If the caller does not want to wait for a full scan containing the transaction, it can
+     * apply the transaction to the wallet state using this function.
+     *
+     * Note: if this transaction is *not* returned by a next full scan, after `apply_update()` it will disappear from the
+     * transactions list, will not be included in balance computations, and by the remaining
+     * wollet methods.
+     *
+     * Calling this method, might cause `apply_update()` to fail with a
+     * `Error::UpdateOnDifferentStatus`, make sure to either avoid it or handle the error properly.
      * @param {Transaction} tx
+     * @returns {Balance}
      */
     applyTransaction(tx) {
         _assertClass(tx, Transaction);
         const ret = wasm.wollet_applyTransaction(this.__wbg_ptr, tx.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return Balance.__wrap(ret[0]);
     }
     /**
-     * @returns {any}
+     * Get the wallet balance for each assets
+     * @returns {Balance}
      */
     balance() {
         const ret = wasm.wollet_balance(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return Balance.__wrap(ret[0]);
     }
     /**
+     * Get the asset identifiers owned by the wallet
      * @returns {AssetIds}
      */
     assetsOwned() {
@@ -4290,6 +4892,7 @@ class Wollet {
         return AssetIds.__wrap(ret[0]);
     }
     /**
+     * Get the wallet transactions
      * @returns {WalletTx[]}
      */
     transactions() {
@@ -4342,6 +4945,7 @@ class Wollet {
         return Pset.__wrap(ret[0]);
     }
     /**
+     * Get the PSET details with respect to the wallet
      * @param {Pset} pset
      * @returns {PsetDetails}
      */
@@ -4354,6 +4958,7 @@ class Wollet {
         return PsetDetails.__wrap(ret[0]);
     }
     /**
+     * Get a copy of the wallet descriptor of this wallet.
      * @returns {WolletDescriptor}
      */
     descriptor() {
@@ -4364,6 +4969,12 @@ class Wollet {
         return WolletDescriptor.__wrap(ret[0]);
     }
     /**
+     * A deterministic value derived from the descriptor, the config and the content of this wollet,
+     * including what's in the wallet store (transactions etc)
+     *
+     * In this case, we don't need cryptographic assurance guaranteed by the std default hasher (siphash)
+     * And we can use a much faster hasher, which is used also in the rust compiler.
+     * ([source](https://nnethercote.github.io/2021/12/08/a-brutally-effective-hash-function-in-rust.html))
      * @returns {bigint}
      */
     status() {
@@ -4371,6 +4982,7 @@ class Wollet {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * Get the blockchain tip at the time of the last update of this wollet.
      * @returns {Tip}
      */
     tip() {
@@ -4378,7 +4990,7 @@ class Wollet {
         return Tip.__wrap(ret);
     }
     /**
-     * wraps [lwk_wollet::Wollet::never_scanned()]
+     * Returns true if this wollet has never received an updated applyed to it
      * @returns {boolean}
      */
     neverScanned() {
@@ -4400,7 +5012,7 @@ const WolletDescriptorFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wolletdescriptor_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`lwk_wollet::WolletDescriptor`]
+ * A wrapper that contains only the subset of CT descriptors handled by wollet
  */
 class WolletDescriptor {
 
@@ -4439,6 +5051,8 @@ class WolletDescriptor {
         return this;
     }
     /**
+     * Return the string representation of the descriptor, including the checksum.
+     * This representation can be used to recreate the descriptor via `new()`
      * @returns {string}
      */
     toString() {
@@ -4454,6 +5068,9 @@ class WolletDescriptor {
         }
     }
     /**
+     * Create a new multisig descriptor, where each participant is a keyorigin_xpub and it requires at least threshold signatures to spend.
+     * Errors if the threshold is 0 or greater than the number of participants.
+     * Uses slip77 for the blinding key.
      * @param {number} threshold
      * @param {string[]} participants
      * @returns {WolletDescriptor}
@@ -4468,6 +5085,7 @@ class WolletDescriptor {
         return WolletDescriptor.__wrap(ret[0]);
     }
     /**
+     * Whether the descriptor is for mainnet
      * @returns {boolean}
      */
     isMainnet() {
@@ -4489,7 +5107,7 @@ const XpubFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_xpub_free(ptr >>> 0, 1));
 /**
- * Wrapper of [`bip32::Xpub`]
+ * An extended public key
  */
 class Xpub {
 
@@ -4513,7 +5131,7 @@ class Xpub {
         wasm.__wbg_xpub_free(ptr, 0);
     }
     /**
-     * Creates a Mnemonic
+     * Creates a Xpub
      * @param {string} s
      */
     constructor(s) {
@@ -4528,6 +5146,8 @@ class Xpub {
         return this;
     }
     /**
+     * Return the string representation of the Xpub.
+     * This representation can be used to recreate the Xpub via `new()`
      * @returns {string}
      */
     toString() {
@@ -4543,6 +5163,8 @@ class Xpub {
         }
     }
     /**
+     * Return the identifier of the Xpub.
+     * This is a 40 hex characters string (20 bytes).
      * @returns {string}
      */
     identifier() {
@@ -4558,6 +5180,8 @@ class Xpub {
         }
     }
     /**
+     * Return the first four bytes of the identifier as hex string
+     * This is a 8 hex characters string (4 bytes).
      * @returns {string}
      */
     fingerprint() {
@@ -4573,7 +5197,8 @@ class Xpub {
         }
     }
     /**
-     * Returns true if the passed string is a valid xpub with a valid keyorigin if present
+     * Returns true if the passed string is a valid xpub with a valid keyorigin if present.
+     * For example: "[73c5da0a/84h/1h/0h]tpub..."
      * @param {string} s
      * @returns {boolean}
      */
@@ -4608,6 +5233,16 @@ module.exports.__wbg_amp0_new = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_amp0connected_new = function(arg0) {
+    const ret = Amp0Connected.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_amp0loggedin_new = function(arg0) {
+    const ret = Amp0LoggedIn.__wrap(arg0);
+    return ret;
+};
+
 module.exports.__wbg_append_8c7dd8d641a5f01b = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
@@ -4652,6 +5287,11 @@ module.exports.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(fun
     return ret;
 }, arguments) };
 
+module.exports.__wbg_call_833bed5770ea2041 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments) };
+
 module.exports.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
     const ret = arg0.crypto;
     return ret;
@@ -4821,7 +5461,7 @@ module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_log_1c0673da475f4734 = function(arg0, arg1) {
+module.exports.__wbg_log_b7d655e59d158495 = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -4852,7 +5492,7 @@ module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_526(a, state0.b, arg0, arg1);
+                return __wbg_adapter_543(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -5282,11 +5922,6 @@ module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
-    const ret = BigInt.asUintN(64, arg0);
-    return ret;
-};
-
 module.exports.__wbindgen_cb_drop = function(arg0) {
     const obj = arg0.original;
     if (obj.cnt-- == 1) {
@@ -5297,23 +5932,23 @@ module.exports.__wbindgen_cb_drop = function(arg0) {
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper12419 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1349, __wbg_adapter_43);
+module.exports.__wbindgen_closure_wrapper12904 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 1368, __wbg_adapter_41);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper4731 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 452, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4336 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 698, __wbg_adapter_34);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper4733 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 453, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4338 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 697, __wbg_adapter_34);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper4735 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 452, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4340 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 697, __wbg_adapter_34);
     return ret;
 };