lwk_node 0.12.1 → 0.13.0

package/lwk_wasm.js

@@ -1,10 +1,6 @@
 
 let imports = {};
 imports['__wbindgen_placeholder__'] = module.exports;
-let wasm;
-const { TextEncoder, TextDecoder } = require(`util`);
-
-let WASM_VECTOR_LEN = 0;
 
 let cachedUint8ArrayMemory0 = null;
 
@@ -15,20 +11,33 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-let cachedTextEncoder = new TextEncoder('utf-8');
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
 
-const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
 }
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
 
 function passStringToWasm0(arg, malloc, realloc) {
 
@@ -59,7 +68,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         }
         ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
         const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = encodeString(arg, view);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
 
         offset += ret.written;
         ptr = realloc(ptr, len, offset, 1) >>> 0;
@@ -78,15 +87,6 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
     wasm.__wbindgen_export_4.set(idx, obj);
@@ -102,44 +102,13 @@ function handleError(f, args) {
     }
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => {
-    wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b)
-});
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
+function isLikeNone(x) {
+    return x === undefined || x === null;
 }
 
 function debugString(val) {
@@ -207,6 +176,40 @@ function debugString(val) {
     return className;
 }
 
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(
+state => {
+    wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b);
+}
+);
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_4.get(idx);
     wasm.__externref_table_dealloc(idx);
