saito-wasm 0.2.161 → 0.2.163

package/pkg/web/index.js

@@ -1,30 +1,26 @@
-import { MsgHandler } from './snippets/saito-wasm-7abf862820f718f5/js/msg_handler.js';
+import { MsgHandler } from './snippets/saito-wasm-e8d94f6fc48cc1ba/js/msg_handler.js';
 
 let wasm;
 
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+const heap = new Array(128).fill(undefined);
 
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+heap.push(undefined, null, true, false);
 
-let cachedUint8Memory0 = null;
+function getObject(idx) { return heap[idx]; }
 
-function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
-}
+let heap_next = heap.length;
 
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
 }
 
-const heap = new Array(128).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
 
 function addHeapObject(obj) {
     if (heap_next === heap.length) heap.push(heap.length + 1);
@@ -35,18 +31,22 @@ function addHeapObject(obj) {
     return idx;
 }
 
-function getObject(idx) { return heap[idx]; }
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
 }
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
 let WASM_VECTOR_LEN = 0;
@@ -223,15 +223,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 function __wbg_adapter_38(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha9b2035dcda98f3e(arg0, arg1, addHeapObject(arg2));
-}
-
-let stack_pointer = 128;
-
-function addBorrowedObject(obj) {
-    if (stack_pointer == 1) throw new Error('out of js stack');
-    heap[--stack_pointer] = obj;
-    return stack_pointer;
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf760697bf54687ef(arg0, arg1, addHeapObject(arg2));
 }
 
 function _assertClass(instance, klass) {
@@ -241,61 +233,19 @@ function _assertClass(instance, klass) {
     return instance.ptr;
 }
 
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
-}
-/**
-* @param {string} config_json
-* @param {string} private_key
-* @param {number} log_level_num
-* @param {bigint} hasten_multiplier
-* @param {boolean} delete_old_blocks
-* @returns {Promise<any>}
-*/
-export function initialize(config_json, private_key, log_level_num, hasten_multiplier, delete_old_blocks) {
-    const ret = wasm.initialize(addHeapObject(config_json), addHeapObject(private_key), log_level_num, hasten_multiplier, delete_old_blocks);
-    return takeObject(ret);
-}
-
-/**
-* @param {string} public_key
-* @param {bigint} amount
-* @param {bigint} fee
-* @param {boolean} force_merge
-* @returns {Promise<WasmTransaction>}
-*/
-export function create_transaction(public_key, amount, fee, force_merge) {
-    const ret = wasm.create_transaction(addHeapObject(public_key), amount, fee, force_merge);
-    return takeObject(ret);
-}
+let stack_pointer = 128;
 
-/**
-* @param {Array<any>} public_keys
-* @param {BigUint64Array} amounts
-* @param {bigint} fee
-* @param {boolean} _force_merge
-* @returns {Promise<WasmTransaction>}
-*/
-export function create_transaction_with_multiple_payments(public_keys, amounts, fee, _force_merge) {
-    const ret = wasm.create_transaction_with_multiple_payments(addHeapObject(public_keys), addHeapObject(amounts), fee, _force_merge);
-    return takeObject(ret);
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
 }
-
 /**
-* @param {bigint} num
-* @param {bigint} deposit
-* @param {Uint8Array} tx_msg
-* @param {bigint} fee
-* @param {string} recipient_public_key
-* @param {string} nft_type
-* @returns {Promise<WasmTransaction>}
+* @param {bigint} peer_index
+* @returns {Promise<void>}
 */
