lwk_node 0.8.5

package/lwk_wasm.js

@@ -0,0 +1,3907 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+let wasm;
+const { TextEncoder, TextDecoder } = require(`util`);
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    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);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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 debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function 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 passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    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;
+}
+/**
+ * @returns {Promise<HIDDevice>}
+ */
+module.exports.search_ledger_device = function() {
+    const ret = wasm.search_ledger_device();
+    return ret;
+};
+
+function __wbg_adapter_36(arg0, arg1, arg2) {
+    wasm.closure965_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_379(arg0, arg1, arg2, arg3) {
+    wasm.closure1667_externref_shim(arg0, arg1, arg2, arg3);
+}
+
+/**
+ * Wallet chain
+ * @enum {0 | 1}
+ */
+module.exports.Chain = Object.freeze({
+    /**
+     * External address, shown when asked for a payment.
+     * Wallet having a single descriptor are considered External
+     */
+    External: 0, "0": "External",
+    /**
+     * Internal address, used for the change
+     */
+    Internal: 1, "1": "Internal",
+});
+
+const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+const AddressFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_address_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`elements::Address`]
+ */
+class Address {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Address.prototype);
+        obj.__wbg_ptr = ptr;
+        AddressFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AddressFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_address_free(ptr, 0);
+    }
+    /**
+     * Creates an `Address`
+     * @param {string} s
+     */
+    constructor(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.address_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        AddressFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Script}
+     */
+    scriptPubkey() {
+        const ret = wasm.address_scriptPubkey(this.__wbg_ptr);
+        return Script.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isBlinded() {
+        const ret = wasm.address_isBlinded(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isMainnet() {
+        const ret = wasm.address_isMainnet(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Address}
+     */
+    toUnconfidential() {
+        const ret = wasm.address_toUnconfidential(this.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.address_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);
+        }
+    }
+    /**
+     * Returns a string encoding an image in a uri
+     *
+     * The string can be open in the browser or be used as `src` field in `img` in HTML
+     *
+     * 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]
+     * @returns {string}
+     */
+    QRCodeUri(pixel_per_module) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.address_QRCodeUri(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);
+        }
+    }
+    /**
+     * Returns a string of the QR code printable in a terminal environment
+     * @returns {string}
+     */
+    QRCodeText() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.address_QRCodeText(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);
+        }
+    }
+}
+module.exports.Address = Address;
+
+const AddressResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_addressresult_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::AddressResult`]
+ */
+class AddressResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AddressResult.prototype);
+        obj.__wbg_ptr = ptr;
+        AddressResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AddressResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_addressresult_free(ptr, 0);
+    }
+    /**
+     * @returns {Address}
+     */
+    address() {
+        const ret = wasm.addressresult_address(this.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    index() {
+        const ret = wasm.addressresult_index(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+module.exports.AddressResult = AddressResult;
+
+const Amp2Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp2_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::amp2::Amp2`]
+ */
+class Amp2 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp2.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp2Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp2Finalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp2_free(ptr, 0);
+    }
+    /**
+     * @returns {Amp2}
+     */
+    static new_testnet() {
+        const ret = wasm.amp2_new_testnet();
+        return Amp2.__wrap(ret);
+    }
+    /**
+     * @param {string} keyorigin_xpub
+     * @returns {Amp2Descriptor}
+     */
+    descriptor_from_str(keyorigin_xpub) {
+        const ptr0 = passStringToWasm0(keyorigin_xpub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.amp2_descriptor_from_str(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Amp2Descriptor.__wrap(ret[0]);
+    }
+    /**
+     * @param {Amp2Descriptor} desc
+     * @returns {Promise<string>}
+     */
+    register(desc) {
+        _assertClass(desc, Amp2Descriptor);
+        const ret = wasm.amp2_register(this.__wbg_ptr, desc.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Pset} pset
+     * @returns {Promise<Pset>}
+     */
+    cosign(pset) {
+        _assertClass(pset, Pset);
+        const ret = wasm.amp2_cosign(this.__wbg_ptr, pset.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.Amp2 = Amp2;
+
+const Amp2DescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp2descriptor_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::amp2::Amp2Descriptor`]
+ */
+class Amp2Descriptor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp2Descriptor.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp2DescriptorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp2DescriptorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp2descriptor_free(ptr, 0);
+    }
+    /**
+     * @returns {WolletDescriptor}
+     */
+    descriptor() {
+        const ret = wasm.amp2descriptor_descriptor(this.__wbg_ptr);
+        return WolletDescriptor.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.amp2descriptor_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.Amp2Descriptor = Amp2Descriptor;
+
+const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetid_free(ptr >>> 0, 1));
+/**
+ * A valid asset identifier. wrapper of [`elements::AssetId`]
+ *
+ * 32 bytes encoded as hex string.
+ */
+class AssetId {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetId.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetIdFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetid_free(ptr, 0);
+    }
+    /**
+     * Creates an `AssetId`
+     * @param {string} asset_id
+     */
+    constructor(asset_id) {
+        const ptr0 = passStringToWasm0(asset_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetid_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        AssetIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.assetid_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.AssetId = AssetId;
+
+const BipFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bip_free(ptr >>> 0, 1));
+/**
+ * wrapper over [`lwk_common::Bip`]
+ */
+class Bip {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Bip.prototype);
+        obj.__wbg_ptr = ptr;
+        BipFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BipFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bip_free(ptr, 0);
+    }
+    /**
+     * Creates a bip49 variant
+     * @returns {Bip}
+     */
+    static bip49() {
+        const ret = wasm.bip_bip49();
+        return Bip.__wrap(ret);
+    }
+    /**
+     * Creates a bip84 variant
+     * @returns {Bip}
+     */
+    static bip84() {
+        const ret = wasm.bip_bip84();
+        return Bip.__wrap(ret);
+    }
+    /**
+     * Creates a bip87 variant
+     * @returns {Bip}
+     */
+    static bip87() {
+        const ret = wasm.bip_bip87();
+        return Bip.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.bip_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.Bip = Bip;
+
+const ContractFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contract_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::Contract`]
+ */
+class Contract {
+
+    __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;
+    }
+    /**
+     * @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);
+        }
+    }
+}
+module.exports.Contract = Contract;
+
+const EsploraClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_esploraclient_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`asyncr::EsploraClient`]
+ */
+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 a client, wrapper of [`asyncr::EsploraClient`]
+     * @param {Network} network
+     * @param {string} url
+     * @param {boolean} waterfalls
+     */
+    constructor(network, url, waterfalls) {
+        _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);
+        this.__wbg_ptr = ret >>> 0;
+        EsploraClientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @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;
+    }
+    /**
+     * @param {Pset} pset
+     * @returns {Promise<Txid>}
+     */
+    broadcast(pset) {
+        _assertClass(pset, Pset);
+        const ret = wasm.esploraclient_broadcast(this.__wbg_ptr, pset.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} recipient
+     * @returns {Promise<void>}
+     */
+    set_waterfalls_server_recipient(recipient) {
+        const ptr0 = passStringToWasm0(recipient, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.esploraclient_set_waterfalls_server_recipient(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+module.exports.EsploraClient = EsploraClient;
+
+const IssuanceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_issuance_free(ptr >>> 0, 1));
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::Issuance`]
+ */
+class Issuance {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Issuance.prototype);
+        obj.__wbg_ptr = ptr;
+        IssuanceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IssuanceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_issuance_free(ptr, 0);
+    }
+    /**
+     * @returns {AssetId | undefined}
+     */
+    asset() {
+        const ret = wasm.issuance_asset(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+    /**
+     * @returns {AssetId | undefined}
+     */
+    token() {
+        const ret = wasm.issuance_token(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    prevVout() {
+        const ret = wasm.issuance_prevVout(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {Txid | undefined}
+     */
+    prevTxid() {
+        const ret = wasm.issuance_prevTxid(this.__wbg_ptr);
+        return ret === 0 ? undefined : Txid.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isIssuance() {
+        const ret = wasm.issuance_isIssuance(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isReissuance() {
+        const ret = wasm.issuance_isReissuance(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+module.exports.Issuance = Issuance;
+
+const JadeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jade_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`asyncr::Jade`]
+ */
+class Jade {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Jade.prototype);
+        obj.__wbg_ptr = ptr;
+        JadeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JadeFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jade_free(ptr, 0);
+    }
+    /**
+     * Creates a Jade from Web Serial for the given network
+     *
+     * When filter is true, it will filter available serial with Blockstream released chips, use
+     * false if you don't see your DYI jade
+     * @param {Network} network
+     * @param {boolean} filter
+     */
+    constructor(network, filter) {
+        _assertClass(network, Network);
+        const ret = wasm.jade_from_serial(network.__wbg_ptr, filter);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    getVersion() {
+        const ret = wasm.jade_getVersion(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<Xpub>}
+     */
+    getMasterXpub() {
+        const ret = wasm.jade_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.jade_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.jade_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.jade_sign(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<WolletDescriptor>}
+     */
+    wpkh() {
+        const ret = wasm.jade_wpkh(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<WolletDescriptor>}
+     */
+    shWpkh() {
+        const ret = wasm.jade_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.jade_multi(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    getRegisteredMultisigs() {
+        const ret = wasm.jade_getRegisteredMultisigs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @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);
+        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 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);
+    }
+    /**
+     * @param {HIDDevice} hid_device
+     */
+    constructor(hid_device) {
+        const ret = wasm.ledgerweb_new(hid_device);
+        this.__wbg_ptr = ret >>> 0;
+        LedgerWebFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    get_version() {
+        const ret = wasm.ledgerweb_get_version(this.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.LedgerWeb = LedgerWeb;
+
+const MnemonicFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mnemonic_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`bip39::Mnemonic`]
+ */
+class Mnemonic {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Mnemonic.prototype);
+        obj.__wbg_ptr = ptr;
+        MnemonicFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MnemonicFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mnemonic_free(ptr, 0);
+    }
+    /**
+     * Creates a Mnemonic
+     * @param {string} s
+     */
+    constructor(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mnemonic_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        MnemonicFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mnemonic_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);
+        }
+    }
+    /**
+     * Creates a Mnemonic from entropy, at least 16 bytes are needed.
+     * @param {Uint8Array} b
+     * @returns {Mnemonic}
+     */
+    static fromEntropy(b) {
+        const ptr0 = passArray8ToWasm0(b, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mnemonic_fromEntropy(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mnemonic.__wrap(ret[0]);
+    }
+    /**
+     * Creates a random Mnemonic of given words (12,15,18,21,24)
+     * @param {number} word_count
+     * @returns {Mnemonic}
+     */
+    static fromRandom(word_count) {
+        const ret = wasm.mnemonic_fromRandom(word_count);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Mnemonic.__wrap(ret[0]);
+    }
+}
+module.exports.Mnemonic = Mnemonic;
+
+const NetworkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_network_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::ElementsNetwork`]
+ */
+class Network {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Network.prototype);
+        obj.__wbg_ptr = ptr;
+        NetworkFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        NetworkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_network_free(ptr, 0);
+    }
+    /**
+     * Creates a mainnet `Network``
+     * @returns {Network}
+     */
+    static mainnet() {
+        const ret = wasm.network_mainnet();
+        return Network.__wrap(ret);
+    }
+    /**
+     * Creates a testnet `Network``
+     * @returns {Network}
+     */
+    static testnet() {
+        const ret = wasm.network_testnet();
+        return Network.__wrap(ret);
+    }
+    /**
+     * Creates a regtest `Network``
+     * @param {AssetId} policy_asset
+     * @returns {Network}
+     */
+    static regtest(policy_asset) {
+        _assertClass(policy_asset, AssetId);
+        const ret = wasm.network_regtest(policy_asset.__wbg_ptr);
+        return Network.__wrap(ret);
+    }
+    /**
+     * Creates the default regtest `Network`
+     * @returns {Network}
+     */
+    static regtestDefault() {
+        const ret = wasm.network_regtestDefault();
+        return Network.__wrap(ret);
+    }
+    /**
+     * @returns {EsploraClient}
+     */
+    defaultEsploraClient() {
+        const ret = wasm.network_defaultEsploraClient(this.__wbg_ptr);
+        return EsploraClient.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isMainnet() {
+        const ret = wasm.network_isMainnet(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.network_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);
+        }
+    }
+    /**
+     * @returns {AssetId}
+     */
+    policyAsset() {
+        const ret = wasm.network_policyAsset(this.__wbg_ptr);
+        return AssetId.__wrap(ret);
+    }
+    /**
+     * @returns {TxBuilder}
+     */
+    txBuilder() {
+        const ret = wasm.network_txBuilder(this.__wbg_ptr);
+        return TxBuilder.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    defaultExplorerUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.network_defaultExplorerUrl(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.Network = Network;
+
+const OptionWalletTxOutFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_optionwallettxout_free(ptr >>> 0, 1));
+/**
+ * An optional wallet transaction output. Could be None when it's not possible to unblind.
+ * It seems required by wasm_bindgen because we can't return `Vec<Option<WalletTxOut>>`
+ */
+class OptionWalletTxOut {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OptionWalletTxOut.prototype);
+        obj.__wbg_ptr = ptr;
+        OptionWalletTxOutFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OptionWalletTxOutFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_optionwallettxout_free(ptr, 0);
+    }
+    /**
+     * @returns {WalletTxOut | undefined}
+     */
+    get() {
+        const ret = wasm.optionwallettxout_get(this.__wbg_ptr);
+        return ret === 0 ? undefined : WalletTxOut.__wrap(ret);
+    }
+}
+module.exports.OptionWalletTxOut = OptionWalletTxOut;
+
+const OutPointFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_outpoint_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`elements::OutPoint`]
+ */
+class OutPoint {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OutPoint.prototype);
+        obj.__wbg_ptr = ptr;
+        OutPointFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OutPointFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_outpoint_free(ptr, 0);
+    }
+    /**
+     * Creates an `OutPoint`
+     * @param {string} s
+     */
+    constructor(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.outpoint_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        OutPointFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Txid}
+     */
+    txid() {
+        const ret = wasm.outpoint_txid(this.__wbg_ptr);
+        return Txid.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    vout() {
+        const ret = wasm.outpoint_vout(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+module.exports.OutPoint = OutPoint;
+
+const PrecisionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_precision_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_common::precision::Precision`]
+ */
+class Precision {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PrecisionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_precision_free(ptr, 0);
+    }
+    /**
+     * Creates a Precision
+     * @param {number} precision
+     */
+    constructor(precision) {
+        const ret = wasm.precision_new(precision);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PrecisionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {bigint} sats
+     * @returns {string}
+     */
+    satsToString(sats) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.precision_satsToString(this.__wbg_ptr, sats);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} sats
+     * @returns {bigint}
+     */
+    stringToSats(sats) {
+        const ptr0 = passStringToWasm0(sats, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.precision_stringToSats(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+}
+module.exports.Precision = Precision;
+
+const PsetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pset_free(ptr >>> 0, 1));
+/**
+ * Partially Signed Elements Transaction, wrapper of [`PartiallySignedTransaction`]
+ */
+class Pset {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Pset.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pset_free(ptr, 0);
+    }
+    /**
+     * Creates a `Pset`
+     * @param {string} base64
+     */
+    constructor(base64) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pset_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PsetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.pset_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);
+        }
+    }
+    /**
+     * @returns {Transaction}
+     */
+    extractTx() {
+        const ret = wasm.pset_extractTx(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Transaction.__wrap(ret[0]);
+    }
+    /**
+     * @param {Pset} other
+     */
+    combine(other) {
+        _assertClass(other, Pset);
+        var ptr0 = other.__destroy_into_raw();
+        const ret = wasm.pset_combine(this.__wbg_ptr, ptr0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {(PsetInput)[]}
+     */
+    inputs() {
+        const ret = wasm.pset_inputs(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;
+
+const PsetBalanceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_psetbalance_free(ptr >>> 0, 1));
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetBalance`]
+ */
+class PsetBalance {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PsetBalance.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetBalanceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetBalanceFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_psetbalance_free(ptr, 0);
+    }
+    /**
+     * @returns {bigint}
+     */
+    fee() {
+        const ret = wasm.psetbalance_fee(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * The net balance for every asset with respect of the wallet asking the pset details
+     * @returns {any}
+     */
+    balances() {
+        const ret = wasm.psetbalance_balances(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {(Recipient)[]}
+     */
+    recipients() {
+        const ret = wasm.psetbalance_recipients(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+module.exports.PsetBalance = PsetBalance;
+
+const PsetDetailsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_psetdetails_free(ptr >>> 0, 1));
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetDetails`]
+ */
+class PsetDetails {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PsetDetails.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetDetailsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetDetailsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_psetdetails_free(ptr, 0);
+    }
+    /**
+     * @returns {PsetBalance}
+     */
+    balance() {
+        const ret = wasm.psetdetails_balance(this.__wbg_ptr);
+        return PsetBalance.__wrap(ret);
+    }
+    /**
+     * For each input existing or missing signatures
+     * @returns {(PsetSignatures)[]}
+     */
+    signatures() {
+        const ret = wasm.psetdetails_signatures(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    fingerprintsMissing() {
+        const ret = wasm.psetdetails_fingerprintsMissing(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {(string)[]}
+     */
+    fingerprintsHas() {
+        const ret = wasm.psetdetails_fingerprintsHas(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Return an element for every input that could possibly be a issuance or a reissuance
+     * @returns {(Issuance)[]}
+     */
+    inputsIssuances() {
+        const ret = wasm.psetdetails_inputsIssuances(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+module.exports.PsetDetails = PsetDetails;
+
+const PsetInputFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_psetinput_free(ptr >>> 0, 1));
+/**
+ * PSET input
+ */
+class PsetInput {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PsetInput.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetInputFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetInputFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_psetinput_free(ptr, 0);
+    }
+    /**
+     * Prevout TXID of the input
+     * @returns {Txid}
+     */
+    previous_txid() {
+        const ret = wasm.psetinput_previous_txid(this.__wbg_ptr);
+        return Txid.__wrap(ret);
+    }
+    /**
+     * Prevout vout of the input
+     * @returns {number}
+     */
+    previous_vout() {
+        const ret = wasm.psetinput_previous_vout(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * If the input has an issuance, the asset id
+     * @returns {AssetId | undefined}
+     */
+    issuanceAsset() {
+        const ret = wasm.psetinput_issuanceAsset(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+    /**
+     * If the input has an issuance, the token id
+     * @returns {AssetId | undefined}
+     */
+    issuanceToken() {
+        const ret = wasm.psetinput_issuanceToken(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+}
+module.exports.PsetInput = PsetInput;
+
+const PsetSignaturesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_psetsignatures_free(ptr >>> 0, 1));
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetSignatures`]
+ */
+class PsetSignatures {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PsetSignatures.prototype);
+        obj.__wbg_ptr = ptr;
+        PsetSignaturesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PsetSignaturesFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_psetsignatures_free(ptr, 0);
+    }
+    /**
+     * Returns `Vec<(PublicKey, KeySource)>`
+     * @returns {any}
+     */
+    hasSignature() {
+        const ret = wasm.psetsignatures_hasSignature(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    missingSignature() {
+        const ret = wasm.psetsignatures_missingSignature(this.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.PsetSignatures = PsetSignatures;
+
+const RecipientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_recipient_free(ptr >>> 0, 1));
+/**
+ * Recipient of a PSET, in other words outputs that doesn't belong to the wallet
+ */
+class Recipient {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Recipient.prototype);
+        obj.__wbg_ptr = ptr;
+        RecipientFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RecipientFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_recipient_free(ptr, 0);
+    }
+    /**
+     * @returns {AssetId | undefined}
+     */
+    asset() {
+        const ret = wasm.recipient_asset(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    value() {
+        const ret = wasm.recipient_value(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {Address | undefined}
+     */
+    address() {
+        const ret = wasm.recipient_address(this.__wbg_ptr);
+        return ret === 0 ? undefined : Address.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    vout() {
+        const ret = wasm.recipient_vout(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+module.exports.Recipient = Recipient;
+
+const ScriptFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_script_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`elements::Script`]
+ */
+class Script {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Script.prototype);
+        obj.__wbg_ptr = ptr;
+        ScriptFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ScriptFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_script_free(ptr, 0);
+    }
+    /**
+     * Creates a `Script`
+     * @param {string} s
+     */
+    constructor(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.script_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ScriptFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    bytes() {
+        const ret = wasm.script_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    asm() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.script_asm(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}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.script_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.Script = Script;
+
+const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
+/**
+ * A Software signer, wrapper of [`lwk_signer::SwSigner`]
+ */
+class Signer {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SignerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_signer_free(ptr, 0);
+    }
+    /**
+     * Creates a `Signer`
+     * @param {Mnemonic} mnemonic
+     * @param {Network} network
+     */
+    constructor(mnemonic, network) {
+        _assertClass(mnemonic, Mnemonic);
+        _assertClass(network, Network);
+        const ret = wasm.signer_new(mnemonic.__wbg_ptr, network.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        SignerFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sign and consume the given PSET, returning the signed one
+     * @param {Pset} pset
+     * @returns {Pset}
+     */
+    sign(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.signer_sign(this.__wbg_ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pset.__wrap(ret[0]);
+    }
+    /**
+     * @returns {WolletDescriptor}
+     */
+    wpkhSlip77Descriptor() {
+        const ret = wasm.signer_wpkhSlip77Descriptor(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WolletDescriptor.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Xpub}
+     */
+    getMasterXpub() {
+        const ret = wasm.signer_getMasterXpub(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Xpub.__wrap(ret[0]);
+    }
+    /**
+     * @param {Bip} bip
+     * @returns {string}
+     */
+    keyoriginXpub(bip) {
+        let deferred3_0;
+        let deferred3_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];
+            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 {Mnemonic}
+     */
+    mnemonic() {
+        const ret = wasm.signer_mnemonic(this.__wbg_ptr);
+        return Mnemonic.__wrap(ret);
+    }
+}
+module.exports.Signer = Signer;
+
+const SinglesigFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_singlesig_free(ptr >>> 0, 1));
+
+class Singlesig {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Singlesig.prototype);
+        obj.__wbg_ptr = ptr;
+        SinglesigFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SinglesigFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_singlesig_free(ptr, 0);
+    }
+    /**
+     * @param {string} variant
+     * @returns {Singlesig}
+     */
+    static from(variant) {
+        const ptr0 = passStringToWasm0(variant, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.singlesig_from(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Singlesig.__wrap(ret[0]);
+    }
+}
+module.exports.Singlesig = Singlesig;
+
+const TipFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tip_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::Tip`]
+ */
+class Tip {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Tip.prototype);
+        obj.__wbg_ptr = ptr;
+        TipFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TipFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tip_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    height() {
+        const ret = wasm.tip_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    hash() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.tip_hash(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 | undefined}
+     */
+    timestamp() {
+        const ret = wasm.tip_timestamp(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+}
+module.exports.Tip = Tip;
+
+const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0, 1));
+/**
+ * A Liquid transaction, wrapper of [`elements::Transaction`]
+ *
+ * See [`crate::WalletTx`] for the transaction as seen from the perspective of the wallet
+ * where you can actually see unblinded amounts and tx net-balance.
+ */
+class Transaction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Transaction.prototype);
+        obj.__wbg_ptr = ptr;
+        TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransactionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transaction_free(ptr, 0);
+    }
+    /**
+     * Creates a `Transaction`
+     * @param {string} tx_hex
+     */
+    constructor(tx_hex) {
+        const ptr0 = passStringToWasm0(tx_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.transaction_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        TransactionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Txid}
+     */
+    txid() {
+        const ret = wasm.transaction_txid(this.__wbg_ptr);
+        return Txid.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    bytes() {
+        const ret = wasm.transaction_bytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {AssetId} policy_asset
+     * @returns {bigint}
+     */
+    fee(policy_asset) {
+        _assertClass(policy_asset, AssetId);
+        const ret = wasm.transaction_fee(this.__wbg_ptr, policy_asset.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.transaction_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.Transaction = Transaction;
+
+const TxBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txbuilder_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::TxBuilder`]
+ */
+class TxBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        TxBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txbuilder_free(ptr, 0);
+    }
+    /**
+     * Creates a transaction builder
+     * @param {Network} network
+     */
+    constructor(network) {
+        _assertClass(network, Network);
+        const ret = wasm.txbuilder_new(network.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        TxBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Build the transaction
+     * @param {Wollet} wollet
+     * @returns {Pset}
+     */
+    finish(wollet) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(wollet, Wollet);
+        const ret = wasm.txbuilder_finish(ptr, wollet.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pset.__wrap(ret[0]);
+    }
+    /**
+     * Set the fee rate
+     * @param {number | undefined} [fee_rate]
+     * @returns {TxBuilder}
+     */
+    feeRate(fee_rate) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.txbuilder_feeRate(ptr, isLikeNone(fee_rate) ? 0x100000001 : Math.fround(fee_rate));
+        return TxBuilder.__wrap(ret);
+    }
+    /**
+     * Select all available L-BTC inputs
+     * @returns {TxBuilder}
+     */
+    drainLbtcWallet() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.txbuilder_drainLbtcWallet(ptr);
+        return TxBuilder.__wrap(ret);
+    }
+    /**
+     * Sets the address to drain excess L-BTC to
+     * @param {Address} address
+     * @returns {TxBuilder}
+     */
+    drainLbtcTo(address) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(address, Address);
+        var ptr0 = address.__destroy_into_raw();
+        const ret = wasm.txbuilder_drainLbtcTo(ptr, ptr0);
+        return TxBuilder.__wrap(ret);
+    }
+    /**
+     * Add a recipient receiving L-BTC
+     *
+     * Errors if address's network is incompatible
+     * @param {Address} address
+     * @param {bigint} satoshi
+     * @returns {TxBuilder}
+     */
+    addLbtcRecipient(address, satoshi) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(address, Address);
+        const ret = wasm.txbuilder_addLbtcRecipient(ptr, address.__wbg_ptr, satoshi);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Add a recipient receiving the given asset
+     *
+     * Errors if address's network is incompatible
+     * @param {Address} address
+     * @param {bigint} satoshi
+     * @param {AssetId} asset
+     * @returns {TxBuilder}
+     */
+    addRecipient(address, satoshi, asset) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(address, Address);
+        _assertClass(asset, AssetId);
+        const ret = wasm.txbuilder_addRecipient(ptr, address.__wbg_ptr, satoshi, asset.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Burn satoshi units of the given asset
+     * @param {bigint} satoshi
+     * @param {AssetId} asset
+     * @returns {TxBuilder}
+     */
+    addBurn(satoshi, asset) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(asset, AssetId);
+        const ret = wasm.txbuilder_addBurn(ptr, satoshi, asset.__wbg_ptr);
+        return TxBuilder.__wrap(ret);
+    }
+    /**
+     * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
+     * @param {bigint} asset_sats
+     * @param {Address | undefined} asset_receiver
+     * @param {bigint} token_sats
+     * @param {Address | undefined} [token_receiver]
+     * @param {Contract | undefined} [contract]
+     * @returns {TxBuilder}
+     */
+    issueAsset(asset_sats, asset_receiver, token_sats, token_receiver, contract) {
+        const ptr = this.__destroy_into_raw();
+        let ptr0 = 0;
+        if (!isLikeNone(asset_receiver)) {
+            _assertClass(asset_receiver, Address);
+            ptr0 = asset_receiver.__destroy_into_raw();
+        }
+        let ptr1 = 0;
+        if (!isLikeNone(token_receiver)) {
+            _assertClass(token_receiver, Address);
+            ptr1 = token_receiver.__destroy_into_raw();
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(contract)) {
+            _assertClass(contract, Contract);
+            ptr2 = contract.__destroy_into_raw();
+        }
+        const ret = wasm.txbuilder_issueAsset(ptr, asset_sats, ptr0, token_sats, ptr1, ptr2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
+    /**
+     * 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]
+     * @returns {TxBuilder}
+     */
+    reissueAsset(asset_to_reissue, satoshi_to_reissue, asset_receiver, issuance_tx) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(asset_to_reissue, AssetId);
+        var ptr0 = asset_to_reissue.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(asset_receiver)) {
+            _assertClass(asset_receiver, Address);
+            ptr1 = asset_receiver.__destroy_into_raw();
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(issuance_tx)) {
+            _assertClass(issuance_tx, Transaction);
+            ptr2 = issuance_tx.__destroy_into_raw();
+        }
+        const ret = wasm.txbuilder_reissueAsset(ptr, ptr0, satoshi_to_reissue, ptr1, ptr2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txbuilder_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.TxBuilder = TxBuilder;
+
+const TxOutSecretsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_txoutsecrets_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`elements::TxOutSecrets`]
+ */
+class TxOutSecrets {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TxOutSecrets.prototype);
+        obj.__wbg_ptr = ptr;
+        TxOutSecretsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TxOutSecretsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txoutsecrets_free(ptr, 0);
+    }
+    /**
+     * @returns {AssetId}
+     */
+    asset() {
+        const ret = wasm.txoutsecrets_asset(this.__wbg_ptr);
+        return AssetId.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    assetBlindingFactor() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txoutsecrets_assetBlindingFactor(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {bigint}
+     */
+    value() {
+        const ret = wasm.txoutsecrets_value(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {string}
+     */
+    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.txid_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.Txid = Txid;
+
+const UpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_update_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::Update`]
+ */
+class Update {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Update.prototype);
+        obj.__wbg_ptr = ptr;
+        UpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UpdateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_update_free(ptr, 0);
+    }
+    /**
+     * Creates an `Update`
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.update_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        UpdateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    serialize() {
+        const ret = wasm.update_serialize(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @param {WolletDescriptor} desc
+     * @returns {string}
+     */
+    serializeEncryptedBase64(desc) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            _assertClass(desc, WolletDescriptor);
+            const ret = wasm.update_serializeEncryptedBase64(this.__wbg_ptr, desc.__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);
+        }
+    }
+    /**
+     * @param {string} base64
+     * @param {WolletDescriptor} desc
+     * @returns {Update}
+     */
+    static deserializeDecryptedBase64(base64, desc) {
+        const ptr0 = passStringToWasm0(base64, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(desc, WolletDescriptor);
+        const ret = wasm.update_deserializeDecryptedBase64(ptr0, len0, desc.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Update.__wrap(ret[0]);
+    }
+    /**
+     * @returns {boolean}
+     */
+    onlyTip() {
+        const ret = wasm.update_onlyTip(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {Wollet} wollet
+     */
+    prune(wollet) {
+        _assertClass(wollet, Wollet);
+        wasm.update_prune(this.__wbg_ptr, wollet.__wbg_ptr);
+    }
+}
+module.exports.Update = Update;
+
+const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wallettx_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::WalletTx`]
+ */
+class WalletTx {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WalletTx.prototype);
+        obj.__wbg_ptr = ptr;
+        WalletTxFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WalletTxFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wallettx_free(ptr, 0);
+    }
+    /**
+     * @returns {Transaction}
+     */
+    tx() {
+        const ret = wasm.wallettx_tx(this.__wbg_ptr);
+        return Transaction.__wrap(ret);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    height() {
+        const ret = wasm.wallettx_height(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {any}
+     */
+    balance() {
+        const ret = wasm.wallettx_balance(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {Txid}
+     */
+    txid() {
+        const ret = wasm.wallettx_txid(this.__wbg_ptr);
+        return Txid.__wrap(ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    fee() {
+        const ret = wasm.wallettx_fee(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {string}
+     */
+    txType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wallettx_txType(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    timestamp() {
+        const ret = wasm.wallettx_timestamp(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {(OptionWalletTxOut)[]}
+     */
+    inputs() {
+        const ret = wasm.wallettx_inputs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {(OptionWalletTxOut)[]}
+     */
+    outputs() {
+        const ret = wasm.wallettx_outputs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {string} explorer_url
+     * @returns {string}
+     */
+    unblindedUrl(explorer_url) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(explorer_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.wallettx_unblindedUrl(this.__wbg_ptr, ptr0, len0);
+            deferred2_0 = ret[0];
+            deferred2_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+module.exports.WalletTx = WalletTx;
+
+const WalletTxOutFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wallettxout_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::WalletTxOut`]
+ */
+class WalletTxOut {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WalletTxOut.prototype);
+        obj.__wbg_ptr = ptr;
+        WalletTxOutFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WalletTxOutFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wallettxout_free(ptr, 0);
+    }
+    /**
+     * @returns {OutPoint}
+     */
+    outpoint() {
+        const ret = wasm.wallettxout_outpoint(this.__wbg_ptr);
+        return OutPoint.__wrap(ret);
+    }
+    /**
+     * @returns {Script}
+     */
+    scriptPubkey() {
+        const ret = wasm.wallettxout_scriptPubkey(this.__wbg_ptr);
+        return Script.__wrap(ret);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    height() {
+        const ret = wasm.wallettxout_height(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {TxOutSecrets}
+     */
+    unblinded() {
+        const ret = wasm.wallettxout_unblinded(this.__wbg_ptr);
+        return TxOutSecrets.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    wildcardIndex() {
+        const ret = wasm.wallettxout_wildcardIndex(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Chain}
+     */
+    extInt() {
+        const ret = wasm.wallettxout_extInt(this.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.WalletTxOut = WalletTxOut;
+
+const WolletFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wollet_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::Wollet`]
+ */
+class Wollet {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WolletFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wollet_free(ptr, 0);
+    }
+    /**
+     * Create a `Wollet`
+     * @param {Network} network
+     * @param {WolletDescriptor} descriptor
+     */
+    constructor(network, descriptor) {
+        _assertClass(network, Network);
+        _assertClass(descriptor, WolletDescriptor);
+        const ret = wasm.wollet_new(network.__wbg_ptr, descriptor.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WolletFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get a wallet address with the correspondong derivation index
+     *
+     * If Some return the address at the given index,
+     * otherwise the last unused address.
+     * @param {number | undefined} [index]
+     * @returns {AddressResult}
+     */
+    address(index) {
+        const ret = wasm.wollet_address(this.__wbg_ptr, isLikeNone(index) ? 0x100000001 : (index) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AddressResult.__wrap(ret[0]);
+    }
+    /**
+     * @param {number} index
+     * @returns {Uint32Array}
+     */
+    addressFullPath(index) {
+        const ret = wasm.wollet_addressFullPath(this.__wbg_ptr, index);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Update} update
+     */
+    applyUpdate(update) {
+        _assertClass(update, Update);
+        const ret = wasm.wollet_applyUpdate(this.__wbg_ptr, update.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    balance() {
+        const ret = wasm.wollet_balance(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {(WalletTx)[]}
+     */
+    transactions() {
+        const ret = wasm.wollet_transactions(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Finalize and consume the given PSET, returning the finalized one
+     * @param {Pset} pset
+     * @returns {Pset}
+     */
+    finalize(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.wollet_finalize(this.__wbg_ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pset.__wrap(ret[0]);
+    }
+    /**
+     * @param {Pset} pset
+     * @returns {PsetDetails}
+     */
+    psetDetails(pset) {
+        _assertClass(pset, Pset);
+        const ret = wasm.wollet_psetDetails(this.__wbg_ptr, pset.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PsetDetails.__wrap(ret[0]);
+    }
+    /**
+     * @returns {WolletDescriptor}
+     */
+    descriptor() {
+        const ret = wasm.wollet_descriptor(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WolletDescriptor.__wrap(ret[0]);
+    }
+    /**
+     * @returns {bigint}
+     */
+    status() {
+        const ret = wasm.wollet_status(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {Tip}
+     */
+    tip() {
+        const ret = wasm.wollet_tip(this.__wbg_ptr);
+        return Tip.__wrap(ret);
+    }
+    /**
+     * wraps [lwk_wollet::Wollet::never_scanned()]
+     * @returns {boolean}
+     */
+    neverScanned() {
+        const ret = wasm.wollet_neverScanned(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+module.exports.Wollet = Wollet;
+
+const WolletDescriptorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wolletdescriptor_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::WolletDescriptor`]
+ */
+class WolletDescriptor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WolletDescriptor.prototype);
+        obj.__wbg_ptr = ptr;
+        WolletDescriptorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WolletDescriptorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wolletdescriptor_free(ptr, 0);
+    }
+    /**
+     * Creates a `WolletDescriptor`
+     * @param {string} descriptor
+     */
+    constructor(descriptor) {
+        const ptr0 = passStringToWasm0(descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wolletdescriptor_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        WolletDescriptorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wolletdescriptor_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);
+        }
+    }
+    /**
+     * @param {number} threshold
+     * @param {(string)[]} participants
+     * @returns {WolletDescriptor}
+     */
+    static newMultiWshSlip77(threshold, participants) {
+        const ptr0 = passArrayJsValueToWasm0(participants, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wolletdescriptor_newMultiWshSlip77(threshold, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WolletDescriptor.__wrap(ret[0]);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isMainnet() {
+        const ret = wasm.wolletdescriptor_isMainnet(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+module.exports.WolletDescriptor = WolletDescriptor;
+
+const XpubFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_xpub_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`bip32::Xpub`]
+ */
+class Xpub {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Xpub.prototype);
+        obj.__wbg_ptr = ptr;
+        XpubFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        XpubFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_xpub_free(ptr, 0);
+    }
+    /**
+     * Creates a Mnemonic
+     * @param {string} s
+     */
+    constructor(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xpub_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        XpubFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.xpub_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);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    identifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.xpub_identifier(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}
+     */
+    fingerprint() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.xpub_fingerprint(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 true if the passed string is a valid xpub with a valid keyorigin if present
+     * @param {string} s
+     * @returns {boolean}
+     */
+    static isValidWithKeyOrigin(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.xpub_isValidWithKeyOrigin(ptr0, len0);
+        return ret !== 0;
+    }
+}
+module.exports.Xpub = Xpub;
+
+module.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;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+module.exports.__wbg_abort_05026c983d86824c = function(arg0) {
+    arg0.abort();
+};
+
+module.exports.__wbg_append_72d1635ad8643998 = 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) {
+    const ret = arg0.arrayBuffer();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_buffer_61b7ce01341d7f88 = 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);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_call_b0d8e36992d9900d = function() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    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;
+    return ret;
+};
+
+module.exports.__wbg_fetch_229368eecee9d217 = function(arg0, arg1) {
+    const ret = arg0.fetch(arg1);
+    return ret;
+};
+
+module.exports.__wbg_fetch_b335d17f45a8b5a1 = function(arg0) {
+    const ret = fetch(arg0);
+    return ret;
+};
+
+module.exports.__wbg_getDevices_e3b981f8ab3f64ca = function(arg0) {
+    const ret = arg0.getDevices();
+    return ret;
+};
+
+module.exports.__wbg_getPorts_bcbc416782ca640e = function(arg0) {
+    const ret = arg0.getPorts();
+    return ret;
+};
+
+module.exports.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments) };
+
+module.exports.__wbg_getWriter_dd1c7a1972bcd348 = function() { return handleError(function (arg0) {
+    const ret = arg0.getWriter();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_get_9aa3dff3f0266054 = function(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+};
+
+module.exports.__wbg_get_bbccf8970793c087 = 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) {
+    const ret = Reflect.has(arg0, arg1);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_headers_24e3e19fe3f187c0 = function(arg0) {
+    const ret = arg0.headers;
+    return ret;
+};
+
+module.exports.__wbg_hid_94d3748076cc70a5 = function(arg0) {
+    const ret = arg0.hid;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_HidDevice_7985a551d7ddb50b = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof HIDDevice;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_Response_d3453657e10c4300 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Response;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_SerialPort_859e0e152f7eb0c4 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof SerialPort;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_instanceof_Window_d2514c6a7ee7ba60 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Window;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+module.exports.__wbg_isArray_1ba11a930108ec51 = function(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+};
+
+module.exports.__wbg_issuance_new = function(arg0) {
+    const ret = Issuance.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_iterator_23604bb983791576 = function() {
+    const ret = Symbol.iterator;
+    return ret;
+};
+
+module.exports.__wbg_jade_new = function(arg0) {
+    const ret = Jade.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_length_65d1cd11729ced11 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+module.exports.__wbg_length_d65cf0786bfc5739 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+module.exports.__wbg_log_5f82480ac7a101b6 = function(arg0, arg1) {
+    console.log(arg0, arg1);
+};
+
+module.exports.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+};
+
+module.exports.__wbg_navigator_0fe968937104eaa7 = 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);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_new_35d748855c4620b9 = function() { return handleError(function () {
+    const ret = new Headers();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_new_3d446df9155128ef = 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_379(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
+module.exports.__wbg_new_3ff5b33b1ce712df = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+module.exports.__wbg_new_5f48f21d4be11586 = function() { return handleError(function () {
+    const ret = new AbortController();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_new_688846f374351c92 = function() {
+    const ret = new Object();
+    return ret;
+};
+
+module.exports.__wbg_new_bc96c6a1c0786643 = function() {
+    const ret = new Map();
+    return ret;
+};
+
+module.exports.__wbg_newnoargs_fd9e4bf8be2bc16d = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+module.exports.__wbg_newwithbyteoffsetandlength_ba35896968751d91 = function(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+module.exports.__wbg_newwithlength_34ce8f1051e74449 = function(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+};
+
+module.exports.__wbg_newwithstrandinit_a1f6583f20e4faff = 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) {
+    const ret = arg0.next;
+    return ret;
+};
+
+module.exports.__wbg_node_02999533c4ea02e3 = function(arg0) {
+    const ret = arg0.node;
+    return ret;
+};
+
+module.exports.__wbg_now_64d0bb151e5d3889 = function() {
+    const ret = Date.now();
+    return ret;
+};
+
+module.exports.__wbg_open_c0755c79d6623261 = function(arg0, arg1) {
+    const ret = arg0.open(arg1);
+    return ret;
+};
+
+module.exports.__wbg_optionwallettxout_new = function(arg0) {
+    const ret = OptionWalletTxOut.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_process_5c1d670bc53614b8 = function(arg0) {
+    const ret = arg0.process;
+    return ret;
+};
+
+module.exports.__wbg_pset_new = function(arg0) {
+    const ret = Pset.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_psetinput_new = function(arg0) {
+    const ret = PsetInput.__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) {
+    queueMicrotask(arg0);
+};
+
+module.exports.__wbg_queueMicrotask_ef9ac43769cbcc4f = function(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+};
+
+module.exports.__wbg_randomFillSync_ab2cfe79ebbf2740 = function() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments) };
+
+module.exports.__wbg_read_4d173e86f707008c = function(arg0) {
+    const ret = arg0.read();
+    return ret;
+};
+
+module.exports.__wbg_readable_6f2f0016480ce261 = function(arg0) {
+    const ret = arg0.readable;
+    return ret;
+};
+
+module.exports.__wbg_recipient_new = function(arg0) {
+    const ret = Recipient.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_requestDevice_80cf95954319a779 = function(arg0, arg1) {
+    const ret = arg0.requestDevice(arg1);
+    return ret;
+};
+
+module.exports.__wbg_requestPort_4017b10c6ed80bc9 = function(arg0, arg1) {
+    const ret = arg0.requestPort(arg1);
+    return ret;
+};
+
+module.exports.__wbg_requestPort_fd685d24d556886e = function(arg0) {
+    const ret = arg0.requestPort();
+    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) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+};
+
+module.exports.__wbg_sendReport_ebe68f3fc9930b4d = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.sendReport(arg1, getArrayU8FromWasm0(arg2, arg3));
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_serial_af8521e375ee4947 = function(arg0) {
+    const ret = arg0.serial;
+    return ret;
+};
+
+module.exports.__wbg_setTimeout_8d2afdcdb34b4e5a = 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) {
+    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) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+};
+
+module.exports.__wbg_setbaudrate_1ae9e2eeefa2bee6 = function(arg0, arg1) {
+    arg0.baudRate = arg1 >>> 0;
+};
+
+module.exports.__wbg_setbody_64920df008e48adc = function(arg0, arg1) {
+    arg0.body = arg1;
+};
+
+module.exports.__wbg_setcredentials_cfc15e48e3a3a535 = function(arg0, arg1) {
+    arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+};
+
+module.exports.__wbg_setfilters_51bbf67999aa61d4 = function(arg0, arg1) {
+    arg0.filters = arg1;
+};
+
+module.exports.__wbg_setfilters_6826706298fde705 = function(arg0, arg1) {
+    arg0.filters = arg1;
+};
+
+module.exports.__wbg_setheaders_4c921e8e226bdfa7 = function(arg0, arg1) {
+    arg0.headers = arg1;
+};
+
+module.exports.__wbg_setmethod_cfc7f688ba46a6be = function(arg0, arg1, arg2) {
+    arg0.method = getStringFromWasm0(arg1, arg2);
+};
+
+module.exports.__wbg_setmode_cd03637eb7da01e0 = function(arg0, arg1) {
+    arg0.mode = __wbindgen_enum_RequestMode[arg1];
+};
+
+module.exports.__wbg_setsignal_f766190d206f09e5 = function(arg0, arg1) {
+    arg0.signal = arg1;
+};
+
+module.exports.__wbg_signal_1fdadeba2d04660e = function(arg0) {
+    const ret = arg0.signal;
+    return ret;
+};
+
+module.exports.__wbg_static_accessor_GLOBAL_0be7472e492ad3e3 = function() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_GLOBAL_THIS_1a6eb482d12c9bfb = function() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_SELF_1dc398a895c82351 = function() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_static_accessor_WINDOW_ae1c80c7eea8d64a = function() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+module.exports.__wbg_status_317f53bc4c7638df = function(arg0) {
+    const ret = arg0.status;
+    return ret;
+};
+
+module.exports.__wbg_stringify_f4f701bc34ceda61 = function() { return handleError(function (arg0) {
+    const ret = JSON.stringify(arg0);
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_subarray_46adeb9b86949d12 = function(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+};
+
+module.exports.__wbg_text_dfc4cb7631d2eb34 = function() { return handleError(function (arg0) {
+    const ret = arg0.text();
+    return ret;
+}, arguments) };
+
+module.exports.__wbg_then_0438fad860fe38e1 = function(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+};
+
+module.exports.__wbg_then_0ffafeddf0e182a4 = function(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+};
+
+module.exports.__wbg_txid_new = function(arg0) {
+    const ret = Txid.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_update_new = function(arg0) {
+    const ret = Update.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_url_5327bc0a41a9b085 = function(arg0, arg1) {
+    const ret = arg1.url;
+    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);
+};
+
+module.exports.__wbg_value_4c32fd138a88eee2 = function(arg0) {
+    const ret = arg0.value;
+    return ret;
+};
+
+module.exports.__wbg_versions_c71aa1626a93e0a1 = function(arg0) {
+    const ret = arg0.versions;
+    return ret;
+};
+
+module.exports.__wbg_wallettx_new = function(arg0) {
+    const ret = WalletTx.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_wolletdescriptor_new = function(arg0) {
+    const ret = WolletDescriptor.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_writable_42ec41878b656f61 = function(arg0) {
+    const ret = arg0.writable;
+    return ret;
+};
+
+module.exports.__wbg_write_0aea81ae26043440 = function(arg0, arg1) {
+    const ret = arg0.write(arg1);
+    return ret;
+};
+
+module.exports.__wbg_xpub_new = function(arg0) {
+    const ret = Xpub.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
+    const ret = arg0;
+    return ret;
+};
+
+module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+};
+
+module.exports.__wbindgen_cb_drop = function(arg0) {
+    const obj = arg0.original;
+    if (obj.cnt-- == 1) {
+        obj.a = 0;
+        return true;
+    }
+    const ret = false;
+    return ret;
+};
+
+module.exports.__wbindgen_closure_wrapper8773 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 966, __wbg_adapter_36);
+    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);
+};
+
+module.exports.__wbindgen_error_new = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    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);
+    ;
+};
+
+module.exports.__wbindgen_is_function = function(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+module.exports.__wbindgen_is_object = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+module.exports.__wbindgen_is_string = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
+module.exports.__wbindgen_is_undefined = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+module.exports.__wbindgen_memory = function() {
+    const ret = wasm.memory;
+    return ret;
+};
+
+module.exports.__wbindgen_number_new = function(arg0) {
+    const ret = arg0;
+    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);
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+module.exports.__wbindgen_throw = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+const path = require('path').join(__dirname, 'lwk_wasm_bg.wasm');
+const bytes = require('fs').readFileSync(path);
+
+const wasmModule = new WebAssembly.Module(bytes);
+const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+wasm = wasmInstance.exports;
+module.exports.__wasm = wasm;
+
+wasm.__wbindgen_start();
+