lwk_node 0.9.0 → 0.9.2

package/lwk_wasm.js

@@ -106,6 +106,11 @@ 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 => {
@@ -208,17 +213,29 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 let cachedUint32ArrayMemory0 = null;
 
 function getUint32ArrayMemory0() {
@@ -235,16 +252,6 @@ function passArray32ToWasm0(arg, malloc) {
     return ptr;
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    const mem = getDataViewMemory0();
-    for (let i = 0; i < array.length; i++) {
-        mem.setUint32(ptr + 4 * i, addToExternrefTable0(array[i]), true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -256,23 +263,28 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
+/**
+ * @returns {Promise<HIDDevice>}
+ */
+module.exports.searchLedgerDevice = function() {
+    const ret = wasm.searchLedgerDevice();
+    return ret;
+};
+
 function __wbg_adapter_36(arg0, arg1, arg2) {
-    wasm.closure975_externref_shim(arg0, arg1, arg2);
+    wasm.closure285_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_373(arg0, arg1, arg2, arg3) {
-    wasm.closure1677_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_43(arg0, arg1, arg2) {
+    wasm.closure1171_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_481(arg0, arg1, arg2, arg3) {
+    wasm.closure1920_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -291,6 +303,8 @@ module.exports.Chain = Object.freeze({
     Internal: 1, "1": "Internal",
 });
 
+const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
@@ -324,6 +338,8 @@ class Address {
     }
     /**
      * Creates an `Address`
+     *
+     * If you know the network, you can use [`Address::parse()`] to validate that the network is consistent.
      * @param {string} s
      */
     constructor(s) {
@@ -337,6 +353,22 @@ class Address {
         AddressFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Parses an `Address` ensuring is for the right network
+     * @param {string} s
+     * @param {Network} network
+     * @returns {Address}
+     */
+    static parse(s, network) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(network, Network);
+        const ret = wasm.address_parse(ptr0, len0, network.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Address.__wrap(ret[0]);
+    }
     /**
      * @returns {Script}
      */
@@ -388,7 +420,7 @@ class Address {
      * For max efficiency we suggest to pass `None` to `pixel_per_module`, get a very small image
      * and use styling to scale up the image in the browser. eg
      * `style="image-rendering: pixelated; border: 20px solid white;"`
-     * @param {number | undefined} [pixel_per_module]
+     * @param {number | null} [pixel_per_module]
      * @returns {string}
      */
     QRCodeUri(pixel_per_module) {
@@ -598,6 +630,50 @@ class Amp2Descriptor {
 }
 module.exports.Amp2Descriptor = Amp2Descriptor;
 
+const AssetAmountFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetamount_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::AssetAmount`]
+ */
+class AssetAmount {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetAmount.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetAmountFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetAmountFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetamount_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    amount() {
+        const ret = wasm.assetamount_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {AssetId}
+     */
+    asset() {
+        const ret = wasm.assetamount_asset(this.__wbg_ptr);
+        return AssetId.__wrap(ret);
+    }
+}
+module.exports.AssetAmount = AssetAmount;
+
 const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetid_free(ptr >>> 0, 1));
@@ -660,6 +736,48 @@ class AssetId {
 }
 module.exports.AssetId = AssetId;
 
+const AssetMetaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetmeta_free(ptr >>> 0, 1));
+
+class AssetMeta {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetMeta.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetMetaFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetMetaFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetmeta_free(ptr, 0);
+    }
+    /**
+     * @returns {Contract}
+     */
+    contract() {
+        const ret = wasm.assetmeta_contract(this.__wbg_ptr);
+        return Contract.__wrap(ret);
+    }
+    /**
+     * @returns {Transaction}
+     */
+    tx() {
+        const ret = wasm.assetmeta_tx(this.__wbg_ptr);
+        return Transaction.__wrap(ret);
+    }
+}
+module.exports.AssetMeta = AssetMeta;
+
 const BipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_bip_free(ptr >>> 0, 1));
@@ -854,12 +972,13 @@ class EsploraClient {
      * @param {Network} network
      * @param {string} url
      * @param {boolean} waterfalls
+     * @param {number} concurrency
      */
-    constructor(network, url, waterfalls) {
+    constructor(network, url, waterfalls, concurrency) {
         _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);
+        const ret = wasm.esploraclient_new(network.__wbg_ptr, ptr0, len0, waterfalls, concurrency);
         this.__wbg_ptr = ret >>> 0;
         EsploraClientFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -1111,26 +1230,270 @@ class Jade {
      * @param {Bip} bip
      * @returns {Promise<string>}
      */
-    keyoriginXpub(bip) {
-        _assertClass(bip, Bip);
-        var ptr0 = bip.__destroy_into_raw();
-        const ret = wasm.jade_keyoriginXpub(this.__wbg_ptr, ptr0);
+    keyoriginXpub(bip) {
+        _assertClass(bip, Bip);
+        const ret = wasm.jade_keyoriginXpub(this.__wbg_ptr, bip.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} name
+     * @param {WolletDescriptor} desc
+     * @returns {Promise<boolean>}
+     */
+    registerDescriptor(name, desc) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(desc, WolletDescriptor);
+        const ret = wasm.jade_registerDescriptor(this.__wbg_ptr, ptr0, len0, desc.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.Jade = Jade;
+
+const JadeWebSocketFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jadewebsocket_free(ptr >>> 0, 1));
+/**
+ * WebSocket-based Wrapper of [`asyncr::Jade`]
+ */
+class JadeWebSocket {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(JadeWebSocket.prototype);
+        obj.__wbg_ptr = ptr;
+        JadeWebSocketFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JadeWebSocketFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jadewebsocket_free(ptr, 0);
+    }
+    /**
+     * Creates a Jade from WebSocket for the given network
+     *
+     * The url should point to your WebSocket bridge that connects to the Docker Jade emulator
+     * @param {Network} network
+     * @param {string} url
+     */
+    constructor(network, url) {
+        _assertClass(network, Network);
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jadewebsocket_from_websocket(network.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    getVersion() {
+        const ret = wasm.jadewebsocket_getVersion(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<Xpub>}
+     */
+    getMasterXpub() {
+        const ret = wasm.jadewebsocket_getMasterXpub(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Return a single sig address with the given `variant` and `path` derivation
+     * @param {Singlesig} variant
+     * @param {Uint32Array} path
+     * @returns {Promise<string>}
+     */
+    getReceiveAddressSingle(variant, path) {
+        _assertClass(variant, Singlesig);
+        var ptr0 = variant.__destroy_into_raw();
+        const ptr1 = passArray32ToWasm0(path, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jadewebsocket_getReceiveAddressSingle(this.__wbg_ptr, ptr0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Return a multisig address of a registered `multisig_name` wallet
+     *
+     * This method accept `path` and `path_n` in place of a single `Vec<Vec<u32>>` because the
+     * latter is not supported by wasm_bindgen (and neither `(u32, Vec<u32>)`). `path` and `path_n`
+     * are converted internally to a `Vec<Vec<u32>>` with the caveat all the paths are the same,
+     * which is almost always the case.
+     * @param {string} multisig_name
+     * @param {Uint32Array} path
+     * @returns {Promise<string>}
+     */
+    getReceiveAddressMulti(multisig_name, path) {
+        const ptr0 = passStringToWasm0(multisig_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(path, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jadewebsocket_getReceiveAddressMulti(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        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.jadewebsocket_sign(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<WolletDescriptor>}
+     */
+    wpkh() {
+        const ret = wasm.jadewebsocket_wpkh(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<WolletDescriptor>}
+     */
+    shWpkh() {
+        const ret = wasm.jadewebsocket_shWpkh(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} name
+     * @returns {Promise<WolletDescriptor>}
+     */
+    multi(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jadewebsocket_multi(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    getRegisteredMultisigs() {
+        const ret = wasm.jadewebsocket_getRegisteredMultisigs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Bip} bip
+     * @returns {Promise<string>}
+     */
+    keyoriginXpub(bip) {
+        _assertClass(bip, Bip);
+        const ret = wasm.jadewebsocket_keyoriginXpub(this.__wbg_ptr, bip.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} name
+     * @param {WolletDescriptor} desc
+     * @returns {Promise<boolean>}
+     */
+    registerDescriptor(name, desc) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(desc, WolletDescriptor);
+        const ret = wasm.jadewebsocket_registerDescriptor(this.__wbg_ptr, ptr0, len0, desc.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.JadeWebSocket = JadeWebSocket;
+
+const LedgerWebFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ledgerweb_free(ptr >>> 0, 1));
+
+class LedgerWeb {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        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;
     }
     /**
-     * @param {string} name
-     * @param {WolletDescriptor} desc
-     * @returns {Promise<boolean>}
+     * Return a single sig address with the given `variant` and `index`
+     * @param {number} index
+     * @returns {Promise<string>}
      */
-    registerDescriptor(name, desc) {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(desc, WolletDescriptor);
-        const ret = wasm.jade_registerDescriptor(this.__wbg_ptr, ptr0, len0, desc.__wbg_ptr);
+    getReceiveAddressSingle(index) {
+        const ret = wasm.ledgerweb_getReceiveAddressSingle(this.__wbg_ptr, index);
         return ret;
     }
 }
-module.exports.Jade = Jade;
+module.exports.LedgerWeb = LedgerWeb;
 
 const MnemonicFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1272,7 +1635,7 @@ class Network {
         return Network.__wrap(ret);
     }
     /**
-     * Creates the default regtest `Network`
+     * Creates the default regtest `Network` with the policy asset `5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225`
      * @returns {Network}
      */
     static regtestDefault() {
@@ -1293,6 +1656,20 @@ class Network {
         const ret = wasm.network_isMainnet(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @returns {boolean}
+     */
+    isTestnet() {
+        const ret = wasm.network_isTestnet(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isRegtest() {
+        const ret = wasm.network_isRegtest(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {string}
      */
@@ -1587,7 +1964,7 @@ class Pset {
         }
     }
     /**
-     * @returns {(PsetInput)[]}
+     * @returns {PsetInput[]}
      */
     inputs() {
         const ret = wasm.pset_inputs(this.__wbg_ptr);
@@ -1595,6 +1972,15 @@ class Pset {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * @returns {PsetOutput[]}
+     */
+    outputs() {
+        const ret = wasm.pset_outputs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
 }
 module.exports.Pset = Pset;
 
@@ -1644,7 +2030,7 @@ class PsetBalance {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {(Recipient)[]}
+     * @returns {Recipient[]}
      */
     recipients() {
         const ret = wasm.psetbalance_recipients(this.__wbg_ptr);
@@ -1691,7 +2077,7 @@ class PsetDetails {
     }
     /**
      * For each input existing or missing signatures
-     * @returns {(PsetSignatures)[]}
+     * @returns {PsetSignatures[]}
      */
     signatures() {
         const ret = wasm.psetdetails_signatures(this.__wbg_ptr);
@@ -1700,7 +2086,7 @@ class PsetDetails {
         return v1;
     }
     /**
-     * @returns {(string)[]}
+     * @returns {string[]}
      */
     fingerprintsMissing() {
         const ret = wasm.psetdetails_fingerprintsMissing(this.__wbg_ptr);
@@ -1709,7 +2095,7 @@ class PsetDetails {
         return v1;
     }
     /**
-     * @returns {(string)[]}
+     * @returns {string[]}
      */
     fingerprintsHas() {
         const ret = wasm.psetdetails_fingerprintsHas(this.__wbg_ptr);
@@ -1719,7 +2105,7 @@ class PsetDetails {
     }
     /**
      * Return an element for every input that could possibly be a issuance or a reissuance
-     * @returns {(Issuance)[]}
+     * @returns {Issuance[]}
      */
     inputsIssuances() {
         const ret = wasm.psetdetails_inputsIssuances(this.__wbg_ptr);
@@ -1792,6 +2178,43 @@ class PsetInput {
 }
 module.exports.PsetInput = PsetInput;
 
+const PsetOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_psetoutput_free(ptr >>> 0, 1));
+/**
+ * PSET output
+ */
+class PsetOutput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PsetOutput.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetOutputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_psetoutput_free(ptr, 0);
+    }
+    /**
+     * @returns {Script}
+     */
+    script_pubkey() {
+        const ret = wasm.psetoutput_script_pubkey(this.__wbg_ptr);
+        return Script.__wrap(ret);
+    }
+}
+module.exports.PsetOutput = PsetOutput;
+
 const PsetSignaturesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_psetsignatures_free(ptr >>> 0, 1));
@@ -1895,6 +2318,128 @@ class Recipient {
 }
 module.exports.Recipient = Recipient;
 
+const RegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_registry_free(ptr >>> 0, 1));
+
+class Registry {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Registry.prototype);
+        obj.__wbg_ptr = ptr;
+        RegistryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RegistryFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_registry_free(ptr, 0);
+    }
+    /**
+     * @param {string} url
+     * @returns {Registry}
+     */
+    static new(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.registry_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Registry.__wrap(ret[0]);
+    }
+    /**
+     * @param {Network} network
+     * @returns {Registry}
+     */
+    static defaultForNetwork(network) {
+        _assertClass(network, Network);
+        const ret = wasm.registry_defaultForNetwork(network.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Registry.__wrap(ret[0]);
+    }
+    /**
+     * @param {AssetId} asset_id
+     * @param {EsploraClient} client
+     * @returns {Promise<AssetMeta>}
+     */
+    fetchWithTx(asset_id, client) {
+        _assertClass(asset_id, AssetId);
+        _assertClass(client, EsploraClient);
+        const ret = wasm.registry_fetchWithTx(this.__wbg_ptr, asset_id.__wbg_ptr, client.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {RegistryPost} data
+     * @returns {Promise<void>}
+     */
+    post(data) {
+        _assertClass(data, RegistryPost);
+        const ret = wasm.registry_post(this.__wbg_ptr, data.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.Registry = Registry;
+
+const RegistryPostFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_registrypost_free(ptr >>> 0, 1));
+
+class RegistryPost {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RegistryPostFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_registrypost_free(ptr, 0);
+    }
+    /**
+     * @param {Contract} contract
+     * @param {AssetId} asset_id
+     */
+    constructor(contract, asset_id) {
+        _assertClass(contract, Contract);
+        var ptr0 = contract.__destroy_into_raw();
+        _assertClass(asset_id, AssetId);
+        var ptr1 = asset_id.__destroy_into_raw();
+        const ret = wasm.registrypost_new(ptr0, ptr1);
+        this.__wbg_ptr = ret >>> 0;
+        RegistryPostFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.registrypost_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.RegistryPost = RegistryPost;
+
 const ScriptFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_script_free(ptr >>> 0, 1));
@@ -2028,6 +2573,31 @@ class Signer {
         }
         return Pset.__wrap(ret[0]);
     }
+    /**
+     * Sign a message with the master key, return the signature as a base64 string
+     * @param {string} message
+     * @returns {string}
+     */
+    signMessage(message) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.signer_signMessage(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * @returns {WolletDescriptor}
      */
@@ -2053,23 +2623,22 @@ class Signer {
      * @returns {string}
      */
     keyoriginXpub(bip) {
-        let deferred3_0;
-        let deferred3_1;
+        let deferred2_0;
+        let deferred2_1;
         try {
             _assertClass(bip, Bip);
-            var ptr0 = bip.__destroy_into_raw();
-            const ret = wasm.signer_keyoriginXpub(this.__wbg_ptr, ptr0);
-            var ptr2 = ret[0];
-            var len2 = ret[1];
+            const ret = wasm.signer_keyoriginXpub(this.__wbg_ptr, bip.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
             if (ret[3]) {
-                ptr2 = 0; len2 = 0;
+                ptr1 = 0; len1 = 0;
                 throw takeFromExternrefTable0(ret[2]);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
-            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
     /**
@@ -2324,7 +2893,7 @@ class TxBuilder {
     }
     /**
      * Set the fee rate
-     * @param {number | undefined} [fee_rate]
+     * @param {number | null} [fee_rate]
      * @returns {TxBuilder}
      */
     feeRate(fee_rate) {
@@ -2404,10 +2973,10 @@ class TxBuilder {
     /**
      * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
      * @param {bigint} asset_sats
-     * @param {Address | undefined} asset_receiver
+     * @param {Address | null | undefined} asset_receiver
      * @param {bigint} token_sats
-     * @param {Address | undefined} [token_receiver]
-     * @param {Contract | undefined} [contract]
+     * @param {Address | null} [token_receiver]
+     * @param {Contract | null} [contract]
      * @returns {TxBuilder}
      */
     issueAsset(asset_sats, asset_receiver, token_sats, token_receiver, contract) {
@@ -2437,8 +3006,8 @@ class TxBuilder {
      * Reissue an asset, wrapper of [`lwk_wollet::TxBuilder::reissue_asset()`]
      * @param {AssetId} asset_to_reissue
      * @param {bigint} satoshi_to_reissue
-     * @param {Address | undefined} [asset_receiver]
-     * @param {Transaction | undefined} [issuance_tx]
+     * @param {Address | null} [asset_receiver]
+     * @param {Transaction | null} [issuance_tx]
      * @returns {TxBuilder}
      */
     reissueAsset(asset_to_reissue, satoshi_to_reissue, asset_receiver, issuance_tx) {
@@ -2463,7 +3032,7 @@ class TxBuilder {
     }
     /**
      * Manual coin selection, wrapper of [`lwk_wollet::TxBuilder::set_wallet_utxos()`]
-     * @param {(OutPoint)[]} outpoints
+     * @param {OutPoint[]} outpoints
      * @returns {TxBuilder}
      */
     setWalletUtxos(outpoints) {
@@ -2488,6 +3057,41 @@ class TxBuilder {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {OutPoint} utxo
+     * @param {Address} address
+     * @param {bigint} satoshi
+     * @param {AssetId} asset_id
+     * @returns {TxBuilder}
+     */
+    liquidexMake(utxo, address, satoshi, asset_id) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(utxo, OutPoint);
+        var ptr0 = utxo.__destroy_into_raw();
+        _assertClass(address, Address);
+        var ptr1 = address.__destroy_into_raw();
+        _assertClass(asset_id, AssetId);
+        var ptr2 = asset_id.__destroy_into_raw();
+        const ret = wasm.txbuilder_liquidexMake(ptr, ptr0, ptr1, satoshi, ptr2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
+    /**
+     * @param {ValidatedLiquidexProposal[]} proposals
+     * @returns {TxBuilder}
+     */
+    liquidexTake(proposals) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passArrayJsValueToWasm0(proposals, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.txbuilder_liquidexTake(ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
 }
 module.exports.TxBuilder = TxBuilder;
 
@@ -2550,11 +3154,73 @@ class TxOutSecrets {
     /**
      * @returns {string}
      */
-    valueBlindingFactor() {
+    valueBlindingFactor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txoutsecrets_valueBlindingFactor(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.TxOutSecrets = TxOutSecrets;
+
+const TxidFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txid_free(ptr >>> 0, 1));
+/**
+ * A valid transaction identifier.
+ *
+ * 32 bytes encoded as hex string.
+ */
+class Txid {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Txid.prototype);
+        obj.__wbg_ptr = ptr;
+        TxidFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxidFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txid_free(ptr, 0);
+    }
+    /**
+     * Creates a `Txid`
+     * @param {string} tx_id
+     */
+    constructor(tx_id) {
+        const ptr0 = passStringToWasm0(tx_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.txid_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TxidFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.txoutsecrets_valueBlindingFactor(this.__wbg_ptr);
+            const ret = wasm.txid_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2563,51 +3229,85 @@ class TxOutSecrets {
         }
     }
 }
-module.exports.TxOutSecrets = TxOutSecrets;
+module.exports.Txid = Txid;
 
-const TxidFinalization = (typeof FinalizationRegistry === 'undefined')
+const UnvalidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_txid_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_unvalidatedliquidexproposal_free(ptr >>> 0, 1));
 /**
- * A valid transaction identifier.
- *
- * 32 bytes encoded as hex string.
+ * Wrapper of [`lwk_wollet::LiquidexProposal<Unvalidated>`]
  */
-class Txid {
+class UnvalidatedLiquidexProposal {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Txid.prototype);
+        const obj = Object.create(UnvalidatedLiquidexProposal.prototype);
         obj.__wbg_ptr = ptr;
-        TxidFinalization.register(obj, obj.__wbg_ptr, obj);
+        UnvalidatedLiquidexProposalFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TxidFinalization.unregister(this);
+        UnvalidatedLiquidexProposalFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_txid_free(ptr, 0);
+        wasm.__wbg_unvalidatedliquidexproposal_free(ptr, 0);
     }
     /**
-     * Creates a `Txid`
-     * @param {string} tx_id
+     * @param {string} s
+     * @returns {UnvalidatedLiquidexProposal}
      */
-    constructor(tx_id) {
-        const ptr0 = passStringToWasm0(tx_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    static new(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txid_new(ptr0, len0);
+        const ret = wasm.unvalidatedliquidexproposal_new(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
-        TxidFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+        return UnvalidatedLiquidexProposal.__wrap(ret[0]);
+    }
+    /**
+     * @param {Pset} pset
+     * @returns {UnvalidatedLiquidexProposal}
+     */
+    static from_pset(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.unvalidatedliquidexproposal_from_pset(ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return UnvalidatedLiquidexProposal.__wrap(ret[0]);
+    }
+    /**
+     * @returns {ValidatedLiquidexProposal}
+     */
+    insecure_validate() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.unvalidatedliquidexproposal_insecure_validate(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValidatedLiquidexProposal.__wrap(ret[0]);
+    }
+    /**
+     * @param {Transaction} tx
+     * @returns {ValidatedLiquidexProposal}
+     */
+    validate(tx) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(tx, Transaction);
+        var ptr0 = tx.__destroy_into_raw();
+        const ret = wasm.unvalidatedliquidexproposal_validate(ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValidatedLiquidexProposal.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -2616,7 +3316,7 @@ class Txid {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.txid_toString(this.__wbg_ptr);
+            const ret = wasm.unvalidatedliquidexproposal_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2625,7 +3325,7 @@ class Txid {
         }
     }
 }
-module.exports.Txid = Txid;
+module.exports.UnvalidatedLiquidexProposal = UnvalidatedLiquidexProposal;
 
 const UpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2736,6 +3436,72 @@ class Update {
 }
 module.exports.Update = Update;
 
+const ValidatedLiquidexProposalFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_validatedliquidexproposal_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::LiquidexProposal<Validated>`]
+ */
+class ValidatedLiquidexProposal {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ValidatedLiquidexProposal.prototype);
+        obj.__wbg_ptr = ptr;
+        ValidatedLiquidexProposalFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof ValidatedLiquidexProposal)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ValidatedLiquidexProposalFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_validatedliquidexproposal_free(ptr, 0);
+    }
+    /**
+     * @returns {AssetAmount}
+     */
+    input() {
+        const ret = wasm.validatedliquidexproposal_input(this.__wbg_ptr);
+        return AssetAmount.__wrap(ret);
+    }
+    /**
+     * @returns {AssetAmount}
+     */
+    output() {
+        const ret = wasm.validatedliquidexproposal_output(this.__wbg_ptr);
+        return AssetAmount.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.validatedliquidexproposal_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.ValidatedLiquidexProposal = ValidatedLiquidexProposal;
+
 const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wallettx_free(ptr >>> 0, 1));
@@ -2824,7 +3590,7 @@ class WalletTx {
         return ret === 0x100000001 ? undefined : ret;
     }
     /**
-     * @returns {(OptionWalletTxOut)[]}
+     * @returns {OptionWalletTxOut[]}
      */
     inputs() {
         const ret = wasm.wallettx_inputs(this.__wbg_ptr);
@@ -2833,7 +3599,7 @@ class WalletTx {
         return v1;
     }
     /**
-     * @returns {(OptionWalletTxOut)[]}
+     * @returns {OptionWalletTxOut[]}
      */
     outputs() {
         const ret = wasm.wallettx_outputs(this.__wbg_ptr);
@@ -2981,7 +3747,7 @@ class Wollet {
      *
      * If Some return the address at the given index,
      * otherwise the last unused address.
-     * @param {number | undefined} [index]
+     * @param {number | null} [index]
      * @returns {AddressResult}
      */
     address(index) {
@@ -3025,7 +3791,7 @@ class Wollet {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * @returns {(WalletTx)[]}
+     * @returns {WalletTx[]}
      */
     transactions() {
         const ret = wasm.wollet_transactions(this.__wbg_ptr);
@@ -3038,7 +3804,7 @@ class Wollet {
     }
     /**
      * Get the unspent transaction outputs of the wallet
-     * @returns {(WalletTxOut)[]}
+     * @returns {WalletTxOut[]}
      */
     utxos() {
         const ret = wasm.wollet_utxos(this.__wbg_ptr);
@@ -3051,7 +3817,7 @@ class Wollet {
     }
     /**
      * Get all the transaction outputs of the wallet, both spent and unspent
-     * @returns {(WalletTxOut)[]}
+     * @returns {WalletTxOut[]}
      */
     txos() {
         const ret = wasm.wollet_txos(this.__wbg_ptr);
@@ -3182,7 +3948,7 @@ class WolletDescriptor {
     }
     /**
      * @param {number} threshold
-     * @param {(string)[]} participants
+     * @param {string[]} participants
      * @returns {WolletDescriptor}
      */
     static newMultiWshSlip77(threshold, participants) {
@@ -3313,46 +4079,71 @@ module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_abort_05026c983d86824c = function(arg0) {
+module.exports.__wbg_abort_775ef1d17fc65868 = function(arg0) {
     arg0.abort();
 };
 
-module.exports.__wbg_append_72d1635ad8643998 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+module.exports.__wbg_append_8c7dd8d641a5f01b = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-module.exports.__wbg_arrayBuffer_d0ca2ad8bda0039b = function() { return handleError(function (arg0) {
+module.exports.__wbg_arrayBuffer_d1b44c4390db422f = function() { return handleError(function (arg0) {
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_buffer_61b7ce01341d7f88 = function(arg0) {
+module.exports.__wbg_assetmeta_new = function(arg0) {
+    const ret = AssetMeta.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_buffer_09165b52af8c5237 = function(arg0) {
     const ret = arg0.buffer;
     return ret;
 };
 
-module.exports.__wbg_call_500db948e69c7330 = function() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.call(arg1, arg2);
+module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+    const ret = arg0.buffer;
     return ret;
-}, arguments) };
+};
+
+module.exports.__wbg_byteLength_1bdb96d98ab0d871 = function(arg0) {
+    const ret = arg0.byteLength;
+    return ret;
+};
 
-module.exports.__wbg_call_b0d8e36992d9900d = function() { return handleError(function (arg0, arg1) {
+module.exports.__wbg_byteOffset_d7656012e66edc5f = function(arg0) {
+    const ret = arg0.byteOffset;
+    return ret;
+};
+
+module.exports.__wbg_call_672a4d21634d4a24 = 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) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
 module.exports.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
     const ret = arg0.crypto;
     return ret;
 };
 
-module.exports.__wbg_done_f22c1561fa919baa = function(arg0) {
-    const ret = arg0.done;
+module.exports.__wbg_data_432d9c3df2630942 = function(arg0) {
+    const ret = arg0.data;
     return ret;
 };
 
-module.exports.__wbg_fetch_229368eecee9d217 = function(arg0, arg1) {
-    const ret = arg0.fetch(arg1);
+module.exports.__wbg_data_abeb242764125124 = function(arg0) {
+    const ret = arg0.data;
+    return ret;
+};
+
+module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) {
+    const ret = arg0.done;
     return ret;
 };
 
@@ -3361,7 +4152,17 @@ module.exports.__wbg_fetch_4465c2b10f21a927 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_getPorts_bcbc416782ca640e = function(arg0) {
+module.exports.__wbg_fetch_509096533071c657 = function(arg0, arg1) {
+    const ret = arg0.fetch(arg1);
+    return ret;
+};
+
+module.exports.__wbg_getDevices_916883032bafc9b1 = function(arg0) {
+    const ret = arg0.getDevices();
+    return ret;
+};
+
+module.exports.__wbg_getPorts_5e6efecc826b1a6f = function(arg0) {
     const ret = arg0.getPorts();
     return ret;
 };
@@ -3370,32 +4171,64 @@ module.exports.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return hand
     arg0.getRandomValues(arg1);
 }, arguments) };
 
-module.exports.__wbg_getWriter_dd1c7a1972bcd348 = function() { return handleError(function (arg0) {
-    const ret = arg0.getWriter();
+module.exports.__wbg_getUint8_749a77380c219f58 = function(arg0, arg1) {
+    const ret = arg0.getUint8(arg1 >>> 0);
     return ret;
-}, arguments) };
+};
 
-module.exports.__wbg_get_9aa3dff3f0266054 = function(arg0, arg1) {
-    const ret = arg0[arg1 >>> 0];
+module.exports.__wbg_getWriter_6ce182d0adc3f96b = function() { return handleError(function (arg0) {
+    const ret = arg0.getWriter();
     return ret;
-};
+}, arguments) };
 
-module.exports.__wbg_get_bbccf8970793c087 = function() { return handleError(function (arg0, arg1) {
+module.exports.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_has_94c2fc1d261bbfe9 = function() { return handleError(function (arg0, arg1) {
+module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+};
+
+module.exports.__wbg_has_a5ea9117f258a0ec = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.has(arg0, arg1);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_headers_24e3e19fe3f187c0 = function(arg0) {
+module.exports.__wbg_headers_9cb51cfd2ac780a4 = function(arg0) {
     const ret = arg0.headers;
     return ret;
 };
 
-module.exports.__wbg_instanceof_Response_d3453657e10c4300 = function(arg0) {
+module.exports.__wbg_hid_890a1b64f4c510a6 = function(arg0) {
+    const ret = arg0.hid;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_HidDevice_281d00db95a533c6 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof HIDDevice;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_Response_f2cc20d9f7dfd644 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Response;
@@ -3406,7 +4239,7 @@ module.exports.__wbg_instanceof_Response_d3453657e10c4300 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_SerialPort_859e0e152f7eb0c4 = function(arg0) {
+module.exports.__wbg_instanceof_SerialPort_cb6aa528c64488f2 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof SerialPort;
@@ -3417,7 +4250,7 @@ module.exports.__wbg_instanceof_SerialPort_859e0e152f7eb0c4 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_instanceof_Window_d2514c6a7ee7ba60 = function(arg0) {
+module.exports.__wbg_instanceof_Window_def73ea0955fc569 = function(arg0) {
     let result;
     try {
         result = arg0 instanceof Window;
@@ -3428,7 +4261,7 @@ module.exports.__wbg_instanceof_Window_d2514c6a7ee7ba60 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_isArray_1ba11a930108ec51 = function(arg0) {
+module.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 };
@@ -3438,7 +4271,7 @@ module.exports.__wbg_issuance_new = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_iterator_23604bb983791576 = function() {
+module.exports.__wbg_iterator_9a24c88df860dc65 = function() {
     const ret = Symbol.iterator;
     return ret;
 };
@@ -3448,49 +4281,53 @@ module.exports.__wbg_jade_new = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_length_65d1cd11729ced11 = function(arg0) {
+module.exports.__wbg_jadewebsocket_new = function(arg0) {
+    const ret = JadeWebSocket.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_length_a446193dc22c12f8 = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-module.exports.__wbg_length_d65cf0786bfc5739 = function(arg0) {
+module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
+module.exports.__wbg_log_9366f8b8b59e9e2e = function(arg0, arg1) {
+    console.log(getStringFromWasm0(arg0, arg1));
+};
+
 module.exports.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
     const ret = arg0.msCrypto;
     return ret;
 };
 
-module.exports.__wbg_navigator_0fe968937104eaa7 = function(arg0) {
+module.exports.__wbg_navigator_1577371c070c8947 = function(arg0) {
     const ret = arg0.navigator;
     return ret;
 };
 
-module.exports.__wbg_new_254fa9eac11932ae = function() {
-    const ret = new Array();
-    return ret;
-};
-
-module.exports.__wbg_new_2deffdefb590e47b = function() { return handleError(function (arg0) {
-    const ret = new ReadableStreamDefaultReader(arg0);
+module.exports.__wbg_new_018dcc2d6c8c2f6a = function() { return handleError(function () {
+    const ret = new Headers();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_new_35d748855c4620b9 = function() { return handleError(function () {
-    const ret = new Headers();
+module.exports.__wbg_new_22a36452a23e0e6f = function() { return handleError(function (arg0) {
+    const ret = new ReadableStreamDefaultReader(arg0);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_new_3d446df9155128ef = function(arg0, arg1) {
+module.exports.__wbg_new_23a2665fac83c611 = 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_373(a, state0.b, arg0, arg1);
+                return __wbg_adapter_481(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -3502,71 +4339,96 @@ module.exports.__wbg_new_3d446df9155128ef = function(arg0, arg1) {
     }
 };
 
-module.exports.__wbg_new_3ff5b33b1ce712df = function(arg0) {
-    const ret = new Uint8Array(arg0);
+module.exports.__wbg_new_405e22f390576ce2 = function() {
+    const ret = new Object();
     return ret;
 };
 
-module.exports.__wbg_new_5f48f21d4be11586 = function() { return handleError(function () {
-    const ret = new AbortController();
+module.exports.__wbg_new_5e0be73521bc8c17 = function() {
+    const ret = new Map();
     return ret;
-}, arguments) };
+};
 
-module.exports.__wbg_new_688846f374351c92 = function() {
-    const ret = new Object();
+module.exports.__wbg_new_78feb108b6472713 = function() {
+    const ret = new Array();
     return ret;
 };
 
-module.exports.__wbg_new_bc96c6a1c0786643 = function() {
-    const ret = new Map();
+module.exports.__wbg_new_92c54fc74574ef55 = function() { return handleError(function (arg0, arg1) {
+    const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_new_a12002a7f91c75be = function(arg0) {
+    const ret = new Uint8Array(arg0);
     return ret;
 };
 
-module.exports.__wbg_newnoargs_fd9e4bf8be2bc16d = function(arg0, arg1) {
+module.exports.__wbg_new_e25e5aab09ff45db = function() { return handleError(function () {
+    const ret = new AbortController();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
     const ret = new Function(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-module.exports.__wbg_newwithbyteoffsetandlength_ba35896968751d91 = function(arg0, arg1, arg2) {
+module.exports.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
     const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_newwithlength_34ce8f1051e74449 = function(arg0) {
+module.exports.__wbg_newwithlength_a381634e90c276d4 = function(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_newwithstrandinit_a1f6583f20e4faff = function() { return handleError(function (arg0, arg1, arg2) {
+module.exports.__wbg_newwithstrandinit_06c535e0a867c635 = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_next_01dd9234a5bf6d05 = function() { return handleError(function (arg0) {
-    const ret = arg0.next();
-    return ret;
-}, arguments) };
-
-module.exports.__wbg_next_137428deb98342b0 = function(arg0) {
+module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
     const ret = arg0.next;
     return ret;
 };
 
+module.exports.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments) };
+
 module.exports.__wbg_node_02999533c4ea02e3 = function(arg0) {
     const ret = arg0.node;
     return ret;
 };
 
-module.exports.__wbg_now_64d0bb151e5d3889 = function() {
+module.exports.__wbg_now_807e54c39636c349 = function() {
     const ret = Date.now();
     return ret;
 };
 
-module.exports.__wbg_open_c0755c79d6623261 = function(arg0, arg1) {
+module.exports.__wbg_now_d18023d54d4e5500 = function(arg0) {
+    const ret = arg0.now();
+    return ret;
+};
+
+module.exports.__wbg_open_a95fae7936477724 = function(arg0) {
+    const ret = arg0.open();
+    return ret;
+};
+
+module.exports.__wbg_open_cdb62e879602b6c4 = function(arg0, arg1) {
     const ret = arg0.open(arg1);
     return ret;
 };
 
+module.exports.__wbg_opened_1fee39ed52b14681 = function(arg0) {
+    const ret = arg0.opened;
+    return ret;
+};
+
 module.exports.__wbg_optionwallettxout_new = function(arg0) {
     const ret = OptionWalletTxOut.__wrap(arg0);
     return ret;
@@ -3577,6 +4439,11 @@ module.exports.__wbg_outpoint_unwrap = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_performance_c185c0cdc2766575 = function(arg0) {
+    const ret = arg0.performance;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
 module.exports.__wbg_process_5c1d670bc53614b8 = function(arg0) {
     const ret = arg0.process;
     return ret;
@@ -3592,16 +4459,21 @@ module.exports.__wbg_psetinput_new = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_psetoutput_new = function(arg0) {
+    const ret = PsetOutput.__wrap(arg0);
+    return ret;
+};
+
 module.exports.__wbg_psetsignatures_new = function(arg0) {
     const ret = PsetSignatures.__wrap(arg0);
     return ret;
 };
 
-module.exports.__wbg_queueMicrotask_2181040e064c0dc8 = function(arg0) {
+module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
     queueMicrotask(arg0);
 };
 
-module.exports.__wbg_queueMicrotask_ef9ac43769cbcc4f = function(arg0) {
+module.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
 };
@@ -3610,12 +4482,12 @@ module.exports.__wbg_randomFillSync_ab2cfe79ebbf2740 = function() { return handl
     arg0.randomFillSync(arg1);
 }, arguments) };
 
-module.exports.__wbg_read_4d173e86f707008c = function(arg0) {
+module.exports.__wbg_read_a2434af1186cb56c = function(arg0) {
     const ret = arg0.read();
     return ret;
 };
 
-module.exports.__wbg_readable_6f2f0016480ce261 = function(arg0) {
+module.exports.__wbg_readable_dbb91ee91d979f24 = function(arg0) {
     const ret = arg0.readable;
     return ret;
 };
@@ -3625,136 +4497,170 @@ module.exports.__wbg_recipient_new = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_requestPort_4017b10c6ed80bc9 = function(arg0, arg1) {
-    const ret = arg0.requestPort(arg1);
+module.exports.__wbg_requestDevice_b9904d52d001d64d = function(arg0, arg1) {
+    const ret = arg0.requestDevice(arg1);
     return ret;
 };
 
-module.exports.__wbg_requestPort_fd685d24d556886e = function(arg0) {
+module.exports.__wbg_requestPort_1f87c6573d65b9ff = function(arg0) {
     const ret = arg0.requestPort();
     return ret;
 };
 
+module.exports.__wbg_requestPort_f3ef84a64a129f42 = function(arg0, arg1) {
+    const ret = arg0.requestPort(arg1);
+    return ret;
+};
+
 module.exports.__wbg_require_79b1e9274cde3c87 = function() { return handleError(function () {
     const ret = module.require;
     return ret;
 }, arguments) };
 
-module.exports.__wbg_resolve_0bf7c44d641804f9 = function(arg0) {
+module.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
 };
 
-module.exports.__wbg_serial_af8521e375ee4947 = function(arg0) {
+module.exports.__wbg_sendReport_4d1024566077f413 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.sendReport(arg1, getArrayU8FromWasm0(arg2, arg3));
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_send_7c4769e24cf1d784 = function() { return handleError(function (arg0, arg1) {
+    arg0.send(arg1);
+}, arguments) };
+
+module.exports.__wbg_serial_a5487140b2fdb38f = function(arg0) {
     const ret = arg0.serial;
     return ret;
 };
 
-module.exports.__wbg_setTimeout_8d2afdcdb34b4e5a = function() { return handleError(function (arg0, arg1, arg2) {
+module.exports.__wbg_setTimeout_f2fe5af8e3debeb3 = function() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.setTimeout(arg1, arg2);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_set_1d80752d0d5f0b21 = function(arg0, arg1, arg2) {
+module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
     arg0[arg1 >>> 0] = arg2;
 };
 
-module.exports.__wbg_set_23d69db4e5c66a6e = function(arg0, arg1, arg2) {
-    arg0.set(arg1, arg2 >>> 0);
-};
-
 module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 };
 
-module.exports.__wbg_set_76818dc3c59a63d5 = function(arg0, arg1, arg2) {
+module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
+    arg0.set(arg1, arg2 >>> 0);
+};
+
+module.exports.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
     const ret = arg0.set(arg1, arg2);
     return ret;
 };
 
-module.exports.__wbg_setbaudrate_1ae9e2eeefa2bee6 = function(arg0, arg1) {
+module.exports.__wbg_setbaudrate_fe58f64af51588e8 = function(arg0, arg1) {
     arg0.baudRate = arg1 >>> 0;
 };
 
-module.exports.__wbg_setbody_64920df008e48adc = function(arg0, arg1) {
+module.exports.__wbg_setbinaryType_92fa1ffd873b327c = function(arg0, arg1) {
+    arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+};
+
+module.exports.__wbg_setbody_5923b78a95eedf29 = function(arg0, arg1) {
     arg0.body = arg1;
 };
 
-module.exports.__wbg_setcredentials_cfc15e48e3a3a535 = function(arg0, arg1) {
+module.exports.__wbg_setcredentials_c3a22f1cd105a2c6 = function(arg0, arg1) {
     arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
 };
 
-module.exports.__wbg_setfilters_6826706298fde705 = function(arg0, arg1) {
+module.exports.__wbg_setfilters_35abbff30813c430 = function(arg0, arg1) {
+    arg0.filters = arg1;
+};
+
+module.exports.__wbg_setfilters_a1e596125ae8f487 = function(arg0, arg1) {
     arg0.filters = arg1;
 };
 
-module.exports.__wbg_setheaders_4c921e8e226bdfa7 = function(arg0, arg1) {
+module.exports.__wbg_setheaders_834c0bdb6a8949ad = function(arg0, arg1) {
     arg0.headers = arg1;
 };
 
-module.exports.__wbg_setmethod_cfc7f688ba46a6be = function(arg0, arg1, arg2) {
+module.exports.__wbg_setmethod_3c5280fe5d890842 = function(arg0, arg1, arg2) {
     arg0.method = getStringFromWasm0(arg1, arg2);
 };
 
-module.exports.__wbg_setmode_cd03637eb7da01e0 = function(arg0, arg1) {
+module.exports.__wbg_setmode_5dc300b865044b65 = function(arg0, arg1) {
     arg0.mode = __wbindgen_enum_RequestMode[arg1];
 };
 
-module.exports.__wbg_setsignal_f766190d206f09e5 = function(arg0, arg1) {
+module.exports.__wbg_setoninputreport_de1916af49f98e5f = function(arg0, arg1) {
+    arg0.oninputreport = arg1;
+};
+
+module.exports.__wbg_setonmessage_6eccab530a8fb4c7 = function(arg0, arg1) {
+    arg0.onmessage = arg1;
+};
+
+module.exports.__wbg_setonopen_2da654e1f39745d5 = function(arg0, arg1) {
+    arg0.onopen = arg1;
+};
+
+module.exports.__wbg_setsignal_75b21ef3a81de905 = function(arg0, arg1) {
     arg0.signal = arg1;
 };
 
-module.exports.__wbg_signal_1fdadeba2d04660e = function(arg0) {
+module.exports.__wbg_signal_aaf9ad74119f20a4 = function(arg0) {
     const ret = arg0.signal;
     return ret;
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_0be7472e492ad3e3 = function() {
+module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_GLOBAL_THIS_1a6eb482d12c9bfb = function() {
+module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
     const ret = typeof globalThis === 'undefined' ? null : globalThis;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_SELF_1dc398a895c82351 = function() {
+module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
     const ret = typeof self === 'undefined' ? null : self;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_static_accessor_WINDOW_ae1c80c7eea8d64a = function() {
+module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-module.exports.__wbg_status_317f53bc4c7638df = function(arg0) {
+module.exports.__wbg_status_f6360336ca686bf0 = function(arg0) {
     const ret = arg0.status;
     return ret;
 };
 
-module.exports.__wbg_stringify_f4f701bc34ceda61 = function() { return handleError(function (arg0) {
+module.exports.__wbg_stringify_f7ed6987935b4a24 = function() { return handleError(function (arg0) {
     const ret = JSON.stringify(arg0);
     return ret;
 }, arguments) };
 
-module.exports.__wbg_subarray_46adeb9b86949d12 = function(arg0, arg1, arg2) {
+module.exports.__wbg_subarray_aa9065fa9dc5df96 = function(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-module.exports.__wbg_text_dfc4cb7631d2eb34 = function() { return handleError(function (arg0) {
+module.exports.__wbg_text_7805bea50de2af49 = function() { return handleError(function (arg0) {
     const ret = arg0.text();
     return ret;
 }, arguments) };
 
-module.exports.__wbg_then_0438fad860fe38e1 = function(arg0, arg1) {
+module.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
     const ret = arg0.then(arg1);
     return ret;
 };
 
-module.exports.__wbg_then_0ffafeddf0e182a4 = function(arg0, arg1, arg2) {
+module.exports.__wbg_then_48b406749878a531 = function(arg0, arg1, arg2) {
     const ret = arg0.then(arg1, arg2);
     return ret;
 };
@@ -3769,7 +4675,7 @@ module.exports.__wbg_update_new = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_url_5327bc0a41a9b085 = function(arg0, arg1) {
+module.exports.__wbg_url_ae10c34ca209681d = function(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -3777,7 +4683,12 @@ module.exports.__wbg_url_5327bc0a41a9b085 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-module.exports.__wbg_value_4c32fd138a88eee2 = function(arg0) {
+module.exports.__wbg_validatedliquidexproposal_unwrap = function(arg0) {
+    const ret = ValidatedLiquidexProposal.__unwrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
     const ret = arg0.value;
     return ret;
 };
@@ -3802,12 +4713,12 @@ module.exports.__wbg_wolletdescriptor_new = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_writable_42ec41878b656f61 = function(arg0) {
+module.exports.__wbg_writable_169515f8aae06da5 = function(arg0) {
     const ret = arg0.writable;
     return ret;
 };
 
-module.exports.__wbg_write_0aea81ae26043440 = function(arg0, arg1) {
+module.exports.__wbg_write_311434e30ee214e5 = function(arg0, arg1) {
     const ret = arg0.write(arg1);
     return ret;
 };
@@ -3837,8 +4748,23 @@ module.exports.__wbindgen_cb_drop = function(arg0) {
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper8869 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 976, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper10165 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 1172, __wbg_adapter_43);
+    return ret;
+};
+
+module.exports.__wbindgen_closure_wrapper5011 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 287, __wbg_adapter_36);
+    return ret;
+};
+
+module.exports.__wbindgen_closure_wrapper5013 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 286, __wbg_adapter_36);
+    return ret;
+};
+
+module.exports.__wbindgen_closure_wrapper5015 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 287, __wbg_adapter_36);
     return ret;
 };