-export function create_bound_transaction(num, deposit, tx_msg, fee, recipient_public_key, nft_type) {
-    const ret = wasm.create_bound_transaction(num, deposit, addHeapObject(tx_msg), fee, addHeapObject(recipient_public_key), addHeapObject(nft_type));
+export function remove_stun_peer(peer_index) {
+    const ret = wasm.remove_stun_peer(peer_index);
     return takeObject(ret);
 }
 
@@ -314,150 +264,138 @@ export function create_send_bound_transaction(amt, slip1_utxo_key, slip2_utxo_ke
 }
 
 /**
-* @param {string} slip1_utxo_key
-* @param {string} slip2_utxo_key
-* @param {string} slip3_utxo_key
-* @param {number} left_count
-* @param {number} right_count
-* @param {Uint8Array} tx_msg
-* @returns {Promise<WasmTransaction>}
+* @param {bigint} peer_index
+* @param {string} ip
+* @returns {Promise<void>}
 */
-export function create_split_bound_transaction(slip1_utxo_key, slip2_utxo_key, slip3_utxo_key, left_count, right_count, tx_msg) {
-    const ret = wasm.create_split_bound_transaction(addHeapObject(slip1_utxo_key), addHeapObject(slip2_utxo_key), addHeapObject(slip3_utxo_key), left_count, right_count, addHeapObject(tx_msg));
+export function process_new_peer(peer_index, ip) {
+    const ret = wasm.process_new_peer(peer_index, addHeapObject(ip));
     return takeObject(ret);
 }
 
 /**
-* @param {string} nft_id_hex
-* @param {Uint8Array} tx_msg
+* @param {Array<any>} public_keys
+* @param {BigUint64Array} amounts
+* @param {bigint} fee
+* @param {boolean} _force_merge
 * @returns {Promise<WasmTransaction>}
 */
-export function create_merge_bound_transaction(nft_id_hex, tx_msg) {
-    const ptr0 = passStringToWasm0(nft_id_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.create_merge_bound_transaction(ptr0, len0, addHeapObject(tx_msg));
-    return takeObject(ret);
-}
-
-/**
-* @returns {Promise<Array<any>>}
-*/
-export function get_nft_list() {
-    const ret = wasm.get_nft_list();
+export function create_transaction_with_multiple_payments(public_keys, amounts, fee, _force_merge) {
+    const ret = wasm.create_transaction_with_multiple_payments(addHeapObject(public_keys), addHeapObject(amounts), fee, _force_merge);
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<string>}
+* @param {string} config_json
+* @param {string} private_key
+* @param {number} log_level_num
+* @param {bigint} hasten_multiplier
+* @param {boolean} delete_old_blocks
+* @returns {Promise<any>}
 */
-export function get_latest_block_hash() {
-    const ret = wasm.get_latest_block_hash();
+export function initialize(config_json, private_key, log_level_num, hasten_multiplier, delete_old_blocks) {
+    const ret = wasm.initialize(addHeapObject(config_json), addHeapObject(private_key), log_level_num, hasten_multiplier, delete_old_blocks);
     return takeObject(ret);
 }
 
 /**
-* @param {string} block_hash
-* @returns {Promise<WasmBlock>}
+* @returns {Promise<void>}
 */
-export function get_block(block_hash) {
-    const ret = wasm.get_block(addHeapObject(block_hash));
+export function start_from_received_ghost_chain() {
+    const ret = wasm.start_from_received_ghost_chain();
     return takeObject(ret);
 }
 
 /**
+* @param {Uint8Array} hash
+* @param {bigint} block_id
 * @param {bigint} peer_index
-* @param {string} ip
 * @returns {Promise<void>}
 */
-export function process_new_peer(peer_index, ip) {
-    const ret = wasm.process_new_peer(peer_index, addHeapObject(ip));
+export function process_failed_block_fetch(hash, block_id, peer_index) {
+    const ret = wasm.process_failed_block_fetch(addHeapObject(hash), block_id, peer_index);
     return takeObject(ret);
 }
 
 /**
-* @param {bigint} peer_index
 * @param {string} public_key
-* @returns {Promise<void>}
+* @param {bigint} amount
+* @param {bigint} fee
+* @param {boolean} force_merge
+* @returns {Promise<WasmTransaction>}
 */
-export function process_stun_peer(peer_index, public_key) {
-    const ret = wasm.process_stun_peer(peer_index, addHeapObject(public_key));
+export function create_transaction(public_key, amount, fee, force_merge) {
+    const ret = wasm.create_transaction(addHeapObject(public_key), amount, fee, force_merge);
     return takeObject(ret);
 }
 
 /**
+* @param {Uint8Array} buffer
+* @param {number} msg_index
 * @param {bigint} peer_index
 * @returns {Promise<void>}
 */
-export function remove_stun_peer(peer_index) {
-    const ret = wasm.remove_stun_peer(peer_index);
-    return takeObject(ret);
-}
-
-/**
-* @returns {Promise<bigint>}
-*/
-export function get_next_peer_index() {
-    const ret = wasm.get_next_peer_index();
+export function send_api_success(buffer, msg_index, peer_index) {
+    const ret = wasm.send_api_success(addHeapObject(buffer), msg_index, peer_index);
     return takeObject(ret);
 }
 
 /**
-* @param {bigint} peer_index
+* @param {bigint} threshold
 * @returns {Promise<void>}
 */
-export function process_peer_disconnection(peer_index) {
-    const ret = wasm.process_peer_disconnection(peer_index);
+export function write_issuance_file(threshold) {
+    const ret = wasm.write_issuance_file(threshold);
     return takeObject(ret);
 }
 
 /**
-* @param {Uint8Array} buffer
-* @param {bigint} peer_index
-* @returns {Promise<void>}
+* @returns {Promise<Array<any>>}
 */
-export function process_msg_buffer_from_peer(buffer, peer_index) {
-    const ret = wasm.process_msg_buffer_from_peer(addHeapObject(buffer), peer_index);
+export function get_peers() {
+    const ret = wasm.get_peers();
     return takeObject(ret);
 }
 
 /**
-* @param {Uint8Array} buffer
-* @param {Uint8Array} hash
-* @param {bigint} block_id
-* @param {bigint} peer_index
-* @returns {Promise<void>}
+* @param {bigint} num
+* @param {bigint} deposit
+* @param {Uint8Array} tx_msg
+* @param {bigint} fee
+* @param {string} recipient_public_key
+* @param {string} nft_type
+* @returns {Promise<WasmTransaction>}
 */
-export function process_fetched_block(buffer, hash, block_id, peer_index) {
-    const ret = wasm.process_fetched_block(addHeapObject(buffer), addHeapObject(hash), block_id, peer_index);
+export function create_bound_transaction(num, deposit, tx_msg, fee, recipient_public_key, nft_type) {
+    const ret = wasm.create_bound_transaction(num, deposit, addHeapObject(tx_msg), fee, addHeapObject(recipient_public_key), addHeapObject(nft_type));
     return takeObject(ret);
 }
 
 /**
-* @param {Uint8Array} hash
-* @param {bigint} block_id
-* @param {bigint} peer_index
+* @param {WasmBalanceSnapshot} snapshot
 * @returns {Promise<void>}
 */
-export function process_failed_block_fetch(hash, block_id, peer_index) {
-    const ret = wasm.process_failed_block_fetch(addHeapObject(hash), block_id, peer_index);
+export function update_from_balance_snapshot(snapshot) {
+    _assertClass(snapshot, WasmBalanceSnapshot);
+    var ptr0 = snapshot.__destroy_into_raw();
+    const ret = wasm.update_from_balance_snapshot(ptr0);
     return takeObject(ret);
 }
 
 /**
-* @param {bigint} duration_in_ms
+* @param {bigint} peer_index
 * @returns {Promise<void>}
 */
-export function process_timer_event(duration_in_ms) {
-    const ret = wasm.process_timer_event(duration_in_ms);
+export function process_peer_disconnection(peer_index) {
+    const ret = wasm.process_peer_disconnection(peer_index);
     return takeObject(ret);
 }
 
 /**
-* @param {bigint} current_time
-* @returns {Promise<void>}
+* @returns {Promise<any>}
 */
-export function process_stat_interval(current_time) {
-    const ret = wasm.process_stat_interval(current_time);
+export function get_confirmations() {
+    const ret = wasm.get_confirmations();
     return takeObject(ret);
 }
 
@@ -471,14 +409,58 @@ export function hash(buffer) {
 }
 
 /**
-* @param {Uint8Array} buffer
+* @returns {Promise<bigint>}
+*/
+export function get_next_peer_index() {
+    const ret = wasm.get_next_peer_index();
+    return takeObject(ret);
+}
+
+/**
+* @returns {Promise<string>}
+*/
+export function get_peer_stats() {
+    const ret = wasm.get_peer_stats();
+    return takeObject(ret);
+}
+
+/**
+* @param {string} key
+* @returns {boolean}
+*/
+export function is_valid_public_key(key) {
+    const ret = wasm.is_valid_public_key(addHeapObject(key));
+    return ret !== 0;
+}
+
+/**
+* @param {string} nft_id_hex
+* @param {Uint8Array} tx_msg
+* @returns {Promise<WasmTransaction>}
+*/
+export function create_merge_bound_transaction(nft_id_hex, tx_msg) {
+    const ptr0 = passStringToWasm0(nft_id_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.create_merge_bound_transaction(ptr0, len0, addHeapObject(tx_msg));
+    return takeObject(ret);
+}
+
+/**
+* @returns {Promise<boolean>}
+*/
+export function produce_block_with_gt() {
+    const ret = wasm.produce_block_with_gt();
+    return takeObject(ret);
+}
+
+/**
 * @param {string} private_key
 * @returns {string}
 */
-export function sign_buffer(buffer, private_key) {
+export function generate_public_key(private_key) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.sign_buffer(retptr, addHeapObject(buffer), addHeapObject(private_key));
+        wasm.generate_public_key(retptr, addHeapObject(private_key));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -492,97 +474,85 @@ export function sign_buffer(buffer, private_key) {
 }
 
 /**
-* @param {Uint8Array} buffer
-* @param {string} signature
-* @param {string} public_key
-* @returns {boolean}
+* @returns {Promise<WasmBlockchain>}
 */
-export function verify_signature(buffer, signature, public_key) {
-    const ret = wasm.verify_signature(addHeapObject(buffer), addHeapObject(signature), addHeapObject(public_key));
-    return ret !== 0;
+export function get_blockchain() {
+    const ret = wasm.get_blockchain();
+    return takeObject(ret);
 }
 
 /**
-* @returns {Promise<Array<any>>}
+* @param {bigint} peer_index
+* @param {string} public_key
+* @returns {Promise<void>}
 */
-export function get_peers() {
-    const ret = wasm.get_peers();
+export function process_stun_peer(peer_index, public_key) {
+    const ret = wasm.process_stun_peer(peer_index, addHeapObject(public_key));
     return takeObject(ret);
 }
 
 /**
-* @param {bigint} peer_index
-* @returns {Promise<WasmPeer | undefined>}
+* @param {Uint8Array} buffer
+* @param {string} signature
+* @param {string} public_key
+* @returns {boolean}
 */
-export function get_peer(peer_index) {
-    const ret = wasm.get_peer(peer_index);
-    return takeObject(ret);
+export function verify_signature(buffer, signature, public_key) {
+    const ret = wasm.verify_signature(addHeapObject(buffer), addHeapObject(signature), addHeapObject(public_key));
+    return ret !== 0;
 }
 
 /**
-* @param {string} public_key
-* @returns {Promise<Array<any>>}
+* @returns {Promise<string>}
 */
-export function get_account_slips(public_key) {
-    const ret = wasm.get_account_slips(addHeapObject(public_key));
+export function get_congestion_stats() {
+    const ret = wasm.get_congestion_stats();
     return takeObject(ret);
 }
 
 /**
-* @param {Array<any>} keys
-* @returns {Promise<WasmBalanceSnapshot>}
+* @returns {Promise<Array<any>>}
 */
-export function get_balance_snapshot(keys) {
-    const ret = wasm.get_balance_snapshot(addHeapObject(keys));
+export function get_nft_list() {
+    const ret = wasm.get_nft_list();
     return takeObject(ret);
 }
 
 /**
-* @param {WasmBalanceSnapshot} snapshot
+* @param {Uint8Array} buffer
+* @param {number} msg_index
+* @param {bigint} peer_index
 * @returns {Promise<void>}
 */
-export function update_from_balance_snapshot(snapshot) {
-    _assertClass(snapshot, WasmBalanceSnapshot);
-    var ptr0 = snapshot.__destroy_into_raw();
-    const ret = wasm.update_from_balance_snapshot(ptr0);
+export function send_api_call(buffer, msg_index, peer_index) {
+    const ret = wasm.send_api_call(addHeapObject(buffer), msg_index, peer_index);
     return takeObject(ret);
 }
 
 /**
-* @returns {string}
+* @param {WasmTransaction} tx
+* @returns {Promise<void>}
 */
-export function generate_private_key() {
-    const ret = wasm.generate_private_key();
+export function propagate_transaction(tx) {
+    _assertClass(tx, WasmTransaction);
+    const ret = wasm.propagate_transaction(tx.__wbg_ptr);
     return takeObject(ret);
 }
 
 /**
-* @param {string} private_key
-* @returns {string}
+* @param {string} public_key
+* @returns {Promise<Array<any>>}
 */
-export function generate_public_key(private_key) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.generate_public_key(retptr, addHeapObject(private_key));
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        var r2 = getInt32Memory0()[retptr / 4 + 2];
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+export function get_account_slips(public_key) {
+    const ret = wasm.get_account_slips(addHeapObject(public_key));
+    return takeObject(ret);
 }
 
 /**
-* @param {WasmTransaction} tx
-* @returns {Promise<void>}
+* @returns {Promise<boolean>}
 */
-export function propagate_transaction(tx) {
-    _assertClass(tx, WasmTransaction);
-    const ret = wasm.propagate_transaction(tx.__wbg_ptr);
+export function produce_block_without_gt() {
+    const ret = wasm.produce_block_without_gt();
     return takeObject(ret);
 }
 
@@ -592,152 +562,181 @@ export function propagate_transaction(tx) {
 * @param {bigint} peer_index
 * @returns {Promise<void>}
 */
-export function send_api_call(buffer, msg_index, peer_index) {
-    const ret = wasm.send_api_call(addHeapObject(buffer), msg_index, peer_index);
+export function send_api_error(buffer, msg_index, peer_index) {
+    const ret = wasm.send_api_error(addHeapObject(buffer), msg_index, peer_index);
     return takeObject(ret);
 }
 
 /**
-* @param {Uint8Array} buffer
-* @param {number} msg_index
-* @param {bigint} peer_index
+* @param {bigint} current_time
 * @returns {Promise<void>}
 */
-export function send_api_success(buffer, msg_index, peer_index) {
-    const ret = wasm.send_api_success(addHeapObject(buffer), msg_index, peer_index);
+export function process_stat_interval(current_time) {
+    const ret = wasm.process_stat_interval(current_time);
     return takeObject(ret);
 }
 
 /**
-* @param {Uint8Array} buffer
-* @param {number} msg_index
-* @param {bigint} peer_index
-* @returns {Promise<void>}
+* @param {string} slip1_utxo_key
+* @param {string} slip2_utxo_key
+* @param {string} slip3_utxo_key
+* @param {number} left_count
+* @param {number} right_count
+* @param {Uint8Array} tx_msg
+* @returns {Promise<WasmTransaction>}
 */
-export function send_api_error(buffer, msg_index, peer_index) {
-    const ret = wasm.send_api_error(addHeapObject(buffer), msg_index, peer_index);
+export function create_split_bound_transaction(slip1_utxo_key, slip2_utxo_key, slip3_utxo_key, left_count, right_count, tx_msg) {
+    const ret = wasm.create_split_bound_transaction(addHeapObject(slip1_utxo_key), addHeapObject(slip2_utxo_key), addHeapObject(slip3_utxo_key), left_count, right_count, addHeapObject(tx_msg));
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<WasmWallet>}
+* @returns {Promise<string>}
 */
-export function get_wallet() {
-    const ret = wasm.get_wallet();
+export function get_latest_block_hash() {
+    const ret = wasm.get_latest_block_hash();
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<WasmBlockchain>}
+* @returns {Promise<string>}
 */
-export function get_blockchain() {
-    const ret = wasm.get_blockchain();
+export function get_stats() {
+    const ret = wasm.get_stats();
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<Array<any>>}
+* @param {Array<any>} keys
+* @returns {Promise<WasmBalanceSnapshot>}
 */
-export function get_mempool_txs() {
-    const ret = wasm.get_mempool_txs();
+export function get_balance_snapshot(keys) {
+    const ret = wasm.get_balance_snapshot(addHeapObject(keys));
     return takeObject(ret);
 }
 
 /**
-* @param {number} major
-* @param {number} minor
-* @param {number} patch
 * @returns {Promise<void>}
 */
-export function set_wallet_version(major, minor, patch) {
-    const ret = wasm.set_wallet_version(major, minor, patch);
+export function disable_producing_blocks_by_timer() {
+    const ret = wasm.disable_producing_blocks_by_timer();
     return takeObject(ret);
 }
 
 /**
-* @param {string} key
-* @returns {boolean}
+* @returns {string}
 */
-export function is_valid_public_key(key) {
-    const ret = wasm.is_valid_public_key(addHeapObject(key));
-    return ret !== 0;
+export function generate_private_key() {
+    const ret = wasm.generate_private_key();
+    return takeObject(ret);
 }
 
 /**
-* @param {bigint} threshold
-* @returns {Promise<void>}
+* @param {string} block_hash
+* @returns {Promise<WasmBlock>}
 */
-export function write_issuance_file(threshold) {
-    const ret = wasm.write_issuance_file(threshold);
+export function get_block(block_hash) {
+    const ret = wasm.get_block(addHeapObject(block_hash));
     return takeObject(ret);
 }
 
 /**
+* @param {bigint} duration_in_ms
 * @returns {Promise<void>}
 */
-export function disable_producing_blocks_by_timer() {
-    const ret = wasm.disable_producing_blocks_by_timer();
+export function process_timer_event(duration_in_ms) {
+    const ret = wasm.process_timer_event(duration_in_ms);
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<boolean>}
+* @returns {Promise<WasmWallet>}
 */
-export function produce_block_with_gt() {
-    const ret = wasm.produce_block_with_gt();
+export function get_wallet() {
+    const ret = wasm.get_wallet();
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<boolean>}
+* @param {Uint8Array} buffer
+* @param {bigint} peer_index
+* @returns {Promise<void>}
 */
-export function produce_block_without_gt() {
-    const ret = wasm.produce_block_without_gt();
+export function process_msg_buffer_from_peer(buffer, peer_index) {
+    const ret = wasm.process_msg_buffer_from_peer(addHeapObject(buffer), peer_index);
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<string>}
+* @returns {Promise<Array<any>>}
 */
-export function get_stats() {
-    const ret = wasm.get_stats();
+export function get_mempool_txs() {
+    const ret = wasm.get_mempool_txs();
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<string>}
+* @param {number} major
+* @param {number} minor
+* @param {number} patch
+* @returns {Promise<void>}
 */
-export function get_peer_stats() {
-    const ret = wasm.get_peer_stats();
+export function set_wallet_version(major, minor, patch) {
+    const ret = wasm.set_wallet_version(major, minor, patch);
     return takeObject(ret);
 }
 
 /**
-* @returns {Promise<string>}
+* @param {Uint8Array} buffer
+* @param {string} private_key
+* @returns {string}
 */
-export function get_congestion_stats() {
-    const ret = wasm.get_congestion_stats();
-    return takeObject(ret);
+export function sign_buffer(buffer, private_key) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.sign_buffer(retptr, addHeapObject(buffer), addHeapObject(private_key));
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
-* @returns {Promise<any>}
+* @param {bigint} peer_index
+* @returns {Promise<WasmPeer | undefined>}
 */
-export function get_confirmations() {
-    const ret = wasm.get_confirmations();
+export function get_peer(peer_index) {
+    const ret = wasm.get_peer(peer_index);
     return takeObject(ret);
 }
 
 /**
+* @param {Uint8Array} buffer
+* @param {Uint8Array} hash
+* @param {bigint} block_id
+* @param {bigint} peer_index
 * @returns {Promise<void>}
 */
-export function start_from_received_ghost_chain() {
-    const ret = wasm.start_from_received_ghost_chain();
+export function process_fetched_block(buffer, hash, block_id, peer_index) {
+    const ret = wasm.process_fetched_block(addHeapObject(buffer), addHeapObject(hash), block_id, peer_index);
     return takeObject(ret);
 }
 
-function __wbg_adapter_435(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__he53ebe6ac6430729(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+function __wbg_adapter_393(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__hbc768321d477e205(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const SaitoWasmFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -787,20 +786,6 @@ export class WasmBalanceSnapshot {
         wasm.__wbg_wasmbalancesnapshot_free(ptr);
     }
     /**
-    * @returns {string}
-    */
-    get_file_name() {
-        const ret = wasm.wasmbalancesnapshot_get_file_name(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-    * @returns {Array<any>}
-    */
-    get_entries() {
-        const ret = wasm.wasmbalancesnapshot_get_entries(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
     * @param {string} str
     * @returns {WasmBalanceSnapshot}
     */
@@ -820,6 +805,20 @@ export class WasmBalanceSnapshot {
         }
     }
     /**
+    * @returns {Array<any>}
+    */
+    get_entries() {
+        const ret = wasm.wasmbalancesnapshot_get_entries(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get_file_name() {
+        const ret = wasm.wasmbalancesnapshot_get_file_name(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     * @returns {string}
     */
     to_string() {
@@ -855,45 +854,10 @@ export class WasmBlock {
         wasm.__wbg_wasmblock_free(ptr);
     }
     /**
-    */
-    constructor() {
-        const ret = wasm.wasmblock_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
-    }
-    /**
-    * @returns {Array<any>}
-    */
-    get transactions() {
-        const ret = wasm.wasmblock_get_transactions(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-    * @returns {bigint}
-    */
-    get avg_fee_per_byte() {
-        const ret = wasm.wasmblock_avg_fee_per_byte(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-    * @returns {bigint}
-    */
-    get burnfee() {
-        const ret = wasm.wasmblock_burnfee(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-    * @returns {bigint}
-    */
-    get total_fees() {
-        const ret = wasm.wasmblock_total_fees(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
     * @returns {bigint}
     */
-    get total_fees_cumulative() {
-        const ret = wasm.wasmblock_total_fees_cumulative(this.__wbg_ptr);
+    get avg_income() {
+        const ret = wasm.wasmblock_avg_income(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -906,57 +870,69 @@ export class WasmBlock {
     /**
     * @returns {bigint}
     */
-    get total_rebroadcast_slips() {
-        const ret = wasm.wasmblock_total_rebroadcast_slips(this.__wbg_ptr);
+    get total_fees() {
+        const ret = wasm.wasmblock_total_fees(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_rebroadcast_nolan() {
-        const ret = wasm.wasmblock_total_rebroadcast_nolan(this.__wbg_ptr);
+    get total_work() {
+        const ret = wasm.wasmblock_total_work(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {bigint}
+    * @param {Uint8Array} buffer
+    * @returns {any}
     */
-    get avg_nolan_rebroadcast_per_block() {
-        const ret = wasm.wasmblock_avg_nolan_rebroadcast_per_block(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    deserialize(buffer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmblock_deserialize(retptr, this.__wbg_ptr, addHeapObject(buffer));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
     * @returns {string}
     */
-    get rebroadcast_hash() {
-        const ret = wasm.wasmblock_rebroadcast_hash(this.__wbg_ptr);
+    get creator() {
+        const ret = wasm.wasmblock_get_creator(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {bigint}
+    * @param {string} key
     */
-    get avg_income() {
-        const ret = wasm.wasmblock_avg_income(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    set creator(key) {
+        wasm.wasmblock_set_creator(this.__wbg_ptr, addHeapObject(key));
     }
     /**
     * @returns {bigint}
     */
-    get avg_total_fees() {
-        const ret = wasm.wasmblock_avg_income(this.__wbg_ptr);
+    get fee_per_byte() {
+        const ret = wasm.wasmblock_fee_per_byte(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {boolean}
     */
-    get id() {
-        const ret = wasm.wasmblock_get_id(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get force_loaded() {
+        const ret = wasm.wasmblock_force_loaded(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-    * @param {bigint} id
+    * @returns {string}
     */
-    set id(id) {
-        wasm.wasmblock_set_id(this.__wbg_ptr, id);
+    get file_name() {
+        const ret = wasm.wasmblock_get_file_name(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @returns {bigint}
@@ -972,49 +948,53 @@ export class WasmBlock {
         wasm.wasmblock_set_timestamp(this.__wbg_ptr, timestamp);
     }
     /**
-    * @returns {string}
+    * @returns {bigint}
     */
-    get previous_block_hash() {
-        const ret = wasm.wasmblock_get_previous_block_hash(this.__wbg_ptr);
-        return takeObject(ret);
+    get avg_payout_atr() {
+        const ret = wasm.wasmblock_avg_payout_atr(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {string} hash
+    * @returns {bigint}
     */
-    set previous_block_hash(hash) {
-        wasm.wasmblock_set_previous_block_hash(this.__wbg_ptr, addHeapObject(hash));
+    get avg_total_fees() {
+        const ret = wasm.wasmblock_avg_income(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {string} key
+    * @returns {bigint}
     */
-    set creator(key) {
-        wasm.wasmblock_set_creator(this.__wbg_ptr, addHeapObject(key));
+    get total_fees_atr() {
+        const ret = wasm.wasmblock_total_fees_atr(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {string}
+    * @returns {bigint}
     */
-    get creator() {
-        const ret = wasm.wasmblock_get_creator(this.__wbg_ptr);
-        return takeObject(ret);
+    get total_fees_new() {
+        const ret = wasm.wasmblock_total_fees_new(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {number}
+    * @param {Array<any>} keylist
+    * @returns {boolean}
     */
-    get type() {
-        const ret = wasm.wasmblock_get_type(this.__wbg_ptr);
-        return ret;
+    has_keylist_txs(keylist) {
+        const ret = wasm.wasmblock_has_keylist_txs(this.__wbg_ptr, addHeapObject(keylist));
+        return ret !== 0;
     }
     /**
-    * @param {number} t
+    * @returns {bigint}
     */
-    set type(t) {
-        wasm.wasmblock_set_type(this.__wbg_ptr, t);
+    get avg_fee_per_byte() {
+        const ret = wasm.wasmblock_avg_fee_per_byte(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {string}
+    * @returns {Array<any>}
     */
-    get hash() {
-        const ret = wasm.wasmblock_get_hash(this.__wbg_ptr);
+    get transactions() {
+        const ret = wasm.wasmblock_get_transactions(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1025,52 +1005,60 @@ export class WasmBlock {
         return ret !== 0;
     }
     /**
+    * @returns {string}
+    */
+    get rebroadcast_hash() {
+        const ret = wasm.wasmblock_rebroadcast_hash(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {bigint}
+    */
+    get total_payout_atr() {
+        const ret = wasm.wasmblock_total_payout_atr(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * @returns {bigint}
+    */
+    get avg_payout_mining() {
+        const ret = wasm.wasmblock_avg_payout_mining(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
     * @returns {boolean}
     */
-    get force_loaded() {
-        const ret = wasm.wasmblock_force_loaded(this.__wbg_ptr);
+    get has_golden_ticket() {
+        const ret = wasm.wasmblock_has_golden_ticket(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-    * @returns {string}
+    * @returns {bigint}
     */
-    get file_name() {
-        const ret = wasm.wasmblock_get_file_name(this.__wbg_ptr);
-        return takeObject(ret);
+    get avg_payout_routing() {
+        const ret = wasm.wasmblock_avg_payout_routing(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {bigint}
     */
-    serialize() {
-        const ret = wasm.wasmblock_serialize(this.__wbg_ptr);
-        return takeObject(ret);
+    get avg_total_fees_atr() {
+        const ret = wasm.wasmblock_avg_total_fees_atr(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {Uint8Array} buffer
-    * @returns {any}
+    * @returns {bigint}
     */
-    deserialize(buffer) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.wasmblock_deserialize(retptr, this.__wbg_ptr, addHeapObject(buffer));
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    get avg_total_fees_new() {
+        const ret = wasm.wasmblock_avg_total_fees_new(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {Array<any>} keylist
-    * @returns {boolean}
+    * @returns {bigint}
     */
-    has_keylist_txs(keylist) {
-        const ret = wasm.wasmblock_has_keylist_txs(this.__wbg_ptr, addHeapObject(keylist));
-        return ret !== 0;
+    get avg_payout_treasury() {
+        const ret = wasm.wasmblock_avg_payout_treasury(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
     * @param {Array<any>} keylist
@@ -1083,57 +1071,57 @@ export class WasmBlock {
     /**
     * @returns {bigint}
     */
-    get treasury() {
-        const ret = wasm.wasmblock_treasury(this.__wbg_ptr);
+    get golden_ticket_index() {
+        const ret = wasm.wasmblock_golden_ticket_index(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {boolean}
     */
-    get graveyard() {
-        const ret = wasm.wasmblock_graveyard(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get has_fee_transaction() {
+        const ret = wasm.wasmblock_has_fee_transaction(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
     * @returns {bigint}
     */
-    get total_fees_new() {
-        const ret = wasm.wasmblock_total_fees_new(this.__wbg_ptr);
+    get total_payout_mining() {
+        const ret = wasm.wasmblock_total_payout_mining(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_fees_atr() {
-        const ret = wasm.wasmblock_total_fees_atr(this.__wbg_ptr);
+    get avg_payout_graveyard() {
+        const ret = wasm.wasmblock_avg_payout_graveyard(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get avg_total_fees_new() {
-        const ret = wasm.wasmblock_avg_total_fees_new(this.__wbg_ptr);
+    get total_payout_routing() {
+        const ret = wasm.wasmblock_total_payout_routing(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get avg_total_fees_atr() {
-        const ret = wasm.wasmblock_avg_total_fees_atr(this.__wbg_ptr);
+    get fee_transaction_index() {
+        const ret = wasm.wasmblock_fee_transaction_index(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_payout_routing() {
-        const ret = wasm.wasmblock_total_payout_routing(this.__wbg_ptr);
+    get previous_block_unpaid() {
+        const ret = wasm.wasmblock_previous_block_unpaid(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_payout_mining() {
-        const ret = wasm.wasmblock_total_payout_mining(this.__wbg_ptr);
+    get total_fees_cumulative() {
+        const ret = wasm.wasmblock_total_fees_cumulative(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -1151,116 +1139,127 @@ export class WasmBlock {
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {string}
     */
-    get avg_payout_routing() {
-        const ret = wasm.wasmblock_avg_payout_routing(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get previous_block_hash() {
+        const ret = wasm.wasmblock_get_previous_block_hash(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {boolean}
     */
-    get avg_payout_treasury() {
-        const ret = wasm.wasmblock_avg_payout_treasury(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get has_staking_transaction() {
+        const ret = wasm.wasmblock_has_staking_transaction(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-    * @returns {bigint}
+    * @param {string} hash
     */
-    get avg_payout_graveyard() {
-        const ret = wasm.wasmblock_avg_payout_graveyard(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    set previous_block_hash(hash) {
+        wasm.wasmblock_set_previous_block_hash(this.__wbg_ptr, addHeapObject(hash));
     }
     /**
     * @returns {bigint}
     */
-    get avg_payout_atr() {
-        const ret = wasm.wasmblock_avg_payout_atr(this.__wbg_ptr);
+    get total_rebroadcast_nolan() {
+        const ret = wasm.wasmblock_total_rebroadcast_nolan(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get fee_per_byte() {
-        const ret = wasm.wasmblock_fee_per_byte(this.__wbg_ptr);
+    get total_rebroadcast_slips() {
+        const ret = wasm.wasmblock_total_rebroadcast_slips(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
+    * @returns {boolean}
+    */
+    get has_issuance_transaction() {
+        const ret = wasm.wasmblock_has_issuance_transaction(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
     * @returns {bigint}
     */
-    get previous_block_unpaid() {
-        const ret = wasm.wasmblock_previous_block_unpaid(this.__wbg_ptr);
+    get issuance_transaction_index() {
+        const ret = wasm.wasmblock_issuance_transaction_index(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_work() {
-        const ret = wasm.wasmblock_total_work(this.__wbg_ptr);
+    get avg_nolan_rebroadcast_per_block() {
+        const ret = wasm.wasmblock_avg_nolan_rebroadcast_per_block(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {boolean}
     */
-    get has_golden_ticket() {
-        const ret = wasm.wasmblock_has_golden_ticket(this.__wbg_ptr);
-        return ret !== 0;
+    constructor() {
+        const ret = wasm.wasmblock_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
-    * @returns {boolean}
+    * @returns {bigint}
     */
-    get has_issuance_transaction() {
-        const ret = wasm.wasmblock_has_issuance_transaction(this.__wbg_ptr);
-        return ret !== 0;
+    get id() {
+        const ret = wasm.wasmblock_get_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * @param {bigint} id
+    */
+    set id(id) {
+        wasm.wasmblock_set_id(this.__wbg_ptr, id);
     }
     /**
     * @returns {bigint}
     */
-    get issuance_transaction_index() {
-        const ret = wasm.wasmblock_issuance_transaction_index(this.__wbg_ptr);
+    get burnfee() {
+        const ret = wasm.wasmblock_burnfee(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {boolean}
+    * @returns {string}
     */
-    get has_fee_transaction() {
-        const ret = wasm.wasmblock_has_fee_transaction(this.__wbg_ptr);
-        return ret !== 0;
+    get hash() {
+        const ret = wasm.wasmblock_get_hash(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @returns {boolean}
+    * @returns {number}
     */
-    get has_staking_transaction() {
-        const ret = wasm.wasmblock_has_staking_transaction(this.__wbg_ptr);
-        return ret !== 0;
+    get type() {
+        const ret = wasm.wasmblock_get_type(this.__wbg_ptr);
+        return ret;
     }
     /**
-    * @returns {bigint}
+    * @param {number} t
     */
-    get golden_ticket_index() {
-        const ret = wasm.wasmblock_golden_ticket_index(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    set type(t) {
+        wasm.wasmblock_set_type(this.__wbg_ptr, t);
     }
     /**
     * @returns {bigint}
     */
-    get fee_transaction_index() {
-        const ret = wasm.wasmblock_fee_transaction_index(this.__wbg_ptr);
+    get treasury() {
+        const ret = wasm.wasmblock_treasury(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_payout_atr() {
-        const ret = wasm.wasmblock_total_payout_atr(this.__wbg_ptr);
+    get graveyard() {
+        const ret = wasm.wasmblock_graveyard(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {Uint8Array}
     */
-    get avg_payout_mining() {
-        const ret = wasm.wasmblock_avg_payout_mining(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    serialize() {
+        const ret = wasm.wasmblock_serialize(this.__wbg_ptr);
+        return takeObject(ret);
     }
 }
 
@@ -1291,103 +1290,107 @@ export class WasmBlockchain {
         wasm.__wbg_wasmblockchain_free(ptr);
     }
     /**
-    * @returns {Promise<void>}
+    * @returns {Promise<string>}
     */
-    reset() {
-        const ret = wasm.wasmblockchain_reset(this.__wbg_ptr);
+    get_fork_id() {
+        const ret = wasm.wasmblockchain_get_fork_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<bigint>}
+    * @param {string} hash
+    * @returns {Promise<void>}
     */
-    get_last_block_id() {
-        const ret = wasm.wasmblockchain_get_last_block_id(this.__wbg_ptr);
+    set_fork_id(hash) {
+        const ret = wasm.wasmblockchain_set_fork_id(this.__wbg_ptr, addHeapObject(hash));
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<bigint>}
+    * @param {bigint} block_id
+    * @returns {Promise<Array<any>>}
     */
-    get_last_timestamp() {
-        const ret = wasm.wasmblockchain_get_last_timestamp(this.__wbg_ptr);
+    get_hashes_at_id(block_id) {
+        const ret = wasm.wasmblockchain_get_hashes_at_id(this.__wbg_ptr, block_id);
         return takeObject(ret);
     }
     /**
-    * @param {bigint} id
-    * @returns {Promise<string>}
+    * @returns {Promise<bigint>}
     */
-    get_longest_chain_hash_at(id) {
-        const ret = wasm.wasmblockchain_get_longest_chain_hash_at(this.__wbg_ptr, id);
+    get_last_burnfee() {
+        const ret = wasm.wasmblockchain_get_last_burnfee(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<string>}
+    * @returns {Promise<bigint>}
     */
-    get_last_block_hash() {
-        const ret = wasm.wasmblockchain_get_last_block_hash(this.__wbg_ptr);
+    get_last_block_id() {
+        const ret = wasm.wasmblockchain_get_last_block_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<bigint>}
+    * @param {Function} reorg_cb
+    * @param {Function} add_block_cb
+    * @param {Function} confirm_cb
+    * @returns {Promise<void>}
     */
-    get_last_burnfee() {
-        const ret = wasm.wasmblockchain_get_last_burnfee(this.__wbg_ptr);
+    register_callback(reorg_cb, add_block_cb, confirm_cb) {
+        const ret = wasm.wasmblockchain_register_callback(this.__wbg_ptr, addHeapObject(reorg_cb), addHeapObject(add_block_cb), addHeapObject(confirm_cb));
         return takeObject(ret);
     }
     /**
     * @returns {Promise<bigint>}
     */
-    get_genesis_block_id() {
-        const ret = wasm.wasmblockchain_get_genesis_block_id(this.__wbg_ptr);
+    get_last_timestamp() {
+        const ret = wasm.wasmblockchain_get_last_timestamp(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<bigint>}
+    * @returns {Promise<string>}
     */
-    get_genesis_timestamp() {
-        const ret = wasm.wasmblockchain_get_genesis_timestamp(this.__wbg_ptr);
+    get_last_block_hash() {
+        const ret = wasm.wasmblockchain_get_last_block_hash(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Promise<bigint>}
     */
-    get_lowest_acceptable_timestamp() {
-        const ret = wasm.wasmblockchain_get_lowest_acceptable_timestamp(this.__wbg_ptr);
+    get_latest_block_id() {
+        const ret = wasm.wasmblockchain_get_latest_block_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<string>}
+    * @returns {Promise<bigint>}
     */
-    get_lowest_acceptable_block_hash() {
-        const ret = wasm.wasmblockchain_get_lowest_acceptable_block_hash(this.__wbg_ptr);
+    get_genesis_block_id() {
+        const ret = wasm.wasmblockchain_get_genesis_block_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Promise<bigint>}
     */
-    get_lowest_acceptable_block_id() {
-        const ret = wasm.wasmblockchain_get_lowest_acceptable_block_id(this.__wbg_ptr);
+    get_genesis_timestamp() {
+        const ret = wasm.wasmblockchain_get_genesis_timestamp(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Promise<bigint>}
     */
-    get_latest_block_id() {
-        const ret = wasm.wasmblockchain_get_latest_block_id(this.__wbg_ptr);
+    get_prune_after_blocks() {
+        const ret = wasm.wasmblockchain_get_prune_after_blocks(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
+    * @param {bigint} id
     * @returns {Promise<string>}
     */
-    get_fork_id() {
-        const ret = wasm.wasmblockchain_get_fork_id(this.__wbg_ptr);
+    get_longest_chain_hash_at(id) {
+        const ret = wasm.wasmblockchain_get_longest_chain_hash_at(this.__wbg_ptr, id);
         return takeObject(ret);
     }
     /**
-    * @param {string} hash
-    * @returns {Promise<void>}
+    * @returns {Promise<bigint>}
     */
-    set_fork_id(hash) {
-        const ret = wasm.wasmblockchain_set_fork_id(this.__wbg_ptr, addHeapObject(hash));
+    get_block_confirmation_limit() {
+        const ret = wasm.wasmblockchain_get_block_confirmation_limit(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1400,14 +1403,6 @@ export class WasmBlockchain {
     }
     /**
     * @param {bigint} block_id
-    * @returns {Promise<Array<any>>}
-    */
-    get_hashes_at_id(block_id) {
-        const ret = wasm.wasmblockchain_get_hashes_at_id(this.__wbg_ptr, block_id);
-        return takeObject(ret);
-    }
-    /**
-    * @param {bigint} block_id
     * @returns {Promise<void>}
     */
     set_safe_to_prune_transaction(block_id) {
@@ -1417,25 +1412,29 @@ export class WasmBlockchain {
     /**
     * @returns {Promise<bigint>}
     */
-    get_prune_after_blocks() {
-        const ret = wasm.wasmblockchain_get_prune_after_blocks(this.__wbg_ptr);
+    get_lowest_acceptable_block_id() {
+        const ret = wasm.wasmblockchain_get_lowest_acceptable_block_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Promise<bigint>}
     */
-    get_block_confirmation_limit() {
-        const ret = wasm.wasmblockchain_get_block_confirmation_limit(this.__wbg_ptr);
+    get_lowest_acceptable_timestamp() {
+        const ret = wasm.wasmblockchain_get_lowest_acceptable_timestamp(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Promise<string>}
+    */
+    get_lowest_acceptable_block_hash() {
+        const ret = wasm.wasmblockchain_get_lowest_acceptable_block_hash(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @param {Function} reorg_cb
-    * @param {Function} add_block_cb
-    * @param {Function} confirm_cb
     * @returns {Promise<void>}
     */
-    register_callback(reorg_cb, add_block_cb, confirm_cb) {
-        const ret = wasm.wasmblockchain_register_callback(this.__wbg_ptr, addHeapObject(reorg_cb), addHeapObject(add_block_cb), addHeapObject(confirm_cb));
+    reset() {
+        const ret = wasm.wasmblockchain_reset(this.__wbg_ptr);
         return takeObject(ret);
     }
 }
@@ -1486,53 +1485,39 @@ export class WasmConsensusValues {
         wasm.__wbg_wasmconsensusvalues_free(ptr);
     }
     /**
-    * @returns {number}
-    */
-    get it_num() {
-        const ret = wasm.wasmconsensusvalues_it_num(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-    * @returns {any}
-    */
-    fee_transaction() {
-        const ret = wasm.wasmconsensusvalues_fee_transaction(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-    * @returns {number}
+    * @returns {bigint}
     */
-    get it_index() {
-        const ret = wasm.wasmconsensusvalues_it_index(this.__wbg_ptr);
-        return ret >>> 0;
+    get avg_income() {
+        const ret = wasm.wasmconsensusvalues_avg_income(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {number}
+    * @returns {bigint}
     */
-    get ft_num() {
-        const ret = wasm.wasmconsensusvalues_ft_num(this.__wbg_ptr);
-        return ret;
+    get total_fees() {
+        const ret = wasm.wasmconsensusvalues_total_fees(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {number}
+    * @returns {bigint}
     */
-    get ft_index() {
-        const ret = wasm.wasmconsensusvalues_ft_index(this.__wbg_ptr);
-        return ret >>> 0;
+    get avg_total_fees() {
+        const ret = wasm.wasmconsensusvalues_avg_income(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {number}
+    * @returns {any}
     */
-    get gt_index() {
-        const ret = wasm.wasmconsensusvalues_gt_index(this.__wbg_ptr);
-        return ret >>> 0;
+    fee_transaction() {
+        const ret = wasm.wasmconsensusvalues_fee_transaction(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {string}
     */
-    get total_fees() {
-        const ret = wasm.wasmconsensusvalues_total_fees(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get rebroadcast_hash() {
+        const ret = wasm.wasmconsensusvalues_rebroadcast_hash(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @returns {bigint}
@@ -1544,15 +1529,15 @@ export class WasmConsensusValues {
     /**
     * @returns {bigint}
     */
-    get total_rebroadcast_slips() {
-        const ret = wasm.wasmconsensusvalues_total_rebroadcast_slips(this.__wbg_ptr);
+    get total_rebroadcast_nolan() {
+        const ret = wasm.wasmconsensusvalues_total_rebroadcast_nolan(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {bigint}
     */
-    get total_rebroadcast_nolan() {
-        const ret = wasm.wasmconsensusvalues_total_rebroadcast_nolan(this.__wbg_ptr);
+    get total_rebroadcast_slips() {
+        const ret = wasm.wasmconsensusvalues_total_rebroadcast_slips(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -1570,25 +1555,39 @@ export class WasmConsensusValues {
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {string}
+    * @returns {number}
     */
-    get rebroadcast_hash() {
-        const ret = wasm.wasmconsensusvalues_rebroadcast_hash(this.__wbg_ptr);
-        return takeObject(ret);
+    get ft_num() {
+        const ret = wasm.wasmconsensusvalues_ft_num(this.__wbg_ptr);
+        return ret;
     }
     /**
-    * @returns {bigint}
+    * @returns {number}
     */
-    get avg_income() {
-        const ret = wasm.wasmconsensusvalues_avg_income(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get it_num() {
+        const ret = wasm.wasmconsensusvalues_it_num(this.__wbg_ptr);
+        return ret;
     }
     /**
-    * @returns {bigint}
+    * @returns {number}
     */
-    get avg_total_fees() {
-        const ret = wasm.wasmconsensusvalues_avg_income(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get ft_index() {
+        const ret = wasm.wasmconsensusvalues_ft_index(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {number}
+    */
+    get gt_index() {
+        const ret = wasm.wasmconsensusvalues_gt_index(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {number}
+    */
+    get it_index() {
+        const ret = wasm.wasmconsensusvalues_it_index(this.__wbg_ptr);
+        return ret >>> 0;
     }
 }
 
@@ -1621,12 +1620,12 @@ export class WasmHop {
     /**
     * @returns {string}
     */
-    get from() {
+    get to() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.wasmhop_from(retptr, this.__wbg_ptr);
+            wasm.wasmhop_to(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -1659,12 +1658,12 @@ export class WasmHop {
     /**
     * @returns {string}
     */
-    get to() {
+    get from() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.wasmhop_to(retptr, this.__wbg_ptr);
+            wasm.wasmhop_from(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -1704,6 +1703,23 @@ export class WasmNFT {
         wasm.__wbg_wasmnft_free(ptr);
     }
     /**
+    * @param {Uint8Array} arr
+    */
+    set tx_sig(arr) {
+        try {
+            wasm.wasmnft_set_tx_sig(this.__wbg_ptr, addBorrowedObject(arr));
+        } finally {
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get id() {
+        const ret = wasm.wasmnft_id(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     */
     constructor() {
         const ret = wasm.wasmnft_new();
@@ -1711,45 +1727,42 @@ export class WasmNFT {
         return this;
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {WasmSlip}
     */
-    get id() {
-        const ret = wasm.wasmnft_id(this.__wbg_ptr);
-        return takeObject(ret);
+    get slip1() {
+        const ret = wasm.wasmnft_slip1(this.__wbg_ptr);
+        return WasmSlip.__wrap(ret);
     }
     /**
-    * @param {Uint8Array} arr
+    * @returns {WasmSlip}
     */
-    set id(arr) {
-        try {
-            wasm.wasmnft_set_id(this.__wbg_ptr, addBorrowedObject(arr));
-        } finally {
-            heap[stack_pointer++] = undefined;
-        }
+    get slip2() {
+        const ret = wasm.wasmnft_slip2(this.__wbg_ptr);
+        return WasmSlip.__wrap(ret);
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {WasmSlip}
     */
-    get tx_sig() {
-        const ret = wasm.wasmnft_tx_sig(this.__wbg_ptr);
-        return takeObject(ret);
+    get slip3() {
+        const ret = wasm.wasmnft_slip3(this.__wbg_ptr);
+        return WasmSlip.__wrap(ret);
     }
     /**
     * @param {Uint8Array} arr
     */
-    set tx_sig(arr) {
+    set id(arr) {
         try {
-            wasm.wasmnft_set_tx_sig(this.__wbg_ptr, addBorrowedObject(arr));
+            wasm.wasmnft_set_id(this.__wbg_ptr, addBorrowedObject(arr));
         } finally {
             heap[stack_pointer++] = undefined;
         }
     }
     /**
-    * @returns {WasmSlip}
+    * @returns {Uint8Array}
     */
-    get slip1() {
-        const ret = wasm.wasmnft_slip1(this.__wbg_ptr);
-        return WasmSlip.__wrap(ret);
+    get tx_sig() {
+        const ret = wasm.wasmnft_tx_sig(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @param {WasmSlip} ws
@@ -1759,13 +1772,6 @@ export class WasmNFT {
         wasm.wasmnft_set_slip1(this.__wbg_ptr, ws.__wbg_ptr);
     }
     /**
-    * @returns {WasmSlip}
-    */
-    get slip2() {
-        const ret = wasm.wasmnft_slip2(this.__wbg_ptr);
-        return WasmSlip.__wrap(ret);
-    }
-    /**
     * @param {WasmSlip} ws
     */
     set slip2(ws) {
@@ -1773,13 +1779,6 @@ export class WasmNFT {
         wasm.wasmnft_set_slip2(this.__wbg_ptr, ws.__wbg_ptr);
     }
     /**
-    * @returns {WasmSlip}
-    */
-    get slip3() {
-        const ret = wasm.wasmnft_slip3(this.__wbg_ptr);
-        return WasmSlip.__wrap(ret);
-    }
-    /**
     * @param {WasmSlip} ws
     */
     set slip3(ws) {
@@ -1817,11 +1816,19 @@ export class WasmPeer {
     /**
     * @returns {string}
     */
-    get public_key() {
-        const ret = wasm.wasmpeer_get_public_key(this.__wbg_ptr);
+    get status() {
+        const ret = wasm.wasmpeer_get_status(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
+    * @param {string} service
+    * @returns {boolean}
+    */
+    has_service(service) {
+        const ret = wasm.wasmpeer_has_service(this.__wbg_ptr, addHeapObject(service));
+        return ret !== 0;
+    }
+    /**
     * @returns {Array<any>}
     */
     get key_list() {
@@ -1829,19 +1836,17 @@ export class WasmPeer {
         return takeObject(ret);
     }
     /**
-    * @returns {bigint}
+    * @returns {any}
     */
-    get peer_index() {
-        const ret = wasm.wasmpeer_get_peer_index(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get services() {
+        const ret = wasm.wasmpeer_get_services(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @param {bigint} peer_index
+    * @param {any} services
     */
-    constructor(peer_index) {
-        const ret = wasm.wasmpeer_new(peer_index);
-        this.__wbg_ptr = ret >>> 0;
-        return this;
+    set services(services) {
+        wasm.wasmpeer_set_services(this.__wbg_ptr, addHeapObject(services));
     }
     /**
     * @returns {string}
@@ -1851,32 +1856,26 @@ export class WasmPeer {
         return takeObject(ret);
     }
     /**
-    * @returns {any}
-    */
-    get services() {
-        const ret = wasm.wasmpeer_get_services(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-    * @param {any} services
+    * @returns {bigint}
     */
-    set services(services) {
-        wasm.wasmpeer_set_services(this.__wbg_ptr, addHeapObject(services));
+    get peer_index() {
+        const ret = wasm.wasmpeer_get_peer_index(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {string} service
-    * @returns {boolean}
+    * @returns {string}
     */
-    has_service(service) {
-        const ret = wasm.wasmpeer_has_service(this.__wbg_ptr, addHeapObject(service));
-        return ret !== 0;
+    get public_key() {
+        const ret = wasm.wasmpeer_get_public_key(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @returns {string}
+    * @param {bigint} peer_index
     */
-    get status() {
-        const ret = wasm.wasmpeer_get_status(this.__wbg_ptr);
-        return takeObject(ret);
+    constructor(peer_index) {
+        const ret = wasm.wasmpeer_new(peer_index);
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
 }
 
@@ -1907,17 +1906,17 @@ export class WasmPeerService {
         wasm.__wbg_wasmpeerservice_free(ptr);
     }
     /**
+    * @returns {string}
     */
-    constructor() {
-        const ret = wasm.wasmpeerservice_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
+    get domain() {
+        const ret = wasm.wasmpeerservice_get_domain(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @param {string} value
     */
-    set service(value) {
-        wasm.wasmpeerservice_set_service(this.__wbg_ptr, addHeapObject(value));
+    set domain(value) {
+        wasm.wasmpeerservice_set_domain(this.__wbg_ptr, addHeapObject(value));
     }
     /**
     * @returns {string}
@@ -1929,8 +1928,15 @@ export class WasmPeerService {
     /**
     * @param {string} value
     */
-    set name(value) {
-        wasm.wasmpeerservice_set_name(this.__wbg_ptr, addHeapObject(value));
+    set service(value) {
+        wasm.wasmpeerservice_set_service(this.__wbg_ptr, addHeapObject(value));
+    }
+    /**
+    */
+    constructor() {
+        const ret = wasm.wasmpeerservice_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
     * @returns {string}
@@ -1942,15 +1948,8 @@ export class WasmPeerService {
     /**
     * @param {string} value
     */
-    set domain(value) {
-        wasm.wasmpeerservice_set_domain(this.__wbg_ptr, addHeapObject(value));
-    }
-    /**
-    * @returns {string}
-    */
-    get domain() {
-        const ret = wasm.wasmpeerservice_get_domain(this.__wbg_ptr);
-        return takeObject(ret);
+    set name(value) {
+        wasm.wasmpeerservice_set_name(this.__wbg_ptr, addHeapObject(value));
     }
 }
 
@@ -1973,6 +1972,13 @@ export class WasmPeerServiceList {
         wasm.__wbg_wasmpeerservicelist_free(ptr);
     }
     /**
+    */
+    constructor() {
+        const ret = wasm.wasmpeerservicelist_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
     * @param {WasmPeerService} service
     */
     push(service) {
@@ -1980,13 +1986,6 @@ export class WasmPeerServiceList {
         var ptr0 = service.__destroy_into_raw();
         wasm.wasmpeerservicelist_push(this.__wbg_ptr, ptr0);
     }
-    /**
-    */
-    constructor() {
-        const ret = wasm.wasmpeerservicelist_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
-    }
 }
 
 const WasmSlipFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -2016,11 +2015,11 @@ export class WasmSlip {
         wasm.__wbg_wasmslip_free(ptr);
     }
     /**
-    * @returns {bigint}
+    * @returns {string}
     */
-    get amount() {
-        const ret = wasm.wasmslip_amount(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get public_key() {
+        const ret = wasm.wasmslip_public_key(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @param {bigint} amount
@@ -2031,35 +2030,40 @@ export class WasmSlip {
     /**
     * @returns {number}
     */
-    get slip_type() {
-        const ret = wasm.wasmslip_slip_type(this.__wbg_ptr);
+    get slip_index() {
+        const ret = wasm.wasmslip_slip_index(this.__wbg_ptr);
         return ret;
     }
     /**
-    * @param {number} slip_type
+    * @returns {bigint}
     */
-    set slip_type(slip_type) {
-        wasm.wasmslip_set_slip_type(this.__wbg_ptr, slip_type);
+    get tx_ordinal() {
+        const ret = wasm.wasmslip_tx_ordinal(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @returns {string}
+    * @param {bigint} id
     */
-    get public_key() {
-        const ret = wasm.wasmslip_public_key(this.__wbg_ptr);
-        return takeObject(ret);
+    set block_id(id) {
+        wasm.wasmslip_set_block_id(this.__wbg_ptr, id);
     }
     /**
     * @param {string} key
     */
-    set public_key(key) {
-        wasm.wasmslip_set_public_key(this.__wbg_ptr, addHeapObject(key));
+    set utxo_key(key) {
+        wasm.wasmslip_set_utxo_key(this.__wbg_ptr, addHeapObject(key));
     }
     /**
-    * @returns {number}
+    * @param {number} slip_type
     */
-    get slip_index() {
-        const ret = wasm.wasmslip_slip_index(this.__wbg_ptr);
-        return ret;
+    set slip_type(slip_type) {
+        wasm.wasmslip_set_slip_type(this.__wbg_ptr, slip_type);
+    }
+    /**
+    * @param {string} key
+    */
+    set public_key(key) {
+        wasm.wasmslip_set_public_key(this.__wbg_ptr, addHeapObject(key));
     }
     /**
     * @param {number} index
@@ -2068,36 +2072,31 @@ export class WasmSlip {
         wasm.wasmslip_set_slip_index(this.__wbg_ptr, index);
     }
     /**
-    * @returns {bigint}
+    * @param {bigint} ordinal
     */
-    get block_id() {
-        const ret = wasm.wasmslip_block_id(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    set tx_ordinal(ordinal) {
+        wasm.wasmslip_set_tx_ordinal(this.__wbg_ptr, ordinal);
     }
     /**
-    * @param {bigint} id
     */
-    set block_id(id) {
-        wasm.wasmslip_set_block_id(this.__wbg_ptr, id);
+    constructor() {
+        const ret = wasm.wasmslip_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
     * @returns {bigint}
     */
-    get tx_ordinal() {
-        const ret = wasm.wasmslip_tx_ordinal(this.__wbg_ptr);
+    get amount() {
+        const ret = wasm.wasmslip_amount(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {bigint} ordinal
-    */
-    set tx_ordinal(ordinal) {
-        wasm.wasmslip_set_tx_ordinal(this.__wbg_ptr, ordinal);
-    }
-    /**
-    * @param {string} key
+    * @returns {bigint}
     */
-    set utxo_key(key) {
-        wasm.wasmslip_set_utxo_key(this.__wbg_ptr, addHeapObject(key));
+    get block_id() {
+        const ret = wasm.wasmslip_block_id(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
     * @returns {string}
@@ -2107,11 +2106,11 @@ export class WasmSlip {
         return takeObject(ret);
     }
     /**
+    * @returns {number}
     */
-    constructor() {
-        const ret = wasm.wasmslip_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
+    get slip_type() {
+        const ret = wasm.wasmslip_slip_type(this.__wbg_ptr);
+        return ret;
     }
 }
 
@@ -2162,25 +2161,53 @@ export class WasmTransaction {
         wasm.__wbg_wasmtransaction_free(ptr);
     }
     /**
+    * @returns {bigint}
+    */
+    get total_fees() {
+        const ret = wasm.wasmtransaction_total_fees(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * @param {WasmSlip} slip
     */
-    constructor() {
-        const ret = wasm.wasmtransaction_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
+    add_to_slip(slip) {
+        _assertClass(slip, WasmSlip);
+        var ptr0 = slip.__destroy_into_raw();
+        wasm.wasmtransaction_add_to_slip(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {string}
+    * @param {Uint8Array} buffer
+    * @returns {WasmTransaction}
     */
-    get signature() {
-        const ret = wasm.wasmtransaction_signature(this.__wbg_ptr);
-        return takeObject(ret);
+    static deserialize(buffer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtransaction_deserialize(retptr, addHeapObject(buffer));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return WasmTransaction.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * @returns {Array<any>}
+    * @param {WasmSlip} slip
     */
-    get routing_path() {
-        const ret = wasm.wasmtransaction_get_routing_path(this.__wbg_ptr);
-        return takeObject(ret);
+    add_from_slip(slip) {
+        _assertClass(slip, WasmSlip);
+        var ptr0 = slip.__destroy_into_raw();
+        wasm.wasmtransaction_add_from_slip(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {bigint}
+    */
+    get timestamp() {
+        const ret = wasm.wasmtransaction_get_timestamp(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
     * @param {string} signature
@@ -2189,20 +2216,17 @@ export class WasmTransaction {
         wasm.wasmtransaction_set_signature(this.__wbg_ptr, addHeapObject(signature));
     }
     /**
-    * @param {WasmSlip} slip
+    * @param {bigint} timestamp
     */
-    add_to_slip(slip) {
-        _assertClass(slip, WasmSlip);
-        var ptr0 = slip.__destroy_into_raw();
-        wasm.wasmtransaction_add_to_slip(this.__wbg_ptr, ptr0);
+    set timestamp(timestamp) {
+        wasm.wasmtransaction_set_timestamp(this.__wbg_ptr, timestamp);
     }
     /**
-    * @param {WasmSlip} slip
+    * @returns {Array<any>}
     */
-    add_from_slip(slip) {
-        _assertClass(slip, WasmSlip);
-        var ptr0 = slip.__destroy_into_raw();
-        wasm.wasmtransaction_add_from_slip(this.__wbg_ptr, ptr0);
+    get routing_path() {
+        const ret = wasm.wasmtransaction_get_routing_path(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
     * @returns {number}
@@ -2225,6 +2249,13 @@ export class WasmTransaction {
         return takeObject(ret);
     }
     /**
+    */
+    constructor() {
+        const ret = wasm.wasmtransaction_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
     * @returns {Array<any>}
     */
     get from() {
@@ -2232,19 +2263,26 @@ export class WasmTransaction {
         return takeObject(ret);
     }
     /**
+    * @returns {Promise<void>}
+    */
+    sign() {
+        const ret = wasm.wasmtransaction_sign(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
     * @param {string} key
     * @returns {boolean}
     */
-    is_from(key) {
-        const ret = wasm.wasmtransaction_is_from(this.__wbg_ptr, addHeapObject(key));
+    is_to(key) {
+        const ret = wasm.wasmtransaction_is_to(this.__wbg_ptr, addHeapObject(key));
         return ret !== 0;
     }
     /**
     * @param {string} key
     * @returns {boolean}
     */
-    is_to(key) {
-        const ret = wasm.wasmtransaction_is_to(this.__wbg_ptr, addHeapObject(key));
+    is_from(key) {
+        const ret = wasm.wasmtransaction_is_from(this.__wbg_ptr, addHeapObject(key));
         return ret !== 0;
     }
     /**
@@ -2255,32 +2293,6 @@ export class WasmTransaction {
         return takeObject(ret);
     }
     /**
-    * @param {Uint8Array} buffer
-    */
-    set data(buffer) {
-        wasm.wasmtransaction_set_data(this.__wbg_ptr, addHeapObject(buffer));
-    }
-    /**
-    * @returns {bigint}
-    */
-    get timestamp() {
-        const ret = wasm.wasmtransaction_get_timestamp(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-    * @param {bigint} timestamp
-    */
-    set timestamp(timestamp) {
-        wasm.wasmtransaction_set_timestamp(this.__wbg_ptr, timestamp);
-    }
-    /**
-    * @returns {Promise<void>}
-    */
-    sign() {
-        const ret = wasm.wasmtransaction_sign(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
     * @returns {number}
     */
     get type() {
@@ -2288,17 +2300,16 @@ export class WasmTransaction {
         return ret;
     }
     /**
-    * @param {number} t
+    * @param {Uint8Array} buffer
     */
-    set type(t) {
-        wasm.wasmtransaction_set_type(this.__wbg_ptr, t);
+    set data(buffer) {
+        wasm.wasmtransaction_set_data(this.__wbg_ptr, addHeapObject(buffer));
     }
     /**
-    * @returns {bigint}
+    * @param {number} t
     */
-    get total_fees() {
-        const ret = wasm.wasmtransaction_total_fees(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    set type(t) {
+        wasm.wasmtransaction_set_type(this.__wbg_ptr, t);
     }
     /**
     * @returns {Uint8Array}
@@ -2308,23 +2319,11 @@ export class WasmTransaction {
         return takeObject(ret);
     }
     /**
-    * @param {Uint8Array} buffer
-    * @returns {WasmTransaction}
+    * @returns {string}
     */
-    static deserialize(buffer) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.wasmtransaction_deserialize(retptr, addHeapObject(buffer));
-            var r0 = getInt32Memory0()[retptr / 4 + 0];
-            var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var r2 = getInt32Memory0()[retptr / 4 + 2];
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return WasmTransaction.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    get signature() {
+        const ret = wasm.wasmtransaction_signature(this.__wbg_ptr);
+        return takeObject(ret);
     }
 }
 
@@ -2355,62 +2354,49 @@ export class WasmWallet {
         wasm.__wbg_wasmwallet_free(ptr);
     }
     /**
-    * @returns {Promise<void>}
+    * @returns {Promise<bigint>}
     */
-    save() {
-        const ret = wasm.wasmwallet_save(this.__wbg_ptr);
+    get_balance() {
+        const ret = wasm.wasmwallet_get_balance(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @param {boolean} keep_keys
-    * @returns {Promise<void>}
+    * @returns {Promise<Array<any>>}
     */
-    reset(keep_keys) {
-        const ret = wasm.wasmwallet_reset(this.__wbg_ptr, keep_keys);
+    get_key_list() {
+        const ret = wasm.wasmwallet_get_key_list(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
+    * @param {Array<any>} key_list
     * @returns {Promise<void>}
     */
-    load() {
-        const ret = wasm.wasmwallet_load(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-    * @returns {Promise<string>}
-    */
-    get_public_key() {
-        const ret = wasm.wasmwallet_get_public_key(this.__wbg_ptr);
+    set_key_list(key_list) {
+        const ret = wasm.wasmwallet_set_key_list(this.__wbg_ptr, addHeapObject(key_list));
         return takeObject(ret);
     }
     /**
-    * @param {string} key
+    * @param {WasmTransaction} tx
     * @returns {Promise<void>}
     */
-    set_public_key(key) {
-        const ret = wasm.wasmwallet_set_public_key(this.__wbg_ptr, addHeapObject(key));
+    add_to_pending(tx) {
+        _assertClass(tx, WasmTransaction);
+        const ret = wasm.wasmwallet_add_to_pending(this.__wbg_ptr, tx.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Promise<string>}
     */
-    get_private_key() {
-        const ret = wasm.wasmwallet_get_private_key(this.__wbg_ptr);
+    get_public_key() {
+        const ret = wasm.wasmwallet_get_public_key(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @param {string} key
     * @returns {Promise<void>}
     */
-    set_private_key(key) {
-        const ret = wasm.wasmwallet_set_private_key(this.__wbg_ptr, addHeapObject(key));
-        return takeObject(ret);
-    }
-    /**
-    * @returns {Promise<bigint>}
-    */
-    get_balance() {
-        const ret = wasm.wasmwallet_get_balance(this.__wbg_ptr);
+    set_public_key(key) {
+        const ret = wasm.wasmwallet_set_public_key(this.__wbg_ptr, addHeapObject(key));
         return takeObject(ret);
     }
     /**
@@ -2421,44 +2407,40 @@ export class WasmWallet {
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<Array<any>>}
+    * @returns {Promise<string>}
     */
-    get_slips() {
-        const ret = wasm.wasmwallet_get_slips(this.__wbg_ptr);
+    get_private_key() {
+        const ret = wasm.wasmwallet_get_private_key(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @param {WasmWalletSlip} slip
+    * @param {string} key
     * @returns {Promise<void>}
     */
-    add_slip(slip) {
-        _assertClass(slip, WasmWalletSlip);
-        var ptr0 = slip.__destroy_into_raw();
-        const ret = wasm.wasmwallet_add_slip(this.__wbg_ptr, ptr0);
+    set_private_key(key) {
+        const ret = wasm.wasmwallet_set_private_key(this.__wbg_ptr, addHeapObject(key));
         return takeObject(ret);
     }
     /**
-    * @param {WasmTransaction} tx
     * @returns {Promise<void>}
     */
-    add_to_pending(tx) {
-        _assertClass(tx, WasmTransaction);
-        const ret = wasm.wasmwallet_add_to_pending(this.__wbg_ptr, tx.__wbg_ptr);
+    load() {
+        const ret = wasm.wasmwallet_load(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @returns {Promise<Array<any>>}
+    * @returns {Promise<void>}
     */
-    get_key_list() {
-        const ret = wasm.wasmwallet_get_key_list(this.__wbg_ptr);
+    save() {
+        const ret = wasm.wasmwallet_save(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
-    * @param {Array<any>} key_list
+    * @param {boolean} keep_keys
     * @returns {Promise<void>}
     */
-    set_key_list(key_list) {
-        const ret = wasm.wasmwallet_set_key_list(this.__wbg_ptr, addHeapObject(key_list));
+    reset(keep_keys) {
+        const ret = wasm.wasmwallet_reset(this.__wbg_ptr, keep_keys);
         return takeObject(ret);
     }
     /**
@@ -2483,6 +2465,23 @@ export class WasmWallet {
         const ret = wasm.wasmwallet_add_nft(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
         return takeObject(ret);
     }
+    /**
+    * @param {WasmWalletSlip} slip
+    * @returns {Promise<void>}
+    */
+    add_slip(slip) {
+        _assertClass(slip, WasmWalletSlip);
+        var ptr0 = slip.__destroy_into_raw();
+        const ret = wasm.wasmwallet_add_slip(this.__wbg_ptr, ptr0);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Promise<Array<any>>}
+    */
+    get_slips() {
+        const ret = wasm.wasmwallet_get_slips(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const WasmWalletSlipFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -2512,30 +2511,30 @@ export class WasmWalletSlip {
         wasm.__wbg_wasmwalletslip_free(ptr);
     }
     /**
-    * @returns {string}
+    * @returns {bigint}
     */
-    get_utxokey() {
-        const ret = wasm.wasmwalletslip_get_utxokey(this.__wbg_ptr);
-        return takeObject(ret);
+    get_amount() {
+        const ret = wasm.wasmslip_amount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-    * @param {string} key
+    * @param {bigint} amount
     */
-    set_utxokey(key) {
-        wasm.wasmwalletslip_set_utxokey(this.__wbg_ptr, addHeapObject(key));
+    set_amount(amount) {
+        wasm.wasmslip_set_amount(this.__wbg_ptr, amount);
     }
     /**
-    * @returns {bigint}
+    * @returns {string}
     */
-    get_amount() {
-        const ret = wasm.wasmslip_amount(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get_utxokey() {
+        const ret = wasm.wasmwalletslip_get_utxokey(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
-    * @param {bigint} amount
+    * @param {string} key
     */
-    set_amount(amount) {
-        wasm.wasmslip_set_amount(this.__wbg_ptr, amount);
+    set_utxokey(key) {
+        wasm.wasmwalletslip_set_utxokey(this.__wbg_ptr, addHeapObject(key));
     }
     /**
     * @returns {bigint}
@@ -2551,17 +2550,17 @@ export class WasmWalletSlip {
         wasm.wasmslip_set_block_id(this.__wbg_ptr, block_id);
     }
     /**
-    * @returns {bigint}
+    * @returns {number}
     */
-    get_tx_ordinal() {
-        const ret = wasm.wasmslip_tx_ordinal(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get_slip_type() {
+        const ret = wasm.wasmwalletslip_get_slip_type(this.__wbg_ptr);
+        return ret;
     }
     /**
-    * @param {bigint} ordinal
+    * @param {number} slip_type
     */
-    set_tx_ordinal(ordinal) {
-        wasm.wasmslip_set_tx_ordinal(this.__wbg_ptr, ordinal);
+    set_slip_type(slip_type) {
+        wasm.wasmwalletslip_set_slip_type(this.__wbg_ptr, slip_type);
     }
     /**
     * @returns {number}
@@ -2571,23 +2570,30 @@ export class WasmWalletSlip {
         return ret;
     }
     /**
+    * @returns {bigint}
+    */
+    get_tx_ordinal() {
+        const ret = wasm.wasmslip_tx_ordinal(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
     * @param {number} index
     */
     set_slip_index(index) {
         wasm.wasmwalletslip_set_slip_index(this.__wbg_ptr, index);
     }
     /**
-    * @returns {boolean}
+    * @param {bigint} ordinal
     */
-    is_spent() {
-        const ret = wasm.wasmwalletslip_is_spent(this.__wbg_ptr);
-        return ret !== 0;
+    set_tx_ordinal(ordinal) {
+        wasm.wasmslip_set_tx_ordinal(this.__wbg_ptr, ordinal);
     }
     /**
-    * @param {boolean} spent
     */
-    set_spent(spent) {
-        wasm.wasmwalletslip_set_spent(this.__wbg_ptr, spent);
+    constructor() {
+        const ret = wasm.wasmwalletslip_new_();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
     }
     /**
     * @returns {boolean}
@@ -2603,24 +2609,17 @@ export class WasmWalletSlip {
         wasm.wasmwalletslip_set_lc(this.__wbg_ptr, lc);
     }
     /**
-    * @returns {number}
-    */
-    get_slip_type() {
-        const ret = wasm.wasmwalletslip_get_slip_type(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-    * @param {number} slip_type
+    * @returns {boolean}
     */
-    set_slip_type(slip_type) {
-        wasm.wasmwalletslip_set_slip_type(this.__wbg_ptr, slip_type);
+    is_spent() {
+        const ret = wasm.wasmwalletslip_is_spent(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
+    * @param {boolean} spent
     */
-    constructor() {
-        const ret = wasm.wasmwalletslip_new_();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
+    set_spent(spent) {
+        wasm.wasmwalletslip_set_spent(this.__wbg_ptr, spent);
     }
 }
 
@@ -2658,27 +2657,19 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_wasmtransaction_new = function(arg0) {
-        const ret = WasmTransaction.__wrap(arg0);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmslip_new = function(arg0) {
-        const ret = WasmSlip.__wrap(arg0);
+    imports.wbg.__wbg_wasmwallet_new = function(arg0) {
+        const ret = WasmWallet.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmpeer_new = function(arg0) {
-        const ret = WasmPeer.__wrap(arg0);
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
@@ -2689,77 +2680,97 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
+    imports.wbg.__wbg_wasmtransaction_new = function(arg0) {
+        const ret = WasmTransaction.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmblockchain_new = function(arg0) {
-        const ret = WasmBlockchain.__wrap(arg0);
+    imports.wbg.__wbg_wasmslip_new = function(arg0) {
+        const ret = WasmSlip.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmwallet_new = function(arg0) {
-        const ret = WasmWallet.__wrap(arg0);
+    imports.wbg.__wbg_wasmwalletslip_new = function(arg0) {
+        const ret = WasmWalletSlip.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmbalancesnapshot_new = function(arg0) {
-        const ret = WasmBalanceSnapshot.__wrap(arg0);
+    imports.wbg.__wbg_wasmnft_new = function(arg0) {
+        const ret = WasmNFT.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_wasmblock_new = function(arg0) {
         const ret = WasmBlock.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmwalletslip_new = function(arg0) {
-        const ret = WasmWalletSlip.__wrap(arg0);
+    imports.wbg.__wbg_wasmpeer_new = function(arg0) {
+        const ret = WasmPeer.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_wasmnft_new = function(arg0) {
-        const ret = WasmNFT.__wrap(arg0);
+    imports.wbg.__wbg_wasmbalancesnapshot_new = function(arg0) {
+        const ret = WasmBalanceSnapshot.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_wasmblockchain_new = function(arg0) {
+        const ret = WasmBlockchain.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = getObject(arg0);
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_in = function(arg0, arg1) {
+        const ret = getObject(arg0) in getObject(arg1);
+        return ret;
+    };
     imports.wbg.__wbg_wasmhop_new = function(arg0) {
         const ret = WasmHop.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_wasmpeerservice_new = function(arg0) {
         const ret = WasmPeerService.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_sendmessage_2ec021f2331a30ec = function(arg0, arg1) {
-        MsgHandler.send_message(takeObject(arg0), getObject(arg1));
-    };
-    imports.wbg.__wbg_sendmessagetoall_ed21e40a37b3756d = function(arg0, arg1) {
-        MsgHandler.send_message_to_all(getObject(arg0), getObject(arg1));
-    };
-    imports.wbg.__wbg_connecttopeer_d9c0012333c1437e = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_flushdata_43f1541fff3d78bd = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
         try {
             deferred0_0 = arg0;
             deferred0_1 = arg1;
-            const ret = MsgHandler.connect_to_peer(getStringFromWasm0(arg0, arg1), takeObject(arg2));
-            return addHeapObject(ret);
+            MsgHandler.flush_data(getStringFromWasm0(arg0, arg1));
         } finally {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
-    }, arguments) };
-    imports.wbg.__wbg_disconnectfrompeer_3d1d80c79865ac44 = function() { return handleError(function (arg0) {
-        const ret = MsgHandler.disconnect_from_peer(takeObject(arg0));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_fetchblockfrompeer_b7db05d9da1ee6e5 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    };
+    imports.wbg.__wbg_readvalue_0a9c92750448f1d1 = function() { return handleError(function (arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
         try {
-            deferred0_0 = arg2;
-            deferred0_1 = arg3;
-            const ret = MsgHandler.fetch_block_from_peer(getObject(arg0), takeObject(arg1), getStringFromWasm0(arg2, arg3), takeObject(arg4));
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            const ret = MsgHandler.read_value(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         } finally {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     }, arguments) };
-    imports.wbg.__wbg_writevalue_a7c9fd75e5362a0a = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_loadwallet_5cd451ac436ab682 = function() {
+        MsgHandler.load_wallet();
+    };
+    imports.wbg.__wbg_savewallet_6826e875e5dd251b = function() {
+        MsgHandler.save_wallet();
+    };
+    imports.wbg.__wbg_writevalue_cf07df01ae9d9d9b = function(arg0, arg1, arg2) {
         let deferred0_0;
         let deferred0_1;
         try {
@@ -2770,7 +2781,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_appendvalue_47a9f88e91fb3f21 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_appendvalue_3d3f4ddc7cd7f668 = function(arg0, arg1, arg2) {
         let deferred0_0;
         let deferred0_1;
         try {
@@ -2781,78 +2792,72 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_flushdata_b5e6923b95569717 = function(arg0, arg1) {
-        let deferred0_0;
-        let deferred0_1;
-        try {
-            deferred0_0 = arg0;
-            deferred0_1 = arg1;
-            MsgHandler.flush_data(getStringFromWasm0(arg0, arg1));
-        } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-        }
-    };
-    imports.wbg.__wbg_readvalue_cce66abba4678860 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_removevalue_f5900816b911805e = function() { return handleError(function (arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
         try {
             deferred0_0 = arg0;
             deferred0_1 = arg1;
-            const ret = MsgHandler.read_value(getStringFromWasm0(arg0, arg1));
+            const ret = MsgHandler.remove_value(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         } finally {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     }, arguments) };
-    imports.wbg.__wbg_loadblockfilelist_6ee195b852fb0251 = function() { return handleError(function () {
-        const ret = MsgHandler.load_block_file_list();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_isexistingfile_2b9a4fbeaf73b278 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_sendmessage_6d75e3e0b6cbcdea = function(arg0, arg1) {
+        MsgHandler.send_message(takeObject(arg0), getObject(arg1));
+    };
+    imports.wbg.__wbg_connecttopeer_0dbfd6477b38b460 = function() { return handleError(function (arg0, arg1, arg2) {
         let deferred0_0;
         let deferred0_1;
         try {
             deferred0_0 = arg0;
             deferred0_1 = arg1;
-            const ret = MsgHandler.is_existing_file(getStringFromWasm0(arg0, arg1));
+            const ret = MsgHandler.connect_to_peer(getStringFromWasm0(arg0, arg1), takeObject(arg2));
             return addHeapObject(ret);
         } finally {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     }, arguments) };
-    imports.wbg.__wbg_removevalue_3b721b1437117d87 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_getmyservices_671fa3941c07e37c = function() {
+        const ret = MsgHandler.get_my_services();
+        _assertClass(ret, WasmPeerServiceList);
+        var ptr1 = ret.__destroy_into_raw();
+        return ptr1;
+    };
+    imports.wbg.__wbg_isexistingfile_9c5802df7eec1b8c = function() { return handleError(function (arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
         try {
             deferred0_0 = arg0;
             deferred0_1 = arg1;
-            const ret = MsgHandler.remove_value(getStringFromWasm0(arg0, arg1));
+            const ret = MsgHandler.is_existing_file(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         } finally {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     }, arguments) };
-    imports.wbg.__wbg_ensureblockdirectoryexists_fa8ada2200733e99 = function() { return handleError(function (arg0, arg1) {
-        let deferred0_0;
-        let deferred0_1;
-        try {
-            deferred0_0 = arg0;
-            deferred0_1 = arg1;
-            MsgHandler.ensure_block_directory_exists(getStringFromWasm0(arg0, arg1));
-        } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-        }
-    }, arguments) };
-    imports.wbg.__wbg_processapicall_5004afd43c1ee680 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_processapicall_84802524f4b72626 = function(arg0, arg1, arg2) {
         MsgHandler.process_api_call(takeObject(arg0), arg1 >>> 0, takeObject(arg2));
     };
-    imports.wbg.__wbg_processapisuccess_92a95540a6660a60 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_processapierror_d543c65b7ba51917 = function(arg0, arg1, arg2) {
+        MsgHandler.process_api_error(takeObject(arg0), arg1 >>> 0, takeObject(arg2));
+    };
+    imports.wbg.__wbg_processapisuccess_346f01f1e249ab95 = function(arg0, arg1, arg2) {
         MsgHandler.process_api_success(takeObject(arg0), arg1 >>> 0, takeObject(arg2));
     };
-    imports.wbg.__wbg_processapierror_d8c1fa7448823bc2 = function(arg0, arg1, arg2) {
-        MsgHandler.process_api_error(takeObject(arg0), arg1 >>> 0, takeObject(arg2));
+    imports.wbg.__wbg_sendmessagetoall_8b367c13a928c498 = function(arg0, arg1) {
+        MsgHandler.send_message_to_all(getObject(arg0), getObject(arg1));
     };
-    imports.wbg.__wbg_sendinterfaceevent_563825bcd92676c7 = function(arg0, arg1, arg2, arg3, arg4) {
+    imports.wbg.__wbg_disconnectfrompeer_eb1d4acfd8e133d3 = function() { return handleError(function (arg0) {
+        const ret = MsgHandler.disconnect_from_peer(takeObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_loadblockfilelist_e8a6bbf7850e77ec = function() { return handleError(function () {
+        const ret = MsgHandler.load_block_file_list();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_sendinterfaceevent_478dfe7c1d77edc1 = function(arg0, arg1, arg2, arg3, arg4) {
         let deferred0_0;
         let deferred0_1;
         let deferred1_0;
@@ -2868,7 +2873,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     };
-    imports.wbg.__wbg_sendblocksuccess_2ba6e16e88f766bc = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_sendblocksuccess_50f30a221c95ccb2 = function(arg0, arg1, arg2) {
         let deferred0_0;
         let deferred0_1;
         try {
@@ -2879,10 +2884,10 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_sendwalletupdate_2750f81611d6d46b = function() {
+    imports.wbg.__wbg_sendwalletupdate_f56f83f3e07b49a9 = function() {
         MsgHandler.send_wallet_update();
     };
-    imports.wbg.__wbg_sendnewversionalert_55eefbff860ae87a = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_sendnewversionalert_cf706b447638507f = function(arg0, arg1, arg2) {
         let deferred0_0;
         let deferred0_1;
         try {
@@ -2893,41 +2898,35 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_sendblockfetchstatusevent_f6dacd96583f8cf9 = function(arg0) {
+    imports.wbg.__wbg_sendblockfetchstatusevent_34b0e8fb201fbfc5 = function(arg0) {
         MsgHandler.send_block_fetch_status_event(BigInt.asUintN(64, arg0));
     };
-    imports.wbg.__wbg_sendnewchaindetectedevent_be9dfef507784bbd = function() {
+    imports.wbg.__wbg_sendnewchaindetectedevent_3ebfc9ce48ce2f00 = function() {
         MsgHandler.send_new_chain_detected_event();
     };
-    imports.wbg.__wbg_savewallet_ffb2a491b1f66b51 = function() {
-        MsgHandler.save_wallet();
-    };
-    imports.wbg.__wbg_loadwallet_1977a51ad3fcae42 = function() {
-        MsgHandler.load_wallet();
-    };
-    imports.wbg.__wbg_getmyservices_88ebd4bb428eae73 = function() {
-        const ret = MsgHandler.get_my_services();
-        _assertClass(ret, WasmPeerServiceList);
-        var ptr1 = ret.__destroy_into_raw();
-        return ptr1;
-    };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_is_object = function(arg0) {
-        const val = getObject(arg0);
-        const ret = typeof(val) === 'object' && val !== null;
-        return ret;
-    };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
-    };
-    imports.wbg.__wbindgen_in = function(arg0, arg1) {
-        const ret = getObject(arg0) in getObject(arg1);
-        return ret;
-    };
+    imports.wbg.__wbg_fetchblockfrompeer_42bdb36ab5eb6374 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg2;
+            deferred0_1 = arg3;
+            const ret = MsgHandler.fetch_block_from_peer(getObject(arg0), takeObject(arg1), getStringFromWasm0(arg2, arg3), takeObject(arg4));
+            return addHeapObject(ret);
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    }, arguments) };
+    imports.wbg.__wbg_ensureblockdirectoryexists_2eeab9246fcb6206 = function() { return handleError(function (arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            MsgHandler.ensure_block_directory_exists(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    }, arguments) };
     imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
         const ret = getObject(arg0) == getObject(arg1);
         return ret;
@@ -2947,14 +2946,8 @@ function __wbg_get_imports() {
         const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cb_drop = function(arg0) {
-        const obj = takeObject(arg0).original;
-        if (obj.cnt-- == 1) {
-            obj.a = 0;
-            return true;
-        }
-        const ret = false;
-        return ret;
+    imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
+        queueMicrotask(getObject(arg0));
     };
     imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
         const ret = getObject(arg0).queueMicrotask;
@@ -2964,8 +2957,14 @@ function __wbg_get_imports() {
         const ret = typeof(getObject(arg0)) === 'function';
         return ret;
     };
-    imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
-        queueMicrotask(getObject(arg0));
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        const ret = false;
+        return ret;
     };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
         const ret = new Error();
@@ -2989,18 +2988,18 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_debug_7d879afce6cf56cb = function(arg0, arg1, arg2, arg3) {
-        console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
-    imports.wbg.__wbg_error_696630710900ec44 = function(arg0, arg1, arg2, arg3) {
-        console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
-    };
     imports.wbg.__wbg_info_80803d9a3f0aad16 = function(arg0, arg1, arg2, arg3) {
         console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
     };
     imports.wbg.__wbg_warn_5d3f783b0bae8943 = function(arg0, arg1, arg2, arg3) {
         console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
     };
+    imports.wbg.__wbg_debug_7d879afce6cf56cb = function(arg0, arg1, arg2, arg3) {
+        console.debug(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
+    imports.wbg.__wbg_error_696630710900ec44 = function(arg0, arg1, arg2, arg3) {
+        console.error(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
+    };
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -3035,83 +3034,76 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
-    imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
-        const ret = getObject(arg0)[arg1 >>> 0];
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
-        const ret = getObject(arg0).length;
+    imports.wbg.__wbg_valueOf_b4771ea2a1ea7469 = function(arg0) {
+        const ret = getObject(arg0).valueOf();
         return ret;
     };
     imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_valueOf_b4771ea2a1ea7469 = function(arg0) {
-        const ret = getObject(arg0).valueOf();
-        return ret;
-    };
     imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
-        const ret = getObject(arg0).next;
+    imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).next();
+    imports.wbg.__wbg_new_5b2a2842270c66e6 = function(arg0) {
+        const ret = new BigUint64Array(getObject(arg0));
         return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
-        const ret = getObject(arg0).done;
-        return ret;
     };
-    imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
-        const ret = getObject(arg0).value;
+    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
+        const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
-        const ret = Symbol.iterator;
+    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.get(getObject(arg0), getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
-        const ret = self.self;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
-        const ret = window.window;
+    imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
-        const ret = globalThis.globalThis;
+    };
+    imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+    };
+    imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
-        const ret = global.global;
+    };
+    imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
+        const ret = getObject(arg0).done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
+        const ret = getObject(arg0).value;
         return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_newwithlength_66ae46612e7f0234 = function(arg0) {
-        const ret = new Array(arg0 >>> 0);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_f3784c11ba58e531 = function(arg0, arg1, arg2) {
+        const ret = new BigUint64Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
-        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    imports.wbg.__wbg_set_dc7aa8fdca321349 = function(arg0, arg1, arg2) {
+        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_isArray_2ab64d95e09ea0ae = function(arg0) {
-        const ret = Array.isArray(getObject(arg0));
+    imports.wbg.__wbg_length_a641162bc8055216 = function(arg0) {
+        const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
+    imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
         return ret;
     };
     imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
@@ -3124,26 +3116,57 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    imports.wbg.__wbg_now_3014639a94423537 = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_newwithlength_66ae46612e7f0234 = function(arg0) {
+        const ret = new Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_2ab64d95e09ea0ae = function(arg0) {
+        const ret = Array.isArray(getObject(arg0));
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
+        const ret = Symbol.iterator;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
+        const ret = self.self;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_call_8e7cb608789c2528 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+    imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
+        const ret = window.window;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_call_938992c832f74314 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+    imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_now_3014639a94423537 = function() {
-        const ret = Date.now();
-        return ret;
-    };
-    imports.wbg.__wbg_toString_198eafe4f2ea2733 = function(arg0) {
-        const ret = getObject(arg0).toString();
+    imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
+        const ret = global.global;
         return addHeapObject(ret);
-    };
+    }, arguments) };
+    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
@@ -3151,7 +3174,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_435(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_393(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -3162,66 +3185,49 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
-    imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
-        const ret = Promise.resolve(getObject(arg0));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
-        const ret = getObject(arg0).buffer;
+    imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
-        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
-        const ret = new Uint8Array(getObject(arg0));
+    }, arguments) };
+    imports.wbg.__wbg_call_8e7cb608789c2528 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
         return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
-        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
-    };
-    imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_f3784c11ba58e531 = function(arg0, arg1, arg2) {
-        const ret = new BigUint64Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+    }, arguments) };
+    imports.wbg.__wbg_call_938992c832f74314 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
         return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new_5b2a2842270c66e6 = function(arg0) {
-        const ret = new BigUint64Array(getObject(arg0));
+    }, arguments) };
+    imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
+        const ret = getObject(arg0).next;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_dc7aa8fdca321349 = function(arg0, arg1, arg2) {
-        getObject(arg0).set(getObject(arg1), arg2 >>> 0);
-    };
-    imports.wbg.__wbg_length_a641162bc8055216 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Uint8Array;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
-        const ret = new Uint8Array(arg0 >>> 0);
+    imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_toString_198eafe4f2ea2733 = function(arg0) {
+        const ret = getObject(arg0).toString();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
-        const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
         const ret = debugString(getObject(arg1));
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3229,15 +3235,8 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_memory = function() {
-        const ret = wasm.memory;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_closure_wrapper1625 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 580, __wbg_adapter_38);
+    imports.wbg.__wbindgen_closure_wrapper1618 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 574, __wbg_adapter_38);
         return addHeapObject(ret);
     };