@@ -231,7 +234,7 @@ function passArrayJsValueToWasm0(array, malloc) {
 /**
  * @returns {Promise<HIDDevice>}
  */
-module.exports.searchLedgerDevice = function() {
+exports.searchLedgerDevice = function() {
     const ret = wasm.searchLedgerDevice();
     return ret;
 };
@@ -263,34 +266,77 @@ function getUint32ArrayMemory0() {
     return cachedUint32ArrayMemory0;
 }
 
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-
 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 __wbg_adapter_34(arg0, arg1, arg2) {
-    wasm.closure444_externref_shim(arg0, arg1, arg2);
+/**
+ * Convert the given string to a QR code image uri
+ *
+ * The image format is monocromatic bitmap, returned as an encoded in base64 uri.
+ *
+ * Without `pixel_per_module` the default is no border, and 1 pixel per module, to be used
+ * for example in html: `style="image-rendering: pixelated; border: 20px solid white;"`
+ * @param {string} str
+ * @param {number | null} [pixel_per_module]
+ * @returns {string}
+ */
+exports.stringToQr = function(str, pixel_per_module) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stringToQr(ptr0, len0, isLikeNone(pixel_per_module) ? 0xFFFFFF : pixel_per_module);
+        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);
+    }
+};
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+function __wbg_adapter_6(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h05232c3defb8be20(arg0, arg1);
+}
+
+function __wbg_adapter_9(arg0, arg1, arg2) {
+    wasm.closure1305_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_12(arg0, arg1, arg2) {
+    wasm.closure1933_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_23(arg0, arg1, arg2) {
+    wasm.closure773_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_41(arg0, arg1, arg2) {
-    wasm.closure1370_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_32(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h912986096667d3cb(arg0, arg1);
 }
 
-function __wbg_adapter_544(arg0, arg1, arg2, arg3) {
-    wasm.closure2130_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_632(arg0, arg1, arg2, arg3) {
+    wasm.closure2710_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
  * Wallet chain
  * @enum {0 | 1}
  */
-module.exports.Chain = Object.freeze({
+exports.Chain = Object.freeze({
     /**
      * External address, shown when asked for a payment.
      * Wallet having a single descriptor are considered External
@@ -304,6 +350,8 @@ module.exports.Chain = Object.freeze({
 
 const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
 
+const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
@@ -469,7 +517,9 @@ class Address {
         }
     }
 }
-module.exports.Address = Address;
+if (Symbol.dispose) Address.prototype[Symbol.dispose] = Address.prototype.free;
+
+exports.Address = Address;
 
 const AddressResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -517,7 +567,9 @@ class AddressResult {
         return ret >>> 0;
     }
 }
-module.exports.AddressResult = AddressResult;
+if (Symbol.dispose) AddressResult.prototype[Symbol.dispose] = AddressResult.prototype.free;
+
+exports.AddressResult = AddressResult;
 
 const Amp0Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -677,7 +729,9 @@ class Amp0 {
         return ret;
     }
 }
-module.exports.Amp0 = Amp0;
+if (Symbol.dispose) Amp0.prototype[Symbol.dispose] = Amp0.prototype.free;
+
+exports.Amp0 = Amp0;
 
 const Amp0ConnectedFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -743,7 +797,9 @@ class Amp0Connected {
         return ret;
     }
 }
-module.exports.Amp0Connected = Amp0Connected;
+if (Symbol.dispose) Amp0Connected.prototype[Symbol.dispose] = Amp0Connected.prototype.free;
+
+exports.Amp0Connected = Amp0Connected;
 
 const Amp0LoggedInFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -829,7 +885,9 @@ class Amp0LoggedIn {
         return ret;
     }
 }
-module.exports.Amp0LoggedIn = Amp0LoggedIn;
+if (Symbol.dispose) Amp0LoggedIn.prototype[Symbol.dispose] = Amp0LoggedIn.prototype.free;
+
+exports.Amp0LoggedIn = Amp0LoggedIn;
 
 const Amp0PsetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -900,7 +958,9 @@ class Amp0Pset {
         return v1;
     }
 }
-module.exports.Amp0Pset = Amp0Pset;
+if (Symbol.dispose) Amp0Pset.prototype[Symbol.dispose] = Amp0Pset.prototype.free;
+
+exports.Amp0Pset = Amp0Pset;
 
 const Amp0SignerDataFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -928,7 +988,9 @@ class Amp0SignerData {
         wasm.__wbg_amp0signerdata_free(ptr, 0);
     }
 }
-module.exports.Amp0SignerData = Amp0SignerData;
+if (Symbol.dispose) Amp0SignerData.prototype[Symbol.dispose] = Amp0SignerData.prototype.free;
+
+exports.Amp0SignerData = Amp0SignerData;
 
 const Amp2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1000,7 +1062,9 @@ class Amp2 {
         return ret;
     }
 }
-module.exports.Amp2 = Amp2;
+if (Symbol.dispose) Amp2.prototype[Symbol.dispose] = Amp2.prototype.free;
+
+exports.Amp2 = Amp2;
 
 const Amp2DescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1054,7 +1118,9 @@ class Amp2Descriptor {
         }
     }
 }
-module.exports.Amp2Descriptor = Amp2Descriptor;
+if (Symbol.dispose) Amp2Descriptor.prototype[Symbol.dispose] = Amp2Descriptor.prototype.free;
+
+exports.Amp2Descriptor = Amp2Descriptor;
 
 const AssetAmountFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1098,7 +1164,9 @@ class AssetAmount {
         return AssetId.__wrap(ret);
     }
 }
-module.exports.AssetAmount = AssetAmount;
+if (Symbol.dispose) AssetAmount.prototype[Symbol.dispose] = AssetAmount.prototype.free;
+
+exports.AssetAmount = AssetAmount;
 
 const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1162,7 +1230,9 @@ class AssetId {
         }
     }
 }
-module.exports.AssetId = AssetId;
+if (Symbol.dispose) AssetId.prototype[Symbol.dispose] = AssetId.prototype.free;
+
+exports.AssetId = AssetId;
 
 const AssetIdsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1219,7 +1289,9 @@ class AssetIds {
         }
     }
 }
-module.exports.AssetIds = AssetIds;
+if (Symbol.dispose) AssetIds.prototype[Symbol.dispose] = AssetIds.prototype.free;
+
+exports.AssetIds = AssetIds;
 
 const AssetMetaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1267,7 +1339,9 @@ class AssetMeta {
         return Transaction.__wrap(ret);
     }
 }
-module.exports.AssetMeta = AssetMeta;
+if (Symbol.dispose) AssetMeta.prototype[Symbol.dispose] = AssetMeta.prototype.free;
+
+exports.AssetMeta = AssetMeta;
 
 const BalanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1339,7 +1413,9 @@ class Balance {
         }
     }
 }
-module.exports.Balance = Balance;
+if (Symbol.dispose) Balance.prototype[Symbol.dispose] = Balance.prototype.free;
+
+exports.Balance = Balance;
 
 const BipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1409,233 +1485,772 @@ class Bip {
         }
     }
 }
-module.exports.Bip = Bip;
+if (Symbol.dispose) Bip.prototype[Symbol.dispose] = Bip.prototype.free;
 
-const ContractFinalization = (typeof FinalizationRegistry === 'undefined')
+exports.Bip = Bip;
+
+const BoltzSessionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_contract_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_boltzsession_free(ptr >>> 0, 1));
 /**
- * A contract defining metadata of an asset such the name and the ticker
+ * Wrapper over [`lwk_boltz::BoltzSession`]
  */
-class Contract {
+class BoltzSession {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Contract.prototype);
+        const obj = Object.create(BoltzSession.prototype);
         obj.__wbg_ptr = ptr;
-        ContractFinalization.register(obj, obj.__wbg_ptr, obj);
+        BoltzSessionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ContractFinalization.unregister(this);
+        BoltzSessionFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_contract_free(ptr, 0);
-    }
-    /**
-     * Creates a `Contract`
-     * @param {string} domain
-     * @param {string} issuer_pubkey
-     * @param {string} name
-     * @param {number} precision
-     * @param {string} ticker
-     * @param {number} version
-     */
-    constructor(domain, issuer_pubkey, name, precision, ticker, version) {
-        const ptr0 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(issuer_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(ticker, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.contract_new(ptr0, len0, ptr1, len1, ptr2, len2, precision, ptr3, len3, version);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        ContractFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        wasm.__wbg_boltzsession_free(ptr, 0);
     }
     /**
-     * Return the string representation of the contract.
+     * Get the rescue file
      * @returns {string}
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    rescueFile() {
+        let deferred2_0;
+        let deferred2_1;
         try {
-            const ret = wasm.contract_toString(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
+            const ret = wasm.boltzsession_rescueFile(this.__wbg_ptr);
+            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(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
     /**
-     * Return the domain of the issuer of the contract.
-     * @returns {string}
+     * Prepare a lightning invoice payment
+     * @param {LightningPayment} lightning_payment
+     * @param {Address} refund_address
+     * @returns {Promise<PreparePayResponse>}
      */
-    domain() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.contract_domain(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);
-        }
+    preparePay(lightning_payment, refund_address) {
+        _assertClass(lightning_payment, LightningPayment);
+        _assertClass(refund_address, Address);
+        const ret = wasm.boltzsession_preparePay(this.__wbg_ptr, lightning_payment.__wbg_ptr, refund_address.__wbg_ptr);
+        return ret;
     }
     /**
-     * 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}
+     * Create a lightning invoice for receiving payment
+     * @param {bigint} amount
+     * @param {string | null | undefined} description
+     * @param {Address} claim_address
+     * @returns {Promise<InvoiceResponse>}
      */
-    clone() {
-        const ret = wasm.contract_clone(this.__wbg_ptr);
-        return Contract.__wrap(ret);
+    invoice(amount, description, claim_address) {
+        var ptr0 = isLikeNone(description) ? 0 : passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        _assertClass(claim_address, Address);
+        const ret = wasm.boltzsession_invoice(this.__wbg_ptr, amount, ptr0, len0, claim_address.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Restore a swap from its serialized data
+     * @param {string} data
+     * @returns {Promise<PreparePayResponse>}
+     */
+    restorePreparePay(data) {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.boltzsession_restorePreparePay(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Restore a swap from its serialized data
+     * @param {string} data
+     * @returns {Promise<InvoiceResponse>}
+     */
+    restoreInvoice(data) {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.boltzsession_restoreInvoice(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
 }
-module.exports.Contract = Contract;
+if (Symbol.dispose) BoltzSession.prototype[Symbol.dispose] = BoltzSession.prototype.free;
 
-const EsploraClientFinalization = (typeof FinalizationRegistry === 'undefined')
+exports.BoltzSession = BoltzSession;
+
+const BoltzSessionBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_esploraclient_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_boltzsessionbuilder_free(ptr >>> 0, 1));
 /**
- * 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.
+ * Wrapper over [`lwk_boltz::BoltzSessionBuilder`]
  */
-class EsploraClient {
+class BoltzSessionBuilder {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(EsploraClient.prototype);
+        const obj = Object.create(BoltzSessionBuilder.prototype);
         obj.__wbg_ptr = ptr;
-        EsploraClientFinalization.register(obj, obj.__wbg_ptr, obj);
+        BoltzSessionBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        EsploraClientFinalization.unregister(this);
+        BoltzSessionBuilderFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_esploraclient_free(ptr, 0);
+        wasm.__wbg_boltzsessionbuilder_free(ptr, 0);
     }
     /**
-     * Creates an Esplora client with the given options
+     * Create a new BoltzSessionBuilder with the given network
+     *
+     * This creates a builder with default Esplora client for the network.
      * @param {Network} network
-     * @param {string} url
-     * @param {boolean} waterfalls
-     * @param {number} concurrency
-     * @param {boolean} utxo_only
+     * @param {EsploraClient} esplora_client
      */
-    constructor(network, url, waterfalls, concurrency, utxo_only) {
+    constructor(network, esplora_client) {
         _assertClass(network, Network);
-        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.esploraclient_new(network.__wbg_ptr, ptr0, len0, waterfalls, concurrency, utxo_only);
+        _assertClass(esplora_client, EsploraClient);
+        const ret = wasm.boltzsessionbuilder_new(network.__wbg_ptr, esplora_client.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         this.__wbg_ptr = ret[0] >>> 0;
-        EsploraClientFinalization.register(this, this.__wbg_ptr, this);
+        BoltzSessionBuilderFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Scan the blockchain for the scripts generated by a watch-only wallet
+     * Set the timeout for creating swaps
      *
-     * 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).
+     * If not set, the default timeout of 10 seconds is used.
+     * @param {bigint} timeout_seconds
+     * @returns {BoltzSessionBuilder}
+     */
+    createSwapTimeout(timeout_seconds) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_createSwapTimeout(ptr, timeout_seconds);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the timeout for the advance call
      *
-     * Returns `Some(Update)` if any changes were found during scanning, or `None` if no changes
+     * If not set, the default timeout of 3 minutes is used.
+     * @param {bigint} timeout_seconds
+     * @returns {BoltzSessionBuilder}
+     */
+    timeoutAdvance(timeout_seconds) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_timeoutAdvance(ptr, timeout_seconds);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the mnemonic for deriving swap keys
+     *
+     * If not set, a new random mnemonic will be generated.
+     * @param {Mnemonic} mnemonic
+     * @returns {BoltzSessionBuilder}
+     */
+    mnemonic(mnemonic) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(mnemonic, Mnemonic);
+        const ret = wasm.boltzsessionbuilder_mnemonic(ptr, mnemonic.__wbg_ptr);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the polling flag
+     *
+     * If true, the advance call will not await on the websocket connection returning immediately
+     * even if there is no update, thus requiring the caller to poll for updates.
+     *
+     * If true, the timeout_advance will be ignored even if set.
+     * @param {boolean} polling
+     * @returns {BoltzSessionBuilder}
+     */
+    polling(polling) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_polling(ptr, polling);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the next index to use for deriving keypairs
+     *
+     * Avoid a call to the boltz API to recover this information.
+     *
+     * When the mnemonic is not set, this is ignored.
+     * @param {number} next_index_to_use
+     * @returns {BoltzSessionBuilder}
+     */
+    nextIndexToUse(next_index_to_use) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_nextIndexToUse(ptr, next_index_to_use);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the referral id for the BoltzSession
+     * @param {string} referral_id
+     * @returns {BoltzSessionBuilder}
+     */
+    referralId(referral_id) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(referral_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.boltzsessionbuilder_referralId(ptr, ptr0, len0);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Set the url of the bitcoin electrum client
+     * @param {string} bitcoin_electrum_client
+     * @returns {BoltzSessionBuilder}
+     */
+    bitcoinElectrumClient(bitcoin_electrum_client) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(bitcoin_electrum_client, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.boltzsessionbuilder_bitcoinElectrumClient(ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BoltzSessionBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Set the random preimages flag
+     *
+     * The default is false, the preimages will be deterministic and the rescue file will be
+     * compatible with the Boltz web app.
+     * If true, the preimages will be random potentially allowing concurrent sessions with the same
+     * mnemonic, but completing the swap will be possible only with the preimage data. For example
+     * the boltz web app will be able only to refund the swap, not to bring it to completion.
+     * If true, when serializing the swap data, the preimage will be saved in the data.
+     * @param {boolean} random_preimages
+     * @returns {BoltzSessionBuilder}
+     */
+    randomPreimages(random_preimages) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_randomPreimages(ptr, random_preimages);
+        return BoltzSessionBuilder.__wrap(ret);
+    }
+    /**
+     * Build the BoltzSession
+     * @returns {Promise<BoltzSession>}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.boltzsessionbuilder_build(ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) BoltzSessionBuilder.prototype[Symbol.dispose] = BoltzSessionBuilder.prototype.free;
+
+exports.BoltzSessionBuilder = BoltzSessionBuilder;
+
+const ContractFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contract_free(ptr >>> 0, 1));
+/**
+ * A contract defining metadata of an asset such the name and the ticker
+ */
+class Contract {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Contract.prototype);
+        obj.__wbg_ptr = ptr;
+        ContractFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ContractFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_contract_free(ptr, 0);
+    }
+    /**
+     * Creates a `Contract`
+     * @param {string} domain
+     * @param {string} issuer_pubkey
+     * @param {string} name
+     * @param {number} precision
+     * @param {string} ticker
+     * @param {number} version
+     */
+    constructor(domain, issuer_pubkey, name, precision, ticker, version) {
+        const ptr0 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(issuer_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(ticker, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.contract_new(ptr0, len0, ptr1, len1, ptr2, len2, precision, ptr3, len3, version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ContractFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return the string representation of the contract.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contract_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);
+        }
+    }
+    /**
+     * Return the domain of the issuer of the contract.
+     * @returns {string}
+     */
+    domain() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contract_domain(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);
+        }
+    }
+    /**
+     * 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() {
+        const ret = wasm.contract_clone(this.__wbg_ptr);
+        return Contract.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Contract.prototype[Symbol.dispose] = Contract.prototype.free;
+
+exports.Contract = Contract;
+
+const CurrencyCodeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_currencycode_free(ptr >>> 0, 1));
+
+class CurrencyCode {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CurrencyCodeFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_currencycode_free(ptr, 0);
+    }
+    /**
+     * @param {string} code
+     */
+    constructor(code) {
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.currencycode_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        CurrencyCodeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.currencycode_name(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    alpha3() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.currencycode_alpha3(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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    exp() {
+        const ret = wasm.currencycode_exp(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) CurrencyCode.prototype[Symbol.dispose] = CurrencyCode.prototype.free;
+
+exports.CurrencyCode = CurrencyCode;
+
+const EsploraClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_esploraclient_free(ptr >>> 0, 1));
+/**
+ * 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 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(EsploraClient.prototype);
+        obj.__wbg_ptr = ptr;
+        EsploraClientFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EsploraClientFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_esploraclient_free(ptr, 0);
+    }
+    /**
+     * Creates an Esplora client with the given options
+     * @param {Network} network
+     * @param {string} url
+     * @param {boolean} waterfalls
+     * @param {number} concurrency
+     * @param {boolean} utxo_only
+     */
+    constructor(network, url, waterfalls, concurrency, utxo_only) {
+        _assertClass(network, Network);
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.esploraclient_new(network.__wbg_ptr, ptr0, len0, waterfalls, concurrency, utxo_only);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        EsploraClientFinalization.register(this, this.__wbg_ptr, this);
+        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>}
      */
-    fullScan(wollet) {
-        _assertClass(wollet, Wollet);
-        const ret = wasm.esploraclient_fullScan(this.__wbg_ptr, wollet.__wbg_ptr);
-        return ret;
+    fullScan(wollet) {
+        _assertClass(wollet, Wollet);
+        const ret = wasm.esploraclient_fullScan(this.__wbg_ptr, wollet.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * 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>}
+     */
+    fullScanToIndex(wollet, index) {
+        _assertClass(wollet, Wollet);
+        const ret = wasm.esploraclient_fullScanToIndex(this.__wbg_ptr, wollet.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * Broadcast a transaction to the network so that a miner can include it in a block.
+     * @param {Transaction} tx
+     * @returns {Promise<Txid>}
+     */
+    broadcastTx(tx) {
+        _assertClass(tx, Transaction);
+        const ret = wasm.esploraclient_broadcastTx(this.__wbg_ptr, tx.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Broadcast a PSET by extracting the transaction from the PSET and broadcasting it.
+     * @param {Pset} pset
+     * @returns {Promise<Txid>}
+     */
+    broadcast(pset) {
+        _assertClass(pset, Pset);
+        const ret = wasm.esploraclient_broadcast(this.__wbg_ptr, pset.__wbg_ptr);
+        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>}
+     */
+    setWaterfallsServerRecipient(recipient) {
+        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.esploraclient_setWaterfallsServerRecipient(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) EsploraClient.prototype[Symbol.dispose] = EsploraClient.prototype.free;
+
+exports.EsploraClient = EsploraClient;
+
+const ExchangeRatesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_exchangerates_free(ptr >>> 0, 1));
+/**
+ * Multiple exchange rates against BTC provided from various sources
+ */
+class ExchangeRates {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ExchangeRates.prototype);
+        obj.__wbg_ptr = ptr;
+        ExchangeRatesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExchangeRatesFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_exchangerates_free(ptr, 0);
+    }
+    /**
+     * Get the median exchange rate
+     * @returns {number}
+     */
+    median() {
+        const ret = wasm.exchangerates_median(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the individual exchange rates as a JSON array
+     *
+     * Each rate contains: rate, currency, source, and timestamp
+     * @returns {any}
+     */
+    results() {
+        const ret = wasm.exchangerates_results(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get the number of sources that provided rates
+     * @returns {number}
+     */
+    resultsCount() {
+        const ret = wasm.exchangerates_resultsCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Serialize the entire response to JSON string
+     * @returns {string}
+     */
+    serialize() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.exchangerates_serialize(this.__wbg_ptr);
+            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) ExchangeRates.prototype[Symbol.dispose] = ExchangeRates.prototype.free;
+
+exports.ExchangeRates = ExchangeRates;
+
+const InvoiceResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_invoiceresponse_free(ptr >>> 0, 1));
+/**
+ * Wrapper over [`lwk_boltz::InvoiceResponse`]
+ */
+class InvoiceResponse {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(InvoiceResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        InvoiceResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InvoiceResponseFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_invoiceresponse_free(ptr, 0);
+    }
+    /**
+     * Serialize the response to JSON string for JS interop
+     * @returns {string}
+     */
+    serialize() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.invoiceresponse_serialize(this.__wbg_ptr);
+            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);
+        }
     }
     /**
-     * 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>}
+     * Return the bolt11 invoice string
+     * @returns {string}
      */
-    fullScanToIndex(wollet, index) {
-        _assertClass(wollet, Wollet);
-        const ret = wasm.esploraclient_fullScanToIndex(this.__wbg_ptr, wollet.__wbg_ptr, index);
-        return ret;
+    bolt11Invoice() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.invoiceresponse_bolt11Invoice(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);
+        }
     }
     /**
-     * Broadcast a transaction to the network so that a miner can include it in a block.
-     * @param {Transaction} tx
-     * @returns {Promise<Txid>}
+     * @returns {string}
      */
-    broadcastTx(tx) {
-        _assertClass(tx, Transaction);
-        const ret = wasm.esploraclient_broadcastTx(this.__wbg_ptr, tx.__wbg_ptr);
-        return ret;
+    swapId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.invoiceresponse_swapId(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);
+        }
     }
     /**
-     * Broadcast a PSET by extracting the transaction from the PSET and broadcasting it.
-     * @param {Pset} pset
-     * @returns {Promise<Txid>}
+     * The fee of the swap provider
+     *
+     * It is equal to the amount of the invoice minus the amount of the onchain transaction.
+     * Does not include the fee of the onchain transaction.
+     * @returns {bigint | undefined}
      */
-    broadcast(pset) {
-        _assertClass(pset, Pset);
-        const ret = wasm.esploraclient_broadcast(this.__wbg_ptr, pset.__wbg_ptr);
-        return ret;
+    fee() {
+        const ret = wasm.invoiceresponse_fee(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
     }
     /**
-     * Set the waterfalls server recipient key. This is used to encrypt the descriptor when calling the waterfalls endpoint.
-     * @param {string} recipient
-     * @returns {Promise<void>}
+     * Complete the payment by advancing through the swap states until completion or failure
+     * Consumes self as the inner method does
+     * @returns {Promise<boolean>}
      */
-    setWaterfallsServerRecipient(recipient) {
-        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.esploraclient_setWaterfallsServerRecipient(this.__wbg_ptr, ptr0, len0);
+    completePay() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.invoiceresponse_completePay(ptr);
         return ret;
     }
 }
-module.exports.EsploraClient = EsploraClient;
+if (Symbol.dispose) InvoiceResponse.prototype[Symbol.dispose] = InvoiceResponse.prototype.free;
+
+exports.InvoiceResponse = InvoiceResponse;
 
 const IssuanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1713,7 +2328,9 @@ class Issuance {
         return ret !== 0;
     }
 }
-module.exports.Issuance = Issuance;
+if (Symbol.dispose) Issuance.prototype[Symbol.dispose] = Issuance.prototype.free;
+
+exports.Issuance = Issuance;
 
 const JadeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1866,7 +2483,9 @@ class Jade {
         return ret;
     }
 }
-module.exports.Jade = Jade;
+if (Symbol.dispose) Jade.prototype[Symbol.dispose] = Jade.prototype.free;
+
+exports.Jade = Jade;
 
 const JadeWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2020,7 +2639,9 @@ class JadeWebSocket {
         return ret;
     }
 }
-module.exports.JadeWebSocket = JadeWebSocket;
+if (Symbol.dispose) JadeWebSocket.prototype[Symbol.dispose] = JadeWebSocket.prototype.free;
+
+exports.JadeWebSocket = JadeWebSocket;
 
 const LedgerWebFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2031,87 +2652,239 @@ class LedgerWeb {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        LedgerWebFinalization.unregister(this);
+        LedgerWebFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ledgerweb_free(ptr, 0);
+    }
+    /**
+     * hid_device must be already opened
+     * @param {HIDDevice} hid_device
+     * @param {Network} network
+     */
+    constructor(hid_device, network) {
+        _assertClass(network, Network);
+        const ret = wasm.ledgerweb_new(hid_device, network.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        LedgerWebFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    getVersion() {
+        const ret = wasm.ledgerweb_getVersion(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} path
+     * @returns {Promise<string>}
+     */
+    deriveXpub(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ledgerweb_deriveXpub(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    slip77MasterBlindingKey() {
+        const ret = wasm.ledgerweb_slip77MasterBlindingKey(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    fingerprint() {
+        const ret = wasm.ledgerweb_fingerprint(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * TODO Should use Signer::wpkh_slip77_descriptor
+     * @returns {Promise<WolletDescriptor>}
+     */
+    wpkhSlip77Descriptor() {
+        const ret = wasm.ledgerweb_wpkhSlip77Descriptor(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Sign and consume the given PSET, returning the signed one
+     * @param {Pset} pset
+     * @returns {Promise<Pset>}
+     */
+    sign(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.ledgerweb_sign(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * Return a single sig address with the given `variant` and `index`
+     * @param {number} index
+     * @returns {Promise<string>}
+     */
+    getReceiveAddressSingle(index) {
+        const ret = wasm.ledgerweb_getReceiveAddressSingle(this.__wbg_ptr, index);
+        return ret;
+    }
+}
+if (Symbol.dispose) LedgerWeb.prototype[Symbol.dispose] = LedgerWeb.prototype.free;
+
+exports.LedgerWeb = LedgerWeb;
+
+const LightningPaymentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_lightningpayment_free(ptr >>> 0, 1));
+/**
+ * Wrapper over [`lwk_boltz::LightningPayment`]
+ */
+class LightningPayment {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LightningPaymentFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_lightningpayment_free(ptr, 0);
+    }
+    /**
+     * Create a LightningPayment from a bolt11 invoice string or a bolt12 offer
+     * @param {string} invoice
+     */
+    constructor(invoice) {
+        const ptr0 = passStringToWasm0(invoice, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.lightningpayment_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        LightningPaymentFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return a string representation of the LightningPayment
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.lightningpayment_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);
+        }
+    }
+    /**
+     * Return a QR code image uri for the LightningPayment
+     * @param {number | null} [pixel_per_module]
+     * @returns {string}
+     */
+    toUriQr(pixel_per_module) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.lightningpayment_toUriQr(this.__wbg_ptr, isLikeNone(pixel_per_module) ? 0xFFFFFF : pixel_per_module);
+            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) LightningPayment.prototype[Symbol.dispose] = LightningPayment.prototype.free;
+
+exports.LightningPayment = LightningPayment;
+
+const MagicRoutingHintFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_magicroutinghint_free(ptr >>> 0, 1));
+/**
+ * A struct representing a magic routing hint, with details on how to pay directly without using Boltz
+ */
+class MagicRoutingHint {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MagicRoutingHint.prototype);
+        obj.__wbg_ptr = ptr;
+        MagicRoutingHintFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MagicRoutingHintFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ledgerweb_free(ptr, 0);
-    }
-    /**
-     * hid_device must be already opened
-     * @param {HIDDevice} hid_device
-     * @param {Network} network
-     */
-    constructor(hid_device, network) {
-        _assertClass(network, Network);
-        const ret = wasm.ledgerweb_new(hid_device, network.__wbg_ptr);
-        this.__wbg_ptr = ret >>> 0;
-        LedgerWebFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {Promise<string>}
-     */
-    getVersion() {
-        const ret = wasm.ledgerweb_getVersion(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {string} path
-     * @returns {Promise<string>}
-     */
-    deriveXpub(path) {
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ledgerweb_deriveXpub(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * @returns {Promise<string>}
-     */
-    slip77MasterBlindingKey() {
-        const ret = wasm.ledgerweb_slip77MasterBlindingKey(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {Promise<string>}
-     */
-    fingerprint() {
-        const ret = wasm.ledgerweb_fingerprint(this.__wbg_ptr);
-        return ret;
+        wasm.__wbg_magicroutinghint_free(ptr, 0);
     }
     /**
-     * TODO Should use Signer::wpkh_slip77_descriptor
-     * @returns {Promise<WolletDescriptor>}
+     * The address to pay directly to
+     * @returns {string}
      */
-    wpkhSlip77Descriptor() {
-        const ret = wasm.ledgerweb_wpkhSlip77Descriptor(this.__wbg_ptr);
-        return ret;
+    address() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.magicroutinghint_address(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);
+        }
     }
     /**
-     * Sign and consume the given PSET, returning the signed one
-     * @param {Pset} pset
-     * @returns {Promise<Pset>}
+     * The amount to pay directly to
+     * @returns {bigint}
      */
-    sign(pset) {
-        _assertClass(pset, Pset);
-        var ptr0 = pset.__destroy_into_raw();
-        const ret = wasm.ledgerweb_sign(this.__wbg_ptr, ptr0);
-        return ret;
+    amount() {
+        const ret = wasm.magicroutinghint_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * Return a single sig address with the given `variant` and `index`
-     * @param {number} index
-     * @returns {Promise<string>}
+     * The URI to pay directly to
+     * @returns {string}
      */
-    getReceiveAddressSingle(index) {
-        const ret = wasm.ledgerweb_getReceiveAddressSingle(this.__wbg_ptr, index);
-        return ret;
+    uri() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.magicroutinghint_uri(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.LedgerWeb = LedgerWeb;
+if (Symbol.dispose) MagicRoutingHint.prototype[Symbol.dispose] = MagicRoutingHint.prototype.free;
+
+exports.MagicRoutingHint = MagicRoutingHint;
 
 const MnemonicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2203,7 +2976,9 @@ class Mnemonic {
         return Mnemonic.__wrap(ret[0]);
     }
 }
-module.exports.Mnemonic = Mnemonic;
+if (Symbol.dispose) Mnemonic.prototype[Symbol.dispose] = Mnemonic.prototype.free;
+
+exports.Mnemonic = Mnemonic;
 
 const NetworkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2347,7 +3122,9 @@ class Network {
         }
     }
 }
-module.exports.Network = Network;
+if (Symbol.dispose) Network.prototype[Symbol.dispose] = Network.prototype.free;
+
+exports.Network = Network;
 
 const OptionWalletTxOutFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2386,7 +3163,9 @@ class OptionWalletTxOut {
         return ret === 0 ? undefined : WalletTxOut.__wrap(ret);
     }
 }
-module.exports.OptionWalletTxOut = OptionWalletTxOut;
+if (Symbol.dispose) OptionWalletTxOut.prototype[Symbol.dispose] = OptionWalletTxOut.prototype.free;
+
+exports.OptionWalletTxOut = OptionWalletTxOut;
 
 const OutPointFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2454,7 +3233,9 @@ class OutPoint {
         return ret >>> 0;
     }
 }
-module.exports.OutPoint = OutPoint;
+if (Symbol.dispose) OutPoint.prototype[Symbol.dispose] = OutPoint.prototype.free;
+
+exports.OutPoint = OutPoint;
 
 const PrecisionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2527,7 +3308,199 @@ class Precision {
         return ret[0];
     }
 }
-module.exports.Precision = Precision;
+if (Symbol.dispose) Precision.prototype[Symbol.dispose] = Precision.prototype.free;
+
+exports.Precision = Precision;
+
+const PreparePayResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_preparepayresponse_free(ptr >>> 0, 1));
+
+class PreparePayResponse {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PreparePayResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        PreparePayResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PreparePayResponseFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_preparepayresponse_free(ptr, 0);
+    }
+    /**
+     * Serialize the response to JSON string for JS interop
+     * @returns {string}
+     */
+    serialize() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.preparepayresponse_serialize(this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    swapId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preparepayresponse_swapId(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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    uri() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preparepayresponse_uri(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);
+        }
+    }
+    /**
+     * @returns {Address}
+     */
+    uriAddress() {
+        const ret = wasm.preparepayresponse_uriAddress(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Address.__wrap(ret[0]);
+    }
+    /**
+     * @returns {bigint}
+     */
+    uriAmount() {
+        const ret = wasm.preparepayresponse_uriAmount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * The fee of the swap provider
+     *
+     * It is equal to the amount requested onchain minus the amount of the bolt11 invoice
+     * Does not include the fee of the onchain transaction.
+     * @returns {bigint | undefined}
+     */
+    fee() {
+        const ret = wasm.preparepayresponse_fee(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {Promise<boolean>}
+     */
+    completePay() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.preparepayresponse_completePay(ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) PreparePayResponse.prototype[Symbol.dispose] = PreparePayResponse.prototype.free;
+
+exports.PreparePayResponse = PreparePayResponse;
+
+const PricesFetcherFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pricesfetcher_free(ptr >>> 0, 1));
+/**
+ * Wrapper over [`lwk_wollet::PricesFetcher`]
+ */
+class PricesFetcher {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PricesFetcherFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pricesfetcher_free(ptr, 0);
+    }
+    /**
+     * Create a new PricesFetcher with default settings
+     */
+    constructor() {
+        const ret = wasm.pricesfetcher_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PricesFetcherFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Fetch exchange rates for the given currency (e.g., "USD", "EUR", "CHF")
+     *
+     * Returns an ExchangeRates object containing rates from multiple sources and the median
+     * @param {CurrencyCode} currency
+     * @returns {Promise<ExchangeRates>}
+     */
+    rates(currency) {
+        _assertClass(currency, CurrencyCode);
+        const ret = wasm.pricesfetcher_rates(this.__wbg_ptr, currency.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) PricesFetcher.prototype[Symbol.dispose] = PricesFetcher.prototype.free;
+
+exports.PricesFetcher = PricesFetcher;
+
+const PricesFetcherBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pricesfetcherbuilder_free(ptr >>> 0, 1));
+/**
+ * Wrapper over [`lwk_wollet::PricesFetcherBuilder`]
+ */
+class PricesFetcherBuilder {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PricesFetcherBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pricesfetcherbuilder_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) PricesFetcherBuilder.prototype[Symbol.dispose] = PricesFetcherBuilder.prototype.free;
+
+exports.PricesFetcherBuilder = PricesFetcherBuilder;
 
 const PsetFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2633,7 +3606,9 @@ class Pset {
         return v1;
     }
 }
-module.exports.Pset = Pset;
+if (Symbol.dispose) Pset.prototype[Symbol.dispose] = Pset.prototype.free;
+
+exports.Pset = Pset;
 
 const PsetBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2691,7 +3666,9 @@ class PsetBalance {
         return v1;
     }
 }
-module.exports.PsetBalance = PsetBalance;
+if (Symbol.dispose) PsetBalance.prototype[Symbol.dispose] = PsetBalance.prototype.free;
+
+exports.PsetBalance = PsetBalance;
 
 const PsetDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2774,7 +3751,9 @@ class PsetDetails {
         return v1;
     }
 }
-module.exports.PsetDetails = PsetDetails;
+if (Symbol.dispose) PsetDetails.prototype[Symbol.dispose] = PsetDetails.prototype.free;
+
+exports.PsetDetails = PsetDetails;
 
 const PsetInputFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2836,7 +3815,9 @@ class PsetInput {
         return ret === 0 ? undefined : AssetId.__wrap(ret);
     }
 }
-module.exports.PsetInput = PsetInput;
+if (Symbol.dispose) PsetInput.prototype[Symbol.dispose] = PsetInput.prototype.free;
+
+exports.PsetInput = PsetInput;
 
 const PsetOutputFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2873,7 +3854,9 @@ class PsetOutput {
         return Script.__wrap(ret);
     }
 }
-module.exports.PsetOutput = PsetOutput;
+if (Symbol.dispose) PsetOutput.prototype[Symbol.dispose] = PsetOutput.prototype.free;
+
+exports.PsetOutput = PsetOutput;
 
 const PsetSignaturesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2918,7 +3901,9 @@ class PsetSignatures {
         return ret;
     }
 }
-module.exports.PsetSignatures = PsetSignatures;
+if (Symbol.dispose) PsetSignatures.prototype[Symbol.dispose] = PsetSignatures.prototype.free;
+
+exports.PsetSignatures = PsetSignatures;
 
 const RecipientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2976,7 +3961,9 @@ class Recipient {
         return ret >>> 0;
     }
 }
-module.exports.Recipient = Recipient;
+if (Symbol.dispose) Recipient.prototype[Symbol.dispose] = Recipient.prototype.free;
+
+exports.Recipient = Recipient;
 
 const RegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3110,7 +4097,9 @@ class Registry {
         return Pset.__wrap(ret[0]);
     }
 }
-module.exports.Registry = Registry;
+if (Symbol.dispose) Registry.prototype[Symbol.dispose] = Registry.prototype.free;
+
+exports.Registry = Registry;
 
 const RegistryDataFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3190,7 +4179,9 @@ class RegistryData {
         }
     }
 }
-module.exports.RegistryData = RegistryData;
+if (Symbol.dispose) RegistryData.prototype[Symbol.dispose] = RegistryData.prototype.free;
+
+exports.RegistryData = RegistryData;
 
 const RegistryPostFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3243,7 +4234,9 @@ class RegistryPost {
         }
     }
 }
-module.exports.RegistryPost = RegistryPost;
+if (Symbol.dispose) RegistryPost.prototype[Symbol.dispose] = RegistryPost.prototype.free;
+
+exports.RegistryPost = RegistryPost;
 
 const ScriptFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3333,7 +4326,9 @@ class Script {
         }
     }
 }
-module.exports.Script = Script;
+if (Symbol.dispose) Script.prototype[Symbol.dispose] = Script.prototype.free;
+
+exports.Script = Script;
 
 const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3540,12 +4535,27 @@ class Signer {
      * Return the mnemonic of the signer
      * @returns {Mnemonic}
      */
-    mnemonic() {
-        const ret = wasm.signer_mnemonic(this.__wbg_ptr);
-        return Mnemonic.__wrap(ret);
+    mnemonic() {
+        const ret = wasm.signer_mnemonic(this.__wbg_ptr);
+        return Mnemonic.__wrap(ret);
+    }
+    /**
+     * Return the derived BIP85 mnemonic
+     * @param {number} index
+     * @param {number} word_count
+     * @returns {Mnemonic}
+     */
+    derive_bip85_mnemonic(index, word_count) {
+        const ret = wasm.signer_derive_bip85_mnemonic(this.__wbg_ptr, index, word_count);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mnemonic.__wrap(ret[0]);
     }
 }
-module.exports.Signer = Signer;
+if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
+
+exports.Signer = Signer;
 
 const SinglesigFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3586,7 +4596,9 @@ class Singlesig {
         return Singlesig.__wrap(ret[0]);
     }
 }
-module.exports.Singlesig = Singlesig;
+if (Symbol.dispose) Singlesig.prototype[Symbol.dispose] = Singlesig.prototype.free;
+
+exports.Singlesig = Singlesig;
 
 const TipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3645,7 +4657,9 @@ class Tip {
         return ret === 0x100000001 ? undefined : ret;
     }
 }
-module.exports.Tip = Tip;
+if (Symbol.dispose) Tip.prototype[Symbol.dispose] = Tip.prototype.free;
+
+exports.Tip = Tip;
 
 const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3738,7 +4752,9 @@ class Transaction {
         }
     }
 }
-module.exports.Transaction = Transaction;
+if (Symbol.dispose) Transaction.prototype[Symbol.dispose] = Transaction.prototype.free;
+
+exports.Transaction = Transaction;
 
 const TxBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3773,7 +4789,7 @@ class TxBuilder {
      */
     constructor(network) {
         _assertClass(network, Network);
-        const ret = wasm.network_txBuilder(network.__wbg_ptr);
+        const ret = wasm.txbuilder_new(network.__wbg_ptr);
         this.__wbg_ptr = ret >>> 0;
         TxBuilderFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -4060,8 +5076,20 @@ class TxBuilder {
         }
         return TxBuilder.__wrap(ret[0]);
     }
+    /**
+     * Add input rangeproofs
+     * @param {boolean} add_rangeproofs
+     * @returns {TxBuilder}
+     */
+    addInputRangeproofs(add_rangeproofs) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.txbuilder_addInputRangeproofs(ptr, add_rangeproofs);
+        return TxBuilder.__wrap(ret);
+    }
 }
-module.exports.TxBuilder = TxBuilder;
+if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
+
+exports.TxBuilder = TxBuilder;
 
 const TxOutSecretsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4183,7 +5211,9 @@ class TxOutSecrets {
         }
     }
 }
-module.exports.TxOutSecrets = TxOutSecrets;
+if (Symbol.dispose) TxOutSecrets.prototype[Symbol.dispose] = TxOutSecrets.prototype.free;
+
+exports.TxOutSecrets = TxOutSecrets;
 
 const TxidFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4247,7 +5277,9 @@ class Txid {
         }
     }
 }
-module.exports.Txid = Txid;
+if (Symbol.dispose) Txid.prototype[Symbol.dispose] = Txid.prototype.free;
+
+exports.Txid = Txid;
 
 const UnvalidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4352,7 +5384,9 @@ class UnvalidatedLiquidexProposal {
         }
     }
 }
-module.exports.UnvalidatedLiquidexProposal = UnvalidatedLiquidexProposal;
+if (Symbol.dispose) UnvalidatedLiquidexProposal.prototype[Symbol.dispose] = UnvalidatedLiquidexProposal.prototype.free;
+
+exports.UnvalidatedLiquidexProposal = UnvalidatedLiquidexProposal;
 
 const UpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4471,7 +5505,9 @@ class Update {
         wasm.update_prune(this.__wbg_ptr, wollet.__wbg_ptr);
     }
 }
-module.exports.Update = Update;
+if (Symbol.dispose) Update.prototype[Symbol.dispose] = Update.prototype.free;
+
+exports.Update = Update;
 
 const ValidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4537,7 +5573,9 @@ class ValidatedLiquidexProposal {
         }
     }
 }
-module.exports.ValidatedLiquidexProposal = ValidatedLiquidexProposal;
+if (Symbol.dispose) ValidatedLiquidexProposal.prototype[Symbol.dispose] = ValidatedLiquidexProposal.prototype.free;
+
+exports.ValidatedLiquidexProposal = ValidatedLiquidexProposal;
 
 const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4677,7 +5715,9 @@ class WalletTx {
         }
     }
 }
-module.exports.WalletTx = WalletTx;
+if (Symbol.dispose) WalletTx.prototype[Symbol.dispose] = WalletTx.prototype.free;
+
+exports.WalletTx = WalletTx;
 
 const WalletTxOutFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4763,7 +5803,9 @@ class WalletTxOut {
         return Address.__wrap(ret);
     }
 }
-module.exports.WalletTxOut = WalletTxOut;
+if (Symbol.dispose) WalletTxOut.prototype[Symbol.dispose] = WalletTxOut.prototype.free;
+
+exports.WalletTxOut = WalletTxOut;
 
 const WolletFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -4823,6 +5865,28 @@ class Wollet {
         }
         return AddressResult.__wrap(ret[0]);
     }
+    /**
+     * Return the [ELIP152](https://github.com/ElementsProject/ELIPs/blob/main/elip-0152.mediawiki) deterministic wallet identifier.
+     * @returns {string}
+     */
+    dwid() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.wollet_dwid(this.__wbg_ptr);
+            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);
+        }
+    }
     /**
      * Get the full derivation path for an address
      *
@@ -5028,7 +6092,9 @@ class Wollet {
         return ret !== 0;
     }
 }
-module.exports.Wollet = Wollet;
+if (Symbol.dispose) Wollet.prototype[Symbol.dispose] = Wollet.prototype.free;
+
+exports.Wollet = Wollet;
 
 const WolletDescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -5123,7 +6189,9 @@ class WolletDescriptor {
         return ret !== 0;
     }
 }
-module.exports.WolletDescriptor = WolletDescriptor;
+if (Symbol.dispose) WolletDescriptor.prototype[Symbol.dispose] = WolletDescriptor.prototype.free;
+
+exports.WolletDescriptor = WolletDescriptor;
 
 const XpubFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -5231,9 +6299,16 @@ class Xpub {
         return ret !== 0;
     }
 }
-module.exports.Xpub = Xpub;
+if (Symbol.dispose) Xpub.prototype[Symbol.dispose] = Xpub.prototype.free;
+
+exports.Xpub = Xpub;
+
+exports.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
 
-module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
     const ret = String(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -5241,159 +6316,191 @@ module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_abort_775ef1d17fc65868 = function(arg0) {
+exports.__wbg_abort_67e1b49bf6614565 = function(arg0) {
     arg0.abort();
 };
 
-module.exports.__wbg_addressresult_new = function(arg0) {
+exports.__wbg_abort_d830bf2e9aa6ec5b = function(arg0, arg1) {
+    arg0.abort(arg1);
+};
+
+exports.__wbg_addressresult_new = function(arg0) {
     const ret = AddressResult.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_amp0_new = function(arg0) {
+exports.__wbg_amp0_new = function(arg0) {
     const ret = Amp0.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_amp0connected_new = function(arg0) {
+exports.__wbg_amp0connected_new = function(arg0) {
     const ret = Amp0Connected.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_amp0loggedin_new = function(arg0) {
+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) {
+exports.__wbg_append_72a3c0addd2bce38 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-module.exports.__wbg_arrayBuffer_d1b44c4390db422f = function() { return handleError(function (arg0) {
+exports.__wbg_arrayBuffer_9c99b8e2809e8cbb = function() { return handleError(function (arg0) {
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_assetmeta_new = function(arg0) {
+exports.__wbg_assetmeta_new = function(arg0) {
     const ret = AssetMeta.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_buffer_09165b52af8c5237 = function(arg0) {
-    const ret = arg0.buffer;
+exports.__wbg_boltzsession_new = function(arg0) {
+    const ret = BoltzSession.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+exports.__wbg_buffer_8d40b1d762fb3c66 = function(arg0) {
     const ret = arg0.buffer;
     return ret;
 };
 
-module.exports.__wbg_byteLength_1bdb96d98ab0d871 = function(arg0) {
+exports.__wbg_byteLength_8ccf68e3ac59ff5e = function(arg0) {
     const ret = arg0.byteLength;
     return ret;
 };
 
-module.exports.__wbg_byteOffset_d7656012e66edc5f = function(arg0) {
+exports.__wbg_byteOffset_673c717c222fef8e = function(arg0) {
     const ret = arg0.byteOffset;
     return ret;
 };
 
-module.exports.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
     const ret = arg0.call(arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_call_641db1bb5db5a579 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments) };
+
+exports.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_call_833bed5770ea2041 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-    const ret = arg0.call(arg1, arg2, arg3);
+exports.__wbg_clearTimeout_5a54f8841c30079a = function(arg0) {
+    const ret = clearTimeout(arg0);
+    return ret;
+};
+
+exports.__wbg_clearTimeout_7a42b49784aea641 = function(arg0) {
+    const ret = clearTimeout(arg0);
     return ret;
+};
+
+exports.__wbg_close_6437264570d2d37f = function() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments) };
+
+exports.__wbg_close_dadc273a120c03ec = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    arg0.close(arg1, getStringFromWasm0(arg2, arg3));
 }, arguments) };
 
-module.exports.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
+exports.__wbg_code_177e3bed72688e58 = function(arg0) {
+    const ret = arg0.code;
+    return ret;
+};
+
+exports.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
     const ret = arg0.crypto;
     return ret;
 };
 
-module.exports.__wbg_data_432d9c3df2630942 = function(arg0) {
+exports.__wbg_data_8cd553c9786c9361 = function(arg0) {
     const ret = arg0.data;
     return ret;
 };
 
-module.exports.__wbg_data_abeb242764125124 = function(arg0) {
+exports.__wbg_data_9ab529722bcc4e6c = function(arg0) {
     const ret = arg0.data;
     return ret;
 };
 
-module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) {
+exports.__wbg_done_75ed0ee6dd243d9d = function(arg0) {
     const ret = arg0.done;
     return ret;
 };
 
-module.exports.__wbg_fetch_4465c2b10f21a927 = function(arg0) {
+exports.__wbg_exchangerates_new = function(arg0) {
+    const ret = ExchangeRates.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_fetch_74a3e84ebd2c9a0e = function(arg0) {
     const ret = fetch(arg0);
     return ret;
 };
 
-module.exports.__wbg_fetch_509096533071c657 = function(arg0, arg1) {
+exports.__wbg_fetch_87aed7f306ec6d63 = function(arg0, arg1) {
     const ret = arg0.fetch(arg1);
     return ret;
 };
 
-module.exports.__wbg_getDevices_916883032bafc9b1 = function(arg0) {
+exports.__wbg_getDevices_abebcc7be30632a7 = function(arg0) {
     const ret = arg0.getDevices();
     return ret;
 };
 
-module.exports.__wbg_getPorts_5e6efecc826b1a6f = function(arg0) {
+exports.__wbg_getPorts_3a0fce782d01e063 = function(arg0) {
     const ret = arg0.getPorts();
     return ret;
 };
 
-module.exports.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
     arg0.getRandomValues(arg1);
 }, arguments) };
 
-module.exports.__wbg_getUint8_749a77380c219f58 = function(arg0, arg1) {
+exports.__wbg_getUint8_083c6ed87b45a86a = function(arg0, arg1) {
     const ret = arg0.getUint8(arg1 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_getWriter_6ce182d0adc3f96b = function() { return handleError(function (arg0) {
+exports.__wbg_getWriter_03d7689e275ac6a4 = function() { return handleError(function (arg0) {
     const ret = arg0.getWriter();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(arg0, arg1);
-    return ret;
-}, arguments) };
-
-module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
+exports.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 };
 
-module.exports.__wbg_has_a5ea9117f258a0ec = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_has_b89e451f638123e3 = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.has(arg0, arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_headers_9cb51cfd2ac780a4 = function(arg0) {
+exports.__wbg_headers_29fec3c72865cd75 = function(arg0) {
     const ret = arg0.headers;
     return ret;
 };
 
-module.exports.__wbg_hid_890a1b64f4c510a6 = function(arg0) {
+exports.__wbg_hid_fc50a7126d53c63c = function(arg0) {
     const ret = arg0.hid;
     return ret;
 };
 
-module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
+exports.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd = function(arg0) {
     let result;
     try {
         result = arg0 instanceof ArrayBuffer;
@@ -5404,7 +6511,18 @@ module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_HidDevice_281d00db95a533c6 = function(arg0) {
+exports.__wbg_instanceof_Blob_3db67efd3f1b960f = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Blob;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_instanceof_HidDevice_ab5b9b1c208f5539 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof HIDDevice;
@@ -5415,7 +6533,7 @@ module.exports.__wbg_instanceof_HidDevice_281d00db95a533c6 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Response_f2cc20d9f7dfd644 = function(arg0) {
+exports.__wbg_instanceof_Response_50fde2cd696850bf = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Response;
@@ -5426,7 +6544,7 @@ module.exports.__wbg_instanceof_Response_f2cc20d9f7dfd644 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_SerialPort_cb6aa528c64488f2 = function(arg0) {
+exports.__wbg_instanceof_SerialPort_5f6213e35dce8b2a = function(arg0) {
     let result;
     try {
         result = arg0 instanceof SerialPort;
@@ -5437,7 +6555,7 @@ module.exports.__wbg_instanceof_SerialPort_cb6aa528c64488f2 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Window_def73ea0955fc569 = function(arg0) {
+exports.__wbg_instanceof_Window_12d20d558ef92592 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Window;
@@ -5448,73 +6566,83 @@ module.exports.__wbg_instanceof_Window_def73ea0955fc569 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
+exports.__wbg_invoiceresponse_new = function(arg0) {
+    const ret = InvoiceResponse.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_isArray_030cce220591fb41 = function(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 };
 
-module.exports.__wbg_issuance_new = function(arg0) {
+exports.__wbg_issuance_new = function(arg0) {
     const ret = Issuance.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_iterator_9a24c88df860dc65 = function() {
+exports.__wbg_iterator_f370b34483c71a1c = function() {
     const ret = Symbol.iterator;
     return ret;
 };
 
-module.exports.__wbg_jade_new = function(arg0) {
+exports.__wbg_jade_new = function(arg0) {
     const ret = Jade.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_jadewebsocket_new = function(arg0) {
+exports.__wbg_jadewebsocket_new = function(arg0) {
     const ret = JadeWebSocket.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_length_a446193dc22c12f8 = function(arg0) {
+exports.__wbg_length_186546c51cd61acd = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
+exports.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-module.exports.__wbg_log_4dd7615accd2b3e2 = function(arg0, arg1) {
+exports.__wbg_log_98728cad0884ed72 = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
-module.exports.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
+exports.__wbg_magicroutinghint_new = function(arg0) {
+    const ret = MagicRoutingHint.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
     const ret = arg0.msCrypto;
     return ret;
 };
 
-module.exports.__wbg_navigator_1577371c070c8947 = function(arg0) {
+exports.__wbg_navigator_65d5ad763926b868 = function(arg0) {
     const ret = arg0.navigator;
     return ret;
 };
 
-module.exports.__wbg_new_018dcc2d6c8c2f6a = function() { return handleError(function () {
-    const ret = new Headers();
+exports.__wbg_new_19c25a3f2fa63a02 = function() {
+    const ret = new Object();
     return ret;
-}, arguments) };
+};
 
-module.exports.__wbg_new_22a36452a23e0e6f = function() { return handleError(function (arg0) {
-    const ret = new ReadableStreamDefaultReader(arg0);
+exports.__wbg_new_1f3a344cf3123716 = function() {
+    const ret = new Array();
     return ret;
-}, arguments) };
+};
 
-module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
+exports.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
     try {
         var state0 = {a: arg0, b: arg1};
         var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_544(a, state0.b, arg0, arg1);
+                return __wbg_adapter_632(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -5526,367 +6654,434 @@ module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_new_405e22f390576ce2 = function() {
-    const ret = new Object();
+exports.__wbg_new_2ff1f68f3676ea53 = function() {
+    const ret = new Map();
     return ret;
 };
 
-module.exports.__wbg_new_5e0be73521bc8c17 = function() {
-    const ret = new Map();
+exports.__wbg_new_638ebfaedbf32a5e = function(arg0) {
+    const ret = new Uint8Array(arg0);
     return ret;
 };
 
-module.exports.__wbg_new_78feb108b6472713 = function() {
-    const ret = new Array();
+exports.__wbg_new_66b9434b4e59b63e = function() { return handleError(function () {
+    const ret = new AbortController();
     return ret;
-};
+}, arguments) };
 
-module.exports.__wbg_new_92c54fc74574ef55 = function() { return handleError(function (arg0, arg1) {
-    const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+exports.__wbg_new_9033836f0fffb971 = function() { return handleError(function (arg0) {
+    const ret = new ReadableStreamDefaultReader(arg0);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_new_a12002a7f91c75be = function(arg0) {
-    const ret = new Uint8Array(arg0);
+exports.__wbg_new_da9dc54c5db29dfa = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_new_e25e5aab09ff45db = function() { return handleError(function () {
-    const ret = new AbortController();
+exports.__wbg_new_e213f63d18b0de01 = function() { return handleError(function (arg0, arg1) {
+    const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-module.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
-    const ret = new Function(getStringFromWasm0(arg0, arg1));
+exports.__wbg_new_f6e53210afea8e45 = function() { return handleError(function () {
+    const ret = new Headers();
+    return ret;
+}, arguments) };
+
+exports.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
-    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+exports.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_newwithlength_a381634e90c276d4 = function(arg0) {
+exports.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_newwithstrandinit_06c535e0a867c635 = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_newwithstr_4fbb4e3ba652aee4 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = new WebSocket(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+    return ret;
+}, arguments) };
+
+exports.__wbg_newwithstrandinit_b5d168a29a3fd85f = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_newwithstrsequence_6e9d6479e1cf978d = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_newwithstrsequence_f7e2d4848dd49d98 = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = new WebSocket(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
+exports.__wbg_next_5b3530e612fde77d = function(arg0) {
     const ret = arg0.next;
     return ret;
 };
 
-module.exports.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
+exports.__wbg_next_692e82279131b03c = function() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_node_02999533c4ea02e3 = function(arg0) {
+exports.__wbg_node_905d3e251edff8a2 = function(arg0) {
     const ret = arg0.node;
     return ret;
 };
 
-module.exports.__wbg_now_807e54c39636c349 = function() {
+exports.__wbg_now_1e80617bcee43265 = function() {
     const ret = Date.now();
     return ret;
 };
 
-module.exports.__wbg_now_d18023d54d4e5500 = function(arg0) {
+exports.__wbg_now_886b39d7ec380719 = function(arg0) {
     const ret = arg0.now();
     return ret;
 };
 
-module.exports.__wbg_open_a95fae7936477724 = function(arg0) {
+exports.__wbg_open_28c0958dd0e03186 = function(arg0) {
     const ret = arg0.open();
     return ret;
 };
 
-module.exports.__wbg_open_cdb62e879602b6c4 = function(arg0, arg1) {
+exports.__wbg_open_65ec985b581cbed8 = function(arg0, arg1) {
     const ret = arg0.open(arg1);
     return ret;
 };
 
-module.exports.__wbg_opened_1fee39ed52b14681 = function(arg0) {
+exports.__wbg_opened_fc99ed1e3c1035f0 = function(arg0) {
     const ret = arg0.opened;
     return ret;
 };
 
-module.exports.__wbg_optionwallettxout_new = function(arg0) {
+exports.__wbg_optionwallettxout_new = function(arg0) {
     const ret = OptionWalletTxOut.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_outpoint_unwrap = function(arg0) {
+exports.__wbg_outpoint_unwrap = function(arg0) {
     const ret = OutPoint.__unwrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_performance_c185c0cdc2766575 = function(arg0) {
+exports.__wbg_performance_a221af8decc752fb = function(arg0) {
     const ret = arg0.performance;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_process_5c1d670bc53614b8 = function(arg0) {
+exports.__wbg_preparepayresponse_new = function(arg0) {
+    const ret = PreparePayResponse.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
     const ret = arg0.process;
     return ret;
 };
 
-module.exports.__wbg_pset_new = function(arg0) {
+exports.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+exports.__wbg_pset_new = function(arg0) {
     const ret = Pset.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_psetinput_new = function(arg0) {
+exports.__wbg_psetinput_new = function(arg0) {
     const ret = PsetInput.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_psetoutput_new = function(arg0) {
+exports.__wbg_psetoutput_new = function(arg0) {
     const ret = PsetOutput.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_psetsignatures_new = function(arg0) {
+exports.__wbg_psetsignatures_new = function(arg0) {
     const ret = PsetSignatures.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_push_737cfc8c1432c2c6 = function(arg0, arg1) {
+exports.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 };
 
-module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
+exports.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
     queueMicrotask(arg0);
 };
 
-module.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) {
+exports.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
 };
 
-module.exports.__wbg_randomFillSync_ab2cfe79ebbf2740 = function() { return handleError(function (arg0, arg1) {
+exports.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
     arg0.randomFillSync(arg1);
 }, arguments) };
 
-module.exports.__wbg_read_a2434af1186cb56c = function(arg0) {
+exports.__wbg_read_bc925c758aa4d897 = function(arg0) {
     const ret = arg0.read();
     return ret;
 };
 
-module.exports.__wbg_readable_dbb91ee91d979f24 = function(arg0) {
+exports.__wbg_readable_d8d52c48b16a493f = function(arg0) {
     const ret = arg0.readable;
     return ret;
 };
 
-module.exports.__wbg_recipient_new = function(arg0) {
+exports.__wbg_readyState_b0d20ca4531d3797 = function(arg0) {
+    const ret = arg0.readyState;
+    return ret;
+};
+
+exports.__wbg_reason_97efd955be6394bd = function(arg0, arg1) {
+    const ret = arg1.reason;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg_recipient_new = function(arg0) {
     const ret = Recipient.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_registry_new = function(arg0) {
+exports.__wbg_registry_new = function(arg0) {
     const ret = Registry.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_requestDevice_b9904d52d001d64d = function(arg0, arg1) {
+exports.__wbg_requestDevice_225891d9a80a7b19 = function(arg0, arg1) {
     const ret = arg0.requestDevice(arg1);
     return ret;
 };
 
-module.exports.__wbg_requestPort_1f87c6573d65b9ff = function(arg0) {
+exports.__wbg_requestPort_07a56c2addedc9d1 = function(arg0) {
     const ret = arg0.requestPort();
     return ret;
 };
 
-module.exports.__wbg_requestPort_f3ef84a64a129f42 = function(arg0, arg1) {
+exports.__wbg_requestPort_379ba5dd17575815 = function(arg0, arg1) {
     const ret = arg0.requestPort(arg1);
     return ret;
 };
 
-module.exports.__wbg_require_79b1e9274cde3c87 = function() { return handleError(function () {
+exports.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
     const ret = module.require;
     return ret;
 }, arguments) };
 
-module.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) {
+exports.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
 };
 
-module.exports.__wbg_sendReport_4d1024566077f413 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+exports.__wbg_sendReport_c8d0c7c3c3abf30a = function() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.sendReport(arg1, getArrayU8FromWasm0(arg2, arg3));
     return ret;
 }, arguments) };
 
-module.exports.__wbg_send_0293179ba074ffb4 = function() { return handleError(function (arg0, arg1, arg2) {
-    arg0.send(getStringFromWasm0(arg1, arg2));
+exports.__wbg_send_0f09f4487d932d86 = function() { return handleError(function (arg0, arg1) {
+    arg0.send(arg1);
 }, arguments) };
 
-module.exports.__wbg_send_7c4769e24cf1d784 = function() { return handleError(function (arg0, arg1) {
-    arg0.send(arg1);
+exports.__wbg_send_aa9cb445685f0fd0 = function() { return handleError(function (arg0, arg1, arg2) {
+    arg0.send(getArrayU8FromWasm0(arg1, arg2));
+}, arguments) };
+
+exports.__wbg_send_bdda9fac7465e036 = function() { return handleError(function (arg0, arg1, arg2) {
+    arg0.send(getStringFromWasm0(arg1, arg2));
 }, arguments) };
 
-module.exports.__wbg_serial_a5487140b2fdb38f = function(arg0) {
+exports.__wbg_serial_a0dde47bbd77e1b3 = function(arg0) {
     const ret = arg0.serial;
     return ret;
 };
 
-module.exports.__wbg_setTimeout_f2fe5af8e3debeb3 = function() { return handleError(function (arg0, arg1, arg2) {
+exports.__wbg_setTimeout_2966518f28aef92e = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.setTimeout(arg1, arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
-    arg0[arg1 >>> 0] = arg2;
+exports.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+};
+
+exports.__wbg_setTimeout_db2dbaeefb6f39c7 = function() { return handleError(function (arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_set_1353b2a5e96bc48c = function(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
 };
 
-module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 };
 
-module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
-    arg0.set(arg1, arg2 >>> 0);
+exports.__wbg_set_453345bcda80b89a = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+}, arguments) };
+
+exports.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
 };
 
-module.exports.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
+exports.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
     const ret = arg0.set(arg1, arg2);
     return ret;
 };
 
-module.exports.__wbg_setbaudrate_fe58f64af51588e8 = function(arg0, arg1) {
+exports.__wbg_setbaudrate_88a136cc0a6d4b97 = function(arg0, arg1) {
     arg0.baudRate = arg1 >>> 0;
 };
 
-module.exports.__wbg_setbinaryType_92fa1ffd873b327c = function(arg0, arg1) {
+exports.__wbg_setbinaryType_37f3cd35d7775a47 = function(arg0, arg1) {
     arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
 };
 
-module.exports.__wbg_setbody_5923b78a95eedf29 = function(arg0, arg1) {
+exports.__wbg_setbody_c8460bdf44147df8 = function(arg0, arg1) {
     arg0.body = arg1;
 };
 
-module.exports.__wbg_setcredentials_c3a22f1cd105a2c6 = function(arg0, arg1) {
+exports.__wbg_setcache_90ca4ad8a8ad40d3 = function(arg0, arg1) {
+    arg0.cache = __wbindgen_enum_RequestCache[arg1];
+};
+
+exports.__wbg_setcredentials_9cd60d632c9d5dfc = function(arg0, arg1) {
     arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
 };
 
-module.exports.__wbg_setfilters_35abbff30813c430 = function(arg0, arg1) {
+exports.__wbg_setfilters_58b1e783022cd737 = function(arg0, arg1) {
     arg0.filters = arg1;
 };
 
-module.exports.__wbg_setfilters_a1e596125ae8f487 = function(arg0, arg1) {
+exports.__wbg_setfilters_a0bf46d04ea0dd78 = function(arg0, arg1) {
     arg0.filters = arg1;
 };
 
-module.exports.__wbg_setheaders_834c0bdb6a8949ad = function(arg0, arg1) {
+exports.__wbg_setheaders_0052283e2f3503d1 = function(arg0, arg1) {
     arg0.headers = arg1;
 };
 
-module.exports.__wbg_setmethod_3c5280fe5d890842 = function(arg0, arg1, arg2) {
+exports.__wbg_setmethod_9b504d5b855b329c = function(arg0, arg1, arg2) {
     arg0.method = getStringFromWasm0(arg1, arg2);
 };
 
-module.exports.__wbg_setmode_5dc300b865044b65 = function(arg0, arg1) {
+exports.__wbg_setmode_a23e1a2ad8b512f8 = function(arg0, arg1) {
     arg0.mode = __wbindgen_enum_RequestMode[arg1];
 };
 
-module.exports.__wbg_setoninputreport_de1916af49f98e5f = function(arg0, arg1) {
+exports.__wbg_setname_832b43d4602cb930 = function(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+};
+
+exports.__wbg_setonclose_159c0332c2d91b09 = function(arg0, arg1) {
+    arg0.onclose = arg1;
+};
+
+exports.__wbg_setonerror_5d9bff045f909e89 = function(arg0, arg1) {
+    arg0.onerror = arg1;
+};
+
+exports.__wbg_setoninputreport_5d827d5c7285b78f = function(arg0, arg1) {
     arg0.oninputreport = arg1;
 };
 
-module.exports.__wbg_setonmessage_6eccab530a8fb4c7 = function(arg0, arg1) {
+exports.__wbg_setonmessage_5e486f326638a9da = function(arg0, arg1) {
     arg0.onmessage = arg1;
 };
 
-module.exports.__wbg_setonopen_2da654e1f39745d5 = function(arg0, arg1) {
+exports.__wbg_setonopen_3e43af381c2901f8 = function(arg0, arg1) {
     arg0.onopen = arg1;
 };
 
-module.exports.__wbg_setsignal_75b21ef3a81de905 = function(arg0, arg1) {
+exports.__wbg_setsignal_8c45ad1247a74809 = function(arg0, arg1) {
     arg0.signal = arg1;
 };
 
-module.exports.__wbg_signal_aaf9ad74119f20a4 = function(arg0) {
+exports.__wbg_signal_da4d466ce86118b5 = function(arg0) {
     const ret = arg0.signal;
     return ret;
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+exports.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+exports.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
     const ret = typeof globalThis === 'undefined' ? null : globalThis;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+exports.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
     const ret = typeof self === 'undefined' ? null : self;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+exports.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_status_f6360336ca686bf0 = function(arg0) {
+exports.__wbg_status_3fea3036088621d6 = function(arg0) {
     const ret = arg0.status;
     return ret;
 };
 
-module.exports.__wbg_stringify_f7ed6987935b4a24 = function() { return handleError(function (arg0) {
+exports.__wbg_stringify_b98c93d0a190446a = function() { return handleError(function (arg0) {
     const ret = JSON.stringify(arg0);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_subarray_aa9065fa9dc5df96 = function(arg0, arg1, arg2) {
+exports.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_text_7805bea50de2af49 = function() { return handleError(function (arg0) {
+exports.__wbg_text_0f69a215637b9b34 = function() { return handleError(function (arg0) {
     const ret = arg0.text();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
-    const ret = arg0.then(arg1);
+exports.__wbg_then_b33a773d723afa3e = function(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
     return ret;
 };
 
-module.exports.__wbg_then_48b406749878a531 = function(arg0, arg1, arg2) {
-    const ret = arg0.then(arg1, arg2);
+exports.__wbg_then_e22500defe16819f = function(arg0, arg1) {
+    const ret = arg0.then(arg1);
     return ret;
 };
 
-module.exports.__wbg_transaction_new = function(arg0) {
+exports.__wbg_transaction_new = function(arg0) {
     const ret = Transaction.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_txid_new = function(arg0) {
+exports.__wbg_txid_new = function(arg0) {
     const ret = Txid.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_update_new = function(arg0) {
+exports.__wbg_update_new = function(arg0) {
     const ret = Update.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_url_ae10c34ca209681d = function(arg0, arg1) {
+exports.__wbg_url_e5720dfacf77b05e = function(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -5894,166 +7089,196 @@ module.exports.__wbg_url_ae10c34ca209681d = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_validatedliquidexproposal_unwrap = function(arg0) {
+exports.__wbg_validatedliquidexproposal_unwrap = function(arg0) {
     const ret = ValidatedLiquidexProposal.__unwrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
+exports.__wbg_value_dd9372230531eade = function(arg0) {
     const ret = arg0.value;
     return ret;
 };
 
-module.exports.__wbg_versions_c71aa1626a93e0a1 = function(arg0) {
+exports.__wbg_versions_c01dfd4722a88165 = function(arg0) {
     const ret = arg0.versions;
     return ret;
 };
 
-module.exports.__wbg_wallettx_new = function(arg0) {
+exports.__wbg_wallettx_new = function(arg0) {
     const ret = WalletTx.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_wallettxout_new = function(arg0) {
+exports.__wbg_wallettxout_new = function(arg0) {
     const ret = WalletTxOut.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_wolletdescriptor_new = function(arg0) {
-    const ret = WolletDescriptor.__wrap(arg0);
+exports.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
+    const obj = arg0.original;
+    if (obj.cnt-- == 1) {
+        obj.a = 0;
+        return true;
+    }
+    const ret = false;
     return ret;
 };
 
-module.exports.__wbg_writable_169515f8aae06da5 = function(arg0) {
-    const ret = arg0.writable;
+exports.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
+    const ret = typeof(arg0) === 'function';
     return ret;
 };
 
-module.exports.__wbg_write_311434e30ee214e5 = function(arg0, arg1) {
-    const ret = arg0.write(arg1);
+exports.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
     return ret;
 };
 
-module.exports.__wbg_xpub_new = function(arg0) {
-    const ret = Xpub.__wrap(arg0);
+exports.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
+    const ret = typeof(arg0) === 'string';
     return ret;
 };
 
-module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
-    const ret = arg0;
+exports.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
+    const ret = arg0 === undefined;
     return ret;
 };
 
-module.exports.__wbindgen_cb_drop = function(arg0) {
-    const obj = arg0.original;
-    if (obj.cnt-- == 1) {
-        obj.a = 0;
-        return true;
-    }
-    const ret = false;
+exports.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+exports.__wbg_wolletdescriptor_new = function(arg0) {
+    const ret = WolletDescriptor.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper12924 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1371, __wbg_adapter_41);
+exports.__wbg_writable_3d863701c7ab161b = function(arg0) {
+    const ret = arg0.writable;
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper6187 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 445, __wbg_adapter_34);
+exports.__wbg_write_2e39e04a4c8c9e9d = function(arg0, arg1) {
+    const ret = arg0.write(arg1);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper6189 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 446, __wbg_adapter_34);
+exports.__wbg_xpub_new = function(arg0) {
+    const ret = Xpub.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper6191 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 446, __wbg_adapter_34);
+exports.__wbindgen_cast_085aac74eb5b1ae3 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1304, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1304, __wbg_adapter_9);
     return ret;
 };
 
-module.exports.__wbindgen_debug_string = function(arg0, arg1) {
-    const ret = debugString(arg1);
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
 };
 
-module.exports.__wbindgen_error_new = function(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
+exports.__wbindgen_cast_3a898675d43a4cee = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1304, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1304, __wbg_adapter_9);
     return ret;
 };
 
-module.exports.__wbindgen_init_externref_table = function() {
-    const table = wasm.__wbindgen_export_4;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
 };
 
-module.exports.__wbindgen_is_function = function(arg0) {
-    const ret = typeof(arg0) === 'function';
+exports.__wbindgen_cast_491f832b43cae9d3 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1922, function: Function { arguments: [Externref], shim_idx: 1933, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1922, __wbg_adapter_12);
     return ret;
 };
 
-module.exports.__wbindgen_is_object = function(arg0) {
-    const val = arg0;
-    const ret = typeof(val) === 'object' && val !== null;
+exports.__wbindgen_cast_6d461bb7b7d7177d = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 576, function: Function { arguments: [NamedExternref("HIDInputReportEvent")], shim_idx: 773, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 576, __wbg_adapter_23);
     return ret;
 };
 
-module.exports.__wbindgen_is_string = function(arg0) {
-    const ret = typeof(arg0) === 'string';
+exports.__wbindgen_cast_91897b7acd28f489 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1304, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1304, __wbg_adapter_9);
     return ret;
 };
 
-module.exports.__wbindgen_is_undefined = function(arg0) {
-    const ret = arg0 === undefined;
+exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-module.exports.__wbindgen_memory = function() {
-    const ret = wasm.memory;
+exports.__wbindgen_cast_a7d16f2d8bd2063c = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1304, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1305, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1304, __wbg_adapter_9);
     return ret;
 };
 
-module.exports.__wbindgen_number_new = function(arg0) {
-    const ret = arg0;
+exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 };
 
-module.exports.__wbindgen_string_get = function(arg0, arg1) {
-    const obj = arg1;
-    const ret = typeof(obj) === 'string' ? obj : undefined;
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+exports.__wbindgen_cast_cbe1d958a67e1e77 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1885, function: Function { arguments: [], shim_idx: 1886, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1885, __wbg_adapter_6);
+    return ret;
 };
 
-module.exports.__wbindgen_string_new = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
+exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-module.exports.__wbindgen_throw = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
+exports.__wbindgen_cast_ea7c0ccf8adb80f9 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1441, function: Function { arguments: [], shim_idx: 1442, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1441, __wbg_adapter_32);
+    return ret;
 };
 
-const path = require('path').join(__dirname, 'lwk_wasm_bg.wasm');
-const bytes = require('fs').readFileSync(path);
+exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_export_4;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
 
-const wasmModule = new WebAssembly.Module(bytes);
-const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
-wasm = wasmInstance.exports;
-module.exports.__wasm = wasm;
+const wasmPath = `${__dirname}/lwk_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
 
 wasm.__wbindgen_start();