lwk_node 0.15.0 → 0.17.0

package/lwk_wasm.js

@@ -229,32 +229,6 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
-let cachedUint32ArrayMemory0 = null;
-
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
-}
-
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -265,11 +239,6 @@ function getArrayJsValueFromWasm0(ptr, len) {
     wasm.__externref_drop_slice(ptr, len);
     return result;
 }
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
 /**
  * @returns {Promise<HIDDevice>}
  */
@@ -278,6 +247,21 @@ exports.searchLedgerDevice = function() {
     return ret;
 };
 
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * Convert the given string to a QR code image uri
  *
@@ -310,28 +294,42 @@ exports.stringToQr = function(str, pixel_per_module) {
     }
 };
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
 function __wbg_adapter_6(arg0, arg1, arg2) {
-    wasm.closure1965_externref_shim(arg0, arg1, arg2);
+    wasm.closure1315_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_9(arg0, arg1, arg2) {
-    wasm.closure1211_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_11(arg0, arg1, arg2) {
+    wasm.closure748_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_14(arg0, arg1) {
     wasm.wasm_bindgen__convert__closures_____invoke__h94f351489121fb87(arg0, arg1);
 }
 
-function __wbg_adapter_25(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h912986096667d3cb(arg0, arg1);
+function __wbg_adapter_31(arg0, arg1, arg2) {
+    wasm.closure2094_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_28(arg0, arg1, arg2) {
-    wasm.closure855_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_34(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h912986096667d3cb(arg0, arg1);
 }
 
-function __wbg_adapter_678(arg0, arg1, arg2, arg3) {
-    wasm.closure2742_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_735(arg0, arg1, arg2, arg3) {
+    wasm.closure2881_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -763,7 +761,12 @@ class Amp0Connected {
         wasm.__wbg_amp0connected_free(ptr, 0);
     }
     /**
-     * Connect and register to AMP0
+     * Connect and register to AMP0.
+     *
+     * Deprecated: use `connect()` instead.
+     *
+     * `wasm-bindgen` deprecated async constructors because they generate
+     * invalid TypeScript declarations. See https://github.com/wasm-bindgen/wasm-bindgen/pull/4402.
      * @param {Network} network
      * @param {Amp0SignerData} signer_data
      */
@@ -773,6 +776,18 @@ class Amp0Connected {
         const ret = wasm.amp0connected_new(network.__wbg_ptr, signer_data.__wbg_ptr);
         return ret;
     }
+    /**
+     * Connect and register to AMP0.
+     * @param {Network} network
+     * @param {Amp0SignerData} signer_data
+     * @returns {Promise<Amp0Connected>}
+     */
+    static connect(network, signer_data) {
+        _assertClass(network, Network);
+        _assertClass(signer_data, Amp0SignerData);
+        const ret = wasm.amp0connected_connect(network.__wbg_ptr, signer_data.__wbg_ptr);
+        return ret;
+    }
     /**
      * Obtain a login challenge
      *
@@ -1021,6 +1036,26 @@ class Amp2 {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_amp2_free(ptr, 0);
     }
+    /**
+     * Create a new AMP2 client
+     *
+     *  * `server_key` - The keyorigin xpub of the AMP2 server key
+     *  * `url` - The URL of the AMP2 server
+     * @param {string} server_key
+     * @param {string} url
+     * @returns {Amp2}
+     */
+    static new(server_key, url) {
+        const ptr0 = passStringToWasm0(server_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.amp2_new(ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Amp2.__wrap(ret[0]);
+    }
     /**
      * Create a new AMP2 client with the default url and server key for the testnet network.
      * @returns {Amp2}
@@ -1032,12 +1067,15 @@ class Amp2 {
     /**
      * Get an AMP2 wallet descriptor from the keyorigin xpub string obtained from a signer
      * @param {string} keyorigin_xpub
+     * @param {string} descriptor_blinding_key
      * @returns {Amp2Descriptor}
      */
-    descriptorFromStr(keyorigin_xpub) {
+    descriptorFromStr(keyorigin_xpub, descriptor_blinding_key) {
         const ptr0 = passStringToWasm0(keyorigin_xpub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.amp2_descriptorFromStr(this.__wbg_ptr, ptr0, len0);
+        const ptr1 = passStringToWasm0(descriptor_blinding_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.amp2_descriptorFromStr(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1170,6 +1208,104 @@ if (Symbol.dispose) AssetAmount.prototype[Symbol.dispose] = AssetAmount.prototyp
 
 exports.AssetAmount = AssetAmount;
 
+const AssetBlindingFactorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetblindingfactor_free(ptr >>> 0, 1));
+/**
+ * A blinding factor for asset commitments.
+ */
+class AssetBlindingFactor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetBlindingFactor.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetBlindingFactorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetBlindingFactorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetblindingfactor_free(ptr, 0);
+    }
+    /**
+     * Creates an `AssetBlindingFactor` from a string.
+     * @param {string} s
+     * @returns {AssetBlindingFactor}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetblindingfactor_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Creates an `AssetBlindingFactor` from a byte slice.
+     * @param {Uint8Array} bytes
+     * @returns {AssetBlindingFactor}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetblindingfactor_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Returns a zero asset blinding factor.
+     * @returns {AssetBlindingFactor}
+     */
+    static zero() {
+        const ret = wasm.assetblindingfactor_zero();
+        return AssetBlindingFactor.__wrap(ret);
+    }
+    /**
+     * Returns the bytes (32 bytes) in little-endian byte order.
+     *
+     * This is the internal representation used by secp256k1. The byte order is
+     * reversed compared to the hex string representation (which uses big-endian,
+     * following Bitcoin display conventions).
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.assetblindingfactor_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns string representation of the ABF
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.assetblindingfactor_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);
+        }
+    }
+}
+if (Symbol.dispose) AssetBlindingFactor.prototype[Symbol.dispose] = AssetBlindingFactor.prototype.free;
+
+exports.AssetBlindingFactor = AssetBlindingFactor;
+
 const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetid_free(ptr >>> 0, 1));
@@ -1201,6 +1337,8 @@ class AssetId {
     }
     /**
      * Creates an `AssetId`
+     *
+     * Deprecated: use `from_string()` instead
      * @param {string} asset_id
      */
     constructor(asset_id) {
@@ -1214,9 +1352,47 @@ class AssetId {
         AssetIdFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates an `AssetId` from hex string
+     * @param {string} s
+     * @returns {AssetId}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetid_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetId.__wrap(ret[0]);
+    }
+    /**
+     * Creates an `AssetId` from a bytes.
+     * @param {Uint8Array} bytes
+     * @returns {AssetId}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetid_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetId.__wrap(ret[0]);
+    }
+    /**
+     * Returns the `AssetId` bytes in little-endian byte order.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.assetid_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * Return the string representation of the asset identifier (64 hex characters).
-     * This representation can be used to recreate the asset identifier via `new()`
+     * This representation can be used to recreate the asset identifier via `fromString()`
      * @returns {string}
      */
     toString() {
@@ -2438,12 +2614,31 @@ class Jade {
      *
      * When filter is true, it will filter available serial with Blockstream released chips, use
      * false if you don't see your DYI jade
+     *
+     * Deprecated: use `fromSerial()` instead.
+     *
+     * `wasm-bindgen` deprecated async constructors because they generate
+     * invalid TypeScript declarations. See https://github.com/wasm-bindgen/wasm-bindgen/pull/4402.
      * @param {Network} network
      * @param {boolean} filter
      */
     constructor(network, filter) {
         _assertClass(network, Network);
-        const ret = wasm.jade_from_serial(network.__wbg_ptr, filter);
+        const ret = wasm.jade_new(network.__wbg_ptr, filter);
+        return ret;
+    }
+    /**
+     * Creates a Jade from Web Serial for the given network.
+     *
+     * When filter is true, it will filter available serial with Blockstream released chips, use
+     * false if you don't see your DYI jade
+     * @param {Network} network
+     * @param {boolean} filter
+     * @returns {Promise<Jade>}
+     */
+    static fromSerial(network, filter) {
+        _assertClass(network, Network);
+        const ret = wasm.jade_fromSerial(network.__wbg_ptr, filter);
         return ret;
     }
     /**
@@ -2592,6 +2787,11 @@ class JadeWebSocket {
      * Creates a Jade from WebSocket for the given network
      *
      * The url should point to your WebSocket bridge that connects to the Docker Jade emulator
+     *
+     * Deprecated: use `fromWebSocket()` instead.
+     *
+     * `wasm-bindgen` deprecated async constructors because they generate
+     * invalid TypeScript declarations. See https://github.com/wasm-bindgen/wasm-bindgen/pull/4402.
      * @param {Network} network
      * @param {string} url
      */
@@ -2599,7 +2799,22 @@ class JadeWebSocket {
         _assertClass(network, Network);
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.jadewebsocket_from_websocket(network.__wbg_ptr, ptr0, len0);
+        const ret = wasm.jadewebsocket_new(network.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Creates a Jade from WebSocket for the given network
+     *
+     * The url should point to your WebSocket bridge that connects to the Docker Jade emulator
+     * @param {Network} network
+     * @param {string} url
+     * @returns {Promise<JadeWebSocket>}
+     */
+    static fromWebSocket(network, url) {
+        _assertClass(network, Network);
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jadewebsocket_fromWebSocket(network.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -2739,7 +2954,8 @@ class JsStoreLink {
     /**
      * Create a new `JsStoreLink` from a JavaScript storage object.
      *
-     * The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
+     * The JS object must have `get(key)`, `put(key, value)`, `remove(key)`,
+     * and `isPersisted()` methods.
      * @param {any} storage
      */
     constructor(storage) {
@@ -4924,47 +5140,28 @@ class Signer {
         wasm.__wbg_signer_free(ptr, 0);
     }
     /**
-     * Creates a `Signer`
-     * @param {Mnemonic} mnemonic
-     * @param {Network} network
-     */
-    constructor(mnemonic, network) {
-        _assertClass(mnemonic, Mnemonic);
-        _assertClass(network, Network);
-        const ret = wasm.signer_new(mnemonic.__wbg_ptr, network.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        SignerFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Sign and consume the given PSET, returning the signed one
-     * @param {Pset} pset
-     * @returns {Pset}
+     * AMP0 signer data for login
+     * @returns {Amp0SignerData}
      */
-    sign(pset) {
-        _assertClass(pset, Pset);
-        var ptr0 = pset.__destroy_into_raw();
-        const ret = wasm.signer_sign(this.__wbg_ptr, ptr0);
+    amp0SignerData() {
+        const ret = wasm.signer_amp0SignerData(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Pset.__wrap(ret[0]);
+        return Amp0SignerData.__wrap(ret[0]);
     }
     /**
-     * Sign a message with the master key, return the signature as a base64 string
-     * @param {string} message
+     * AMP0 sign login challenge
+     * @param {string} challenge
      * @returns {string}
      */
-    signMessage(message) {
+    amp0SignChallenge(challenge) {
         let deferred3_0;
         let deferred3_1;
         try {
-            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const ptr0 = passStringToWasm0(challenge, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.signer_signMessage(this.__wbg_ptr, ptr0, len0);
+            const ret = wasm.signer_amp0SignChallenge(this.__wbg_ptr, ptr0, len0);
             var ptr2 = ret[0];
             var len2 = ret[1];
             if (ret[3]) {
@@ -4979,17 +5176,95 @@ class Signer {
         }
     }
     /**
-     * Return the witness public key hash, slip77 descriptor of this signer
-     * @returns {WolletDescriptor}
+     * AMP0 account xpub
+     * @param {number} account
+     * @returns {string}
      */
-    wpkhSlip77Descriptor() {
-        const ret = wasm.signer_wpkhSlip77Descriptor(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WolletDescriptor.__wrap(ret[0]);
-    }
-    /**
+    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
+     * @param {Network} network
+     */
+    constructor(mnemonic, network) {
+        _assertClass(mnemonic, Mnemonic);
+        _assertClass(network, Network);
+        const ret = wasm.signer_new(mnemonic.__wbg_ptr, network.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        SignerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sign and consume the given PSET, returning the signed one
+     * @param {Pset} pset
+     * @returns {Pset}
+     */
+    sign(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.signer_sign(this.__wbg_ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pset.__wrap(ret[0]);
+    }
+    /**
+     * Sign a message with the master key, return the signature as a base64 string
+     * @param {string} message
+     * @returns {string}
+     */
+    signMessage(message) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.signer_signMessage(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);
+        }
+    }
+    /**
+     * Return the witness public key hash, slip77 descriptor of this signer
+     * @returns {WolletDescriptor}
+     */
+    wpkhSlip77Descriptor() {
+        const ret = wasm.signer_wpkhSlip77Descriptor(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WolletDescriptor.__wrap(ret[0]);
+    }
+    /**
      * Return the extended public key of the signer
      * @returns {Xpub}
      */
@@ -5067,65 +5342,6 @@ class Signer {
         }
         return Mnemonic.__wrap(ret[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);
-        }
-    }
 }
 if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
 
@@ -5267,6 +5483,8 @@ class Transaction {
     }
     /**
      * Creates a `Transaction`
+     *
+     * Deprecated: use `fromString()` instead.
      * @param {string} tx_hex
      */
     constructor(tx_hex) {
@@ -5280,6 +5498,34 @@ class Transaction {
         TransactionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates a `Transaction` from hex-encoded consensus bytes.
+     * @param {string} s
+     * @returns {Transaction}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.transaction_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Transaction.__wrap(ret[0]);
+    }
+    /**
+     * Creates a `Transaction` from consensus-encoded bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Transaction}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.transaction_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Transaction.__wrap(ret[0]);
+    }
     /**
      * Return the transaction identifier.
      * @returns {Txid}
@@ -5292,6 +5538,18 @@ class Transaction {
      * Return the consensus encoded bytes of the transaction.
      * @returns {Uint8Array}
      */
+    toBytes() {
+        const ret = wasm.transaction_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Return the consensus encoded bytes of the transaction.
+     *
+     * Deprecated: use `toBytes()` instead.
+     * @returns {Uint8Array}
+     */
     bytes() {
         const ret = wasm.transaction_bytes(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
@@ -5485,9 +5743,8 @@ class TxBuilder {
     addExplicitRecipient(address, satoshi, asset) {
         const ptr = this.__destroy_into_raw();
         _assertClass(address, Address);
-        var ptr0 = address.__destroy_into_raw();
         _assertClass(asset, AssetId);
-        const ret = wasm.txbuilder_addExplicitRecipient(ptr, ptr0, satoshi, asset.__wbg_ptr);
+        const ret = wasm.txbuilder_addExplicitRecipient(ptr, address.__wbg_ptr, satoshi, asset.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5557,18 +5814,17 @@ class TxBuilder {
     reissueAsset(asset_to_reissue, satoshi_to_reissue, asset_receiver, issuance_tx) {
         const ptr = this.__destroy_into_raw();
         _assertClass(asset_to_reissue, AssetId);
-        var ptr0 = asset_to_reissue.__destroy_into_raw();
-        let ptr1 = 0;
+        let ptr0 = 0;
         if (!isLikeNone(asset_receiver)) {
             _assertClass(asset_receiver, Address);
-            ptr1 = asset_receiver.__destroy_into_raw();
+            ptr0 = asset_receiver.__destroy_into_raw();
         }
-        let ptr2 = 0;
+        let ptr1 = 0;
         if (!isLikeNone(issuance_tx)) {
             _assertClass(issuance_tx, Transaction);
-            ptr2 = issuance_tx.__destroy_into_raw();
+            ptr1 = issuance_tx.__destroy_into_raw();
         }
-        const ret = wasm.txbuilder_reissueAsset(ptr, ptr0, satoshi_to_reissue, ptr1, ptr2);
+        const ret = wasm.txbuilder_reissueAsset(ptr, asset_to_reissue.__wbg_ptr, satoshi_to_reissue, ptr0, ptr1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5624,12 +5880,9 @@ class TxBuilder {
     liquidexMake(utxo, address, satoshi, asset_id) {
         const ptr = this.__destroy_into_raw();
         _assertClass(utxo, OutPoint);
-        var ptr0 = utxo.__destroy_into_raw();
         _assertClass(address, Address);
-        var ptr1 = address.__destroy_into_raw();
         _assertClass(asset_id, AssetId);
-        var ptr2 = asset_id.__destroy_into_raw();
-        const ret = wasm.txbuilder_liquidexMake(ptr, ptr0, ptr1, satoshi, ptr2);
+        const ret = wasm.txbuilder_liquidexMake(ptr, utxo.__wbg_ptr, address.__wbg_ptr, satoshi, asset_id.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -5661,9 +5914,289 @@ class TxBuilder {
         return TxBuilder.__wrap(ret);
     }
 }
-if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
+if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
+
+exports.TxBuilder = TxBuilder;
+
+const TxDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txdetails_free(ptr >>> 0, 1));
+/**
+ * Transaction details
+ */
+class TxDetails {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxDetails.prototype);
+        obj.__wbg_ptr = ptr;
+        TxDetailsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxDetailsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txdetails_free(ptr, 0);
+    }
+    /**
+     * Transaction
+     * @returns {Transaction | undefined}
+     */
+    tx() {
+        const ret = wasm.txdetails_tx(this.__wbg_ptr);
+        return ret === 0 ? undefined : Transaction.__wrap(ret);
+    }
+    /**
+     * Txid
+     * @returns {Txid}
+     */
+    txid() {
+        const ret = wasm.txdetails_txid(this.__wbg_ptr);
+        return Txid.__wrap(ret);
+    }
+    /**
+     * Blockchain height
+     * @returns {number | undefined}
+     */
+    height() {
+        const ret = wasm.txdetails_height(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Timestamp
+     *
+     * A reasonable timestamp, that however can be inaccurate.
+     * If you need a precise timestamp, do not use this value.
+     * @returns {number | undefined}
+     */
+    timestamp() {
+        const ret = wasm.txdetails_timestamp(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Transaction type
+     *
+     * A tentative description of the transaction type, which
+     * however might be inaccurate. Use this if you want a simple
+     * description of what this transaction is doing, but do
+     * not rely on the value returned.
+     * @returns {string}
+     */
+    txType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txdetails_txType(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);
+        }
+    }
+    /**
+     * Balance
+     *
+     * Net balance from the `Wollet` perspective
+     * @returns {Balance}
+     */
+    balance() {
+        const ret = wasm.txdetails_balance(this.__wbg_ptr);
+        return Balance.__wrap(ret);
+    }
+    /**
+     * Asset fees
+     * @param {AssetId} asset
+     * @returns {bigint}
+     */
+    feesAsset(asset) {
+        _assertClass(asset, AssetId);
+        const ret = wasm.txdetails_feesAsset(this.__wbg_ptr, asset.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Unblinded URL
+     * @param {string} explorer_url
+     * @returns {string}
+     */
+    unblindedUrl(explorer_url) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(explorer_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.txdetails_unblindedUrl(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Inputs
+     * @returns {TxOutDetails[]}
+     */
+    inputs() {
+        const ret = wasm.txdetails_inputs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Outputs
+     * @returns {TxOutDetails[]}
+     */
+    outputs() {
+        const ret = wasm.txdetails_outputs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) TxDetails.prototype[Symbol.dispose] = TxDetails.prototype.free;
+
+exports.TxDetails = TxDetails;
+
+const TxOptFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txopt_free(ptr >>> 0, 1));
+/**
+ * Options for transaction details
+ */
+class TxOpt {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxOpt.prototype);
+        obj.__wbg_ptr = ptr;
+        TxOptFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxOptFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txopt_free(ptr, 0);
+    }
+    /**
+     * @returns {TxOpt}
+     */
+    static default() {
+        const ret = wasm.txopt_default();
+        return TxOpt.__wrap(ret);
+    }
+}
+if (Symbol.dispose) TxOpt.prototype[Symbol.dispose] = TxOpt.prototype.free;
+
+exports.TxOpt = TxOpt;
+
+const TxOutDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txoutdetails_free(ptr >>> 0, 1));
+/**
+ * Transaction output details
+ */
+class TxOutDetails {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxOutDetails.prototype);
+        obj.__wbg_ptr = ptr;
+        TxOutDetailsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxOutDetailsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txoutdetails_free(ptr, 0);
+    }
+    /**
+     * Outpoint
+     * @returns {OutPoint}
+     */
+    outpoint() {
+        const ret = wasm.txoutdetails_outpoint(this.__wbg_ptr);
+        return OutPoint.__wrap(ret);
+    }
+    /**
+     * Scriptpubkey
+     * @returns {Script | undefined}
+     */
+    script_pubkey() {
+        const ret = wasm.txoutdetails_script_pubkey(this.__wbg_ptr);
+        return ret === 0 ? undefined : Script.__wrap(ret);
+    }
+    /**
+     * Height
+     * @returns {number | undefined}
+     */
+    height() {
+        const ret = wasm.txoutdetails_height(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Address
+     * @returns {Address | undefined}
+     */
+    address() {
+        const ret = wasm.txoutdetails_address(this.__wbg_ptr);
+        return ret === 0 ? undefined : Address.__wrap(ret);
+    }
+    /**
+     * Unblinded values (asset, amount, blinders)
+     * @returns {TxOutSecrets | undefined}
+     */
+    unblinded() {
+        const ret = wasm.txoutdetails_unblinded(this.__wbg_ptr);
+        return ret === 0 ? undefined : TxOutSecrets.__wrap(ret);
+    }
+    /**
+     * Whether the transaction output is explicit
+     * @returns {boolean}
+     */
+    is_explicit() {
+        const ret = wasm.txoutdetails_is_explicit(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether the output is spent by a previously downloaded transaction
+     *
+     * Note: this value might be inaccurate. We compute this from downloaded
+     * transactions, however we only download transactions relevant for the
+     * wallet (i.e. if they include inputs or outputs that belong to the
+     * wallet), thus for non-wallet outputs we might set this value
+     * incorrectly. For wallet outputs, it can be outdated.
+     * @returns {boolean}
+     */
+    is_spent() {
+        const ret = wasm.txoutdetails_is_spent(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) TxOutDetails.prototype[Symbol.dispose] = TxOutDetails.prototype.free;
 
-exports.TxBuilder = TxBuilder;
+exports.TxOutDetails = TxOutDetails;
 
 const TxOutSecretsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -5714,20 +6247,12 @@ class TxOutSecrets {
         return AssetId.__wrap(ret);
     }
     /**
-     * Return the asset blinding factor as a hex string.
-     * @returns {string}
+     * Return the asset blinding factor as a typed object.
+     * @returns {AssetBlindingFactor}
      */
     assetBlindingFactor() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.txoutsecrets_assetBlindingFactor(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);
-        }
+        const ret = wasm.txoutsecrets_assetBlindingFactor(this.__wbg_ptr);
+        return AssetBlindingFactor.__wrap(ret);
     }
     /**
      * Return the value of the output.
@@ -5738,20 +6263,12 @@ class TxOutSecrets {
         return BigInt.asUintN(64, ret);
     }
     /**
-     * Return the value blinding factor as a hex string.
-     * @returns {string}
+     * Return the value blinding factor as a typed object.
+     * @returns {ValueBlindingFactor}
      */
     valueBlindingFactor() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.txoutsecrets_valueBlindingFactor(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);
-        }
+        const ret = wasm.txoutsecrets_valueBlindingFactor(this.__wbg_ptr);
+        return ValueBlindingFactor.__wrap(ret);
     }
     /**
      * Return true if the output is explicit (no blinding factors).
@@ -5868,6 +6385,54 @@ if (Symbol.dispose) Txid.prototype[Symbol.dispose] = Txid.prototype.free;
 
 exports.Txid = Txid;
 
+const TxsOptFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txsopt_free(ptr >>> 0, 1));
+/**
+ * Options for transaction details
+ */
+class TxsOpt {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxsOpt.prototype);
+        obj.__wbg_ptr = ptr;
+        TxsOptFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxsOptFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txsopt_free(ptr, 0);
+    }
+    /**
+     * @returns {TxsOpt}
+     */
+    static default() {
+        const ret = wasm.txsopt_default();
+        return TxsOpt.__wrap(ret);
+    }
+    /**
+     * @param {number} offset
+     * @param {number} limit
+     * @returns {TxsOpt}
+     */
+    static withPagination(offset, limit) {
+        const ret = wasm.txsopt_withPagination(offset, limit);
+        return TxsOpt.__wrap(ret);
+    }
+}
+if (Symbol.dispose) TxsOpt.prototype[Symbol.dispose] = TxsOpt.prototype.free;
+
+exports.TxsOpt = TxsOpt;
+
 const UnvalidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_unvalidatedliquidexproposal_free(ptr >>> 0, 1));
@@ -6164,6 +6729,104 @@ if (Symbol.dispose) ValidatedLiquidexProposal.prototype[Symbol.dispose] = Valida
 
 exports.ValidatedLiquidexProposal = ValidatedLiquidexProposal;
 
+const ValueBlindingFactorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_valueblindingfactor_free(ptr >>> 0, 1));
+/**
+ * A blinding factor for value commitments.
+ */
+class ValueBlindingFactor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ValueBlindingFactor.prototype);
+        obj.__wbg_ptr = ptr;
+        ValueBlindingFactorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ValueBlindingFactorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_valueblindingfactor_free(ptr, 0);
+    }
+    /**
+     * Creates a `ValueBlindingFactor` from a string.
+     * @param {string} s
+     * @returns {ValueBlindingFactor}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.valueblindingfactor_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValueBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Creates a `ValueBlindingFactor` from a byte slice.
+     * @param {Uint8Array} bytes
+     * @returns {ValueBlindingFactor}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.valueblindingfactor_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValueBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Returns a zero value blinding factor.
+     * @returns {ValueBlindingFactor}
+     */
+    static zero() {
+        const ret = wasm.valueblindingfactor_zero();
+        return ValueBlindingFactor.__wrap(ret);
+    }
+    /**
+     * Returns the bytes (32 bytes) in little-endian byte order.
+     *
+     * This is the internal representation used by secp256k1. The byte order is
+     * reversed compared to the hex string representation (which uses big-endian,
+     * following Bitcoin display conventions).
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.valueblindingfactor_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns string representation of the VBF
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.valueblindingfactor_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);
+        }
+    }
+}
+if (Symbol.dispose) ValueBlindingFactor.prototype[Symbol.dispose] = ValueBlindingFactor.prototype.free;
+
+exports.ValueBlindingFactor = ValueBlindingFactor;
+
 const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wallettx_free(ptr >>> 0, 1));
@@ -6421,6 +7084,51 @@ class Wollet {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wollet_free(ptr, 0);
     }
+    /**
+     * Get the transaction list
+     *
+     * **Experimental**: This API may change without notice.
+     * @param {TxsOpt} opt
+     * @returns {TxDetails[]}
+     */
+    txs(opt) {
+        _assertClass(opt, TxsOpt);
+        const ret = wasm.wollet_txs(this.__wbg_ptr, opt.__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;
+    }
+    /**
+     * Number of transactions
+     * @returns {number}
+     */
+    numTxs() {
+        const ret = wasm.wollet_numTxs(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Get the details of a transaction
+     *
+     * **Experimental**: This API may change without notice.
+     * @param {Txid} txid
+     * @param {TxOpt} opt
+     * @returns {TxDetails | undefined}
+     */
+    txDetails(txid, opt) {
+        _assertClass(txid, Txid);
+        _assertClass(opt, TxOpt);
+        const ret = wasm.wollet_txDetails(this.__wbg_ptr, txid.__wbg_ptr, opt.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : TxDetails.__wrap(ret[0]);
+    }
     /**
      * Create a `Wollet`
      * @param {Network} network
@@ -6565,7 +7273,7 @@ class Wollet {
         return AssetIds.__wrap(ret[0]);
     }
     /**
-     * Get the wallet transactions
+     * Get the wallet transactions, sorted by height descending, then txid descending with unconfirmed first
      * @returns {WalletTx[]}
      */
     transactions() {
@@ -6577,6 +7285,21 @@ class Wollet {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Get the wallet transactions with pagination sorted by height descending, then txid descending with unconfirmed first
+     * @param {number} offset
+     * @param {number} limit
+     * @returns {WalletTx[]}
+     */
+    transactionsPaginated(offset, limit) {
+        const ret = wasm.wollet_transactionsPaginated(this.__wbg_ptr, offset, limit);
+        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 unspent transaction outputs of the wallet
      * @returns {WalletTxOut[]}
@@ -6683,6 +7406,134 @@ if (Symbol.dispose) Wollet.prototype[Symbol.dispose] = Wollet.prototype.free;
 
 exports.Wollet = Wollet;
 
+const WolletBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wolletbuilder_free(ptr >>> 0, 1));
+/**
+ * A builder for constructing [`Wollet`] instances.
+ */
+class WolletBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WolletBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        WolletBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WolletBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wolletbuilder_free(ptr, 0);
+    }
+    /**
+     * Create a builder for a watch-only wallet.
+     * @param {Network} network
+     * @param {WolletDescriptor} descriptor
+     */
+    constructor(network, descriptor) {
+        _assertClass(network, Network);
+        _assertClass(descriptor, WolletDescriptor);
+        const ret = wasm.wolletbuilder_new(network.__wbg_ptr, descriptor.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        WolletBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Set the threshold used to merge persisted updates during build.
+     *
+     * **Experimental**: This API may change without notice.
+     *
+     * `None` disables merging (default behavior).
+     * @param {number | null} [merge_threshold]
+     * @returns {WolletBuilder}
+     */
+    withMergeThreshold(merge_threshold) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_withMergeThreshold(ptr, isLikeNone(merge_threshold) ? 0x100000001 : (merge_threshold) >>> 0);
+        return WolletBuilder.__wrap(ret);
+    }
+    /**
+     * Set the wallet as "utxo only".
+     *
+     * **Experimental**: This API may change without notice.
+     * @param {boolean} utxo_only
+     * @returns {WolletBuilder}
+     */
+    utxoOnly(utxo_only) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_utxoOnly(ptr, utxo_only);
+        return WolletBuilder.__wrap(ret);
+    }
+    /**
+     * Persist wallet updates in the given JavaScript storage object.
+     *
+     * **Experimental**: This API may change without notice.
+     *
+     * Wallet data is persisted in clear.
+     *
+     * The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
+     * @param {any} storage
+     * @returns {WolletBuilder}
+     */
+    withExperimentalStore(storage) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_withExperimentalStore(ptr, storage);
+        return WolletBuilder.__wrap(ret);
+    }
+    /**
+     * Persist wallet transactions in the given JavaScript
+     * storage object.
+     *
+     * **Experimental**: This API may change without notice.
+     *
+     * The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
+     * @param {any} storage
+     * @returns {WolletBuilder}
+     */
+    withTxsStore(storage) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_withTxsStore(ptr, storage);
+        return WolletBuilder.__wrap(ret);
+    }
+    /**
+     * Set encryption for the transactions store.
+     *
+     * **Experimental**: This API may change without notice.
+     *
+     * Default: encrypted if the store is persisted.
+     * @param {boolean} encrypt
+     * @returns {WolletBuilder}
+     */
+    setEncryptionTxsStore(encrypt) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_setEncryptionTxsStore(ptr, encrypt);
+        return WolletBuilder.__wrap(ret);
+    }
+    /**
+     * Build the wallet from this builder.
+     * @returns {Wollet}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.wolletbuilder_build(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Wollet.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WolletBuilder.prototype[Symbol.dispose] = WolletBuilder.prototype.free;
+
+exports.WolletBuilder = WolletBuilder;
+
 const WolletDescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wolletdescriptor_free(ptr >>> 0, 1));
@@ -7077,7 +7928,7 @@ exports.__wbg_get_458e874b43b18b25 = function() { return handleError(function (a
     return ret;
 }, arguments) };
 
-exports.__wbg_get_f73bb45577f88031 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+exports.__wbg_get_51efc4293c4dd1d9 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg1.get(getStringFromWasm0(arg2, arg3));
     var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     var len1 = WASM_VECTOR_LEN;
@@ -7176,6 +8027,11 @@ exports.__wbg_isArray_030cce220591fb41 = function(arg0) {
     return ret;
 };
 
+exports.__wbg_isPersisted_d5ab844267f1abff = function() { return handleError(function (arg0) {
+    const ret = arg0.isPersisted();
+    return ret;
+}, arguments) };
+
 exports.__wbg_issuance_new = function(arg0) {
     const ret = Issuance.__wrap(arg0);
     return ret;
@@ -7211,7 +8067,7 @@ exports.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
     return ret;
 };
 
-exports.__wbg_log_7889594dfd0d33ca = function(arg0, arg1) {
+exports.__wbg_log_8528632c48f8c6bb = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -7247,7 +8103,7 @@ exports.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_678(a, state0.b, arg0, arg1);
+                return __wbg_adapter_735(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -7418,7 +8274,7 @@ exports.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
     return ret;
 };
 
-exports.__wbg_put_cc75277821cdd6b8 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+exports.__wbg_put_fe70093a1126561e = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.put(getStringFromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4));
 }, arguments) };
 
@@ -7468,7 +8324,7 @@ exports.__wbg_registry_new = function(arg0) {
     return ret;
 };
 
-exports.__wbg_remove_d275ae23515119c8 = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_remove_e4c99b92a84f8bdb = function() { return handleError(function (arg0, arg1, arg2) {
     arg0.remove(getStringFromWasm0(arg1, arg2));
 }, arguments) };
 
@@ -7684,11 +8540,21 @@ exports.__wbg_transaction_new = function(arg0) {
     return ret;
 };
 
+exports.__wbg_txdetails_new = function(arg0) {
+    const ret = TxDetails.__wrap(arg0);
+    return ret;
+};
+
 exports.__wbg_txid_new = function(arg0) {
     const ret = Txid.__wrap(arg0);
     return ret;
 };
 
+exports.__wbg_txoutdetails_new = function(arg0) {
+    const ret = TxOutDetails.__wrap(arg0);
+    return ret;
+};
+
 exports.__wbg_update_new = function(arg0) {
     const ret = Update.__wrap(arg0);
     return ret;
@@ -7799,9 +8665,15 @@ exports.__wbg_xpub_new = function(arg0) {
     return ret;
 };
 
-exports.__wbindgen_cast_1cc4fdd2f159de97 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1210, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1210, __wbg_adapter_9);
+exports.__wbindgen_cast_05316810ffcd6eb2 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1527, function: Function { arguments: [], shim_idx: 1528, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1527, __wbg_adapter_34);
+    return ret;
+};
+
+exports.__wbindgen_cast_1321c3200b515ef0 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2048, function: Function { arguments: [], shim_idx: 2049, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2048, __wbg_adapter_14);
     return ret;
 };
 
@@ -7811,39 +8683,39 @@ exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
     return ret;
 };
 
-exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
-    // Cast intrinsic for `U64 -> Externref`.
-    const ret = BigInt.asUintN(64, arg0);
+exports.__wbindgen_cast_2418b153fa6fc211 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1234, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1315, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1234, __wbg_adapter_6);
     return ret;
 };
 
-exports.__wbindgen_cast_4a32eb107c538612 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 854, function: Function { arguments: [NamedExternref("HIDInputReportEvent")], shim_idx: 855, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 854, __wbg_adapter_28);
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
     return ret;
 };
 
-exports.__wbindgen_cast_82b35546cfba6ba9 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1210, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1210, __wbg_adapter_9);
+exports.__wbindgen_cast_472e36d4bc1d72dd = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 464, function: Function { arguments: [NamedExternref("HIDInputReportEvent")], shim_idx: 748, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 464, __wbg_adapter_11);
     return ret;
 };
 
-exports.__wbindgen_cast_82fca60108194369 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1467, function: Function { arguments: [], shim_idx: 1468, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1467, __wbg_adapter_25);
+exports.__wbindgen_cast_5fb90d42c153401a = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1234, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1315, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1234, __wbg_adapter_6);
     return ret;
 };
 
-exports.__wbindgen_cast_8c9414a833bf848b = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1919, function: Function { arguments: [], shim_idx: 1920, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1919, __wbg_adapter_14);
+exports.__wbindgen_cast_870f30505a964aa4 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1234, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1315, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1234, __wbg_adapter_6);
     return ret;
 };
 
-exports.__wbindgen_cast_95fb92c9f38f0051 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1954, function: Function { arguments: [Externref], shim_idx: 1965, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1954, __wbg_adapter_6);
+exports.__wbindgen_cast_87b57fd7dc87a7a7 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2083, function: Function { arguments: [Externref], shim_idx: 2094, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2083, __wbg_adapter_31);
     return ret;
 };
 
@@ -7853,30 +8725,24 @@ exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
     return ret;
 };
 
-exports.__wbindgen_cast_c19f87c9f32561d7 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1210, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1210, __wbg_adapter_9);
-    return ret;
-};
-
 exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
     // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 };
 
-exports.__wbindgen_cast_d0dca845d4d81404 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1210, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1210, __wbg_adapter_9);
-    return ret;
-};
-
 exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 };
 
+exports.__wbindgen_cast_df70d36de82e387c = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1234, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1315, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1234, __wbg_adapter_6);
+    return ret;
+};
+
 exports.__wbindgen_init_externref_table = function() {
     const table = wasm.__wbindgen_export_4;
     const offset = table.grow(4);