lumina-node-wasm 0.10.3 → 0.12.0

package/lumina_node_wasm_bg.js

@@ -4,8 +4,6 @@ export function __wbg_set_wasm(val) {
 }
 
 
-let WASM_VECTOR_LEN = 0;
-
 let cachedUint8ArrayMemory0 = null;
 
 function getUint8ArrayMemory0() {
@@ -15,9 +13,34 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
 
-let cachedTextEncoder = new lTextEncoder('utf-8');
+const cachedTextEncoder = new lTextEncoder('utf-8');
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -95,17 +118,6 @@ function handleError(f, args) {
     }
 }
 
-const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
-
-let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -122,59 +134,6 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => {
-    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b)
-});
-
-function makeClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        try {
-            return f(state.a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
-                state.a = 0;
-                CLOSURE_DTORS.unregister(state);
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -240,6 +199,40 @@ function debugString(val) {
     return className;
 }
 
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(
+state => {
+    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
+}
+);
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
+                CLOSURE_DTORS.unregister(state);
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -251,6 +244,40 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function makeClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        try {
+            return f(state.a, state.b, ...args);
+        } finally {
+            if (--state.cnt === 0) {
+                wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b); state.a = 0;
+                CLOSURE_DTORS.unregister(state);
+            }
+        }
+    };
+    real.original = state;
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+/**
+ * Set up a logging layer that direct logs to the browser's console.
+ */
+export function setup_logging() {
+    wasm.setup_logging();
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -261,18 +288,6 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-/**
- * Set up a logging layer that direct logs to the browser's console.
- */
-export function setup_logging() {
-    wasm.setup_logging();
-}
-
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_4.get(idx);
     wasm.__externref_table_dealloc(idx);
@@ -290,36 +305,41 @@ export function protoEncodeSignDoc(sign_doc) {
     return v1;
 }
 
-function __wbg_adapter_64(arg0, arg1, arg2) {
-    wasm.closure313_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_8(arg0, arg1, arg2) {
+    wasm.closure1785_externref_shim(arg0, arg1, arg2);
+}
+
+function __wbg_adapter_13(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h2abc87618de50089(arg0, arg1);
 }
 
-function __wbg_adapter_67(arg0, arg1, arg2) {
-    wasm.closure310_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_16(arg0, arg1, arg2) {
+    wasm.closure2977_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_70(arg0, arg1, arg2) {
-    wasm.closure1611_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_19(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hc000bd3f01dbb89a(arg0, arg1);
 }
 
-function __wbg_adapter_77(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7d3d89703686d48f(arg0, arg1);
+function __wbg_adapter_28(arg0, arg1, arg2) {
+    wasm.closure670_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_80(arg0, arg1, arg2) {
-    wasm.closure2684_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_33(arg0, arg1, arg2) {
+    wasm.closure2875_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_83(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h70a5324370145de4(arg0, arg1);
+function __wbg_adapter_38(arg0, arg1, arg2) {
+    const ret = wasm.closure675_externref_shim(arg0, arg1, arg2);
+    return ret;
 }
 
-function __wbg_adapter_86(arg0, arg1, arg2) {
-    wasm.closure2809_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_47(arg0, arg1, arg2) {
+    wasm.closure673_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_985(arg0, arg1, arg2, arg3) {
-    wasm.closure2827_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_982(arg0, arg1, arg2, arg3) {
+    wasm.closure3002_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -694,7 +714,7 @@ export const TxPriority = Object.freeze({
 });
 /**
  * Represents state of the transaction in the mempool
- * @enum {0 | 1 | 2 | 3}
+ * @enum {0 | 1 | 2 | 3 | 4}
  */
 export const TxStatus = Object.freeze({
     /**
@@ -709,10 +729,14 @@ export const TxStatus = Object.freeze({
      * The transaction was evicted from the mempool.
      */
     Evicted: 2, "2": "Evicted",
+    /**
+     * The transaction was rejected
+     */
+    Rejected: 3, "3": "Rejected",
     /**
      * The transaction was committed into the block.
      */
-    Committed: 3, "3": "Committed",
+    Committed: 4, "4": "Committed",
 });
 /**
  * Types of votes
@@ -867,6 +891,17 @@ export class AbciQueryResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_abciqueryresponse_free(ptr, 0);
     }
+    /**
+     * The block height from which data was derived.
+     *
+     * Note that this is the height of the block containing the application's Merkle root hash,
+     * which represents the state as it was after committing the block at height - 1.
+     * @returns {bigint}
+     */
+    get height() {
+        const ret = wasm.abciqueryresponse_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * Response code.
      * @returns {ErrorCode}
@@ -1038,17 +1073,6 @@ export class AbciQueryResponse {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_abciqueryresponse_info(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * The block height from which data was derived.
-     *
-     * Note that this is the height of the block containing the application's Merkle root hash,
-     * which represents the state as it was after committing the block at height - 1.
-     * @returns {bigint}
-     */
-    get height() {
-        const ret = wasm.abciqueryresponse_height(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
 }
 
 const AccAddressFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -1879,21 +1903,21 @@ export class BroadcastMode {
         return BroadcastMode.__wrap(ret);
     }
     /**
-     * DEPRECATED: use `BroadcastMode` `Sync` instead,
-     * `BroadcastMode` `Block` is not supported by the SDK from v0.47.x onwards.
+     * `BroadcastMode` `Sync` defines a tx broadcasting mode where the client waits for
+     * a CheckTx execution response only.
      * @returns {BroadcastMode}
      */
-    static get Block() {
-        const ret = wasm.broadcastmode_Block();
+    static get Sync() {
+        const ret = wasm.broadcastmode_Sync();
         return BroadcastMode.__wrap(ret);
     }
     /**
-     * `BroadcastMode` `Sync` defines a tx broadcasting mode where the client waits for
-     * a CheckTx execution response only.
+     * DEPRECATED: use `BroadcastMode` `Sync` instead,
+     * `BroadcastMode` `Block` is not supported by the SDK from v0.47.x onwards.
      * @returns {BroadcastMode}
      */
-    static get Sync() {
-        const ret = wasm.broadcastmode_Sync();
+    static get Block() {
+        const ret = wasm.broadcastmode_Block();
         return BroadcastMode.__wrap(ret);
     }
     /**
@@ -2448,7 +2472,9 @@ export class ConflictingBlock {
 const ConnectionCountersSnapshotFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_connectioncounterssnapshot_free(ptr >>> 0, 1));
-
+/**
+ * Network connection information
+ */
 export class ConnectionCountersSnapshot {
 
     static __wrap(ptr) {
@@ -2657,7 +2683,7 @@ export class Data {
      * @returns {bigint}
      */
     get square_size() {
-        const ret = wasm.__wbg_get_commit_height(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_data_square_size(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -2665,7 +2691,7 @@ export class Data {
      * @param {bigint} arg0
      */
     set square_size(arg0) {
-        wasm.__wbg_set_commit_height(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_data_square_size(this.__wbg_ptr, arg0);
     }
     /**
      * Hash is the root of a binary Merkle tree where the leaves of the tree are
@@ -2772,51 +2798,59 @@ export class DataAvailabilityHeader {
         wasm.__wbg_dataavailabilityheader_free(ptr, 0);
     }
     /**
-     * Merkle roots of the [`ExtendedDataSquare`] rows.
-     * @returns {Array<any>}
+     * Get a root of the row with the given index.
+     * @param {number} row
+     * @returns {any}
      */
-    rowRoots() {
-        const ret = wasm.dataavailabilityheader_rowRoots(this.__wbg_ptr);
+    rowRoot(row) {
+        const ret = wasm.dataavailabilityheader_rowRoot(this.__wbg_ptr, row);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Merkle roots of the [`ExtendedDataSquare`] columns.
+     * Merkle roots of the [`ExtendedDataSquare`] rows.
      * @returns {Array<any>}
      */
-    columnRoots() {
-        const ret = wasm.dataavailabilityheader_columnRoots(this.__wbg_ptr);
+    rowRoots() {
+        const ret = wasm.dataavailabilityheader_rowRoots(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Get a root of the row with the given index.
-     * @param {number} row
+     * Get the a root of the column with the given index.
+     * @param {number} column
      * @returns {any}
      */
-    rowRoot(row) {
-        const ret = wasm.dataavailabilityheader_rowRoot(this.__wbg_ptr, row);
+    columnRoot(column) {
+        const ret = wasm.dataavailabilityheader_columnRoot(this.__wbg_ptr, column);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Get the a root of the column with the given index.
-     * @param {number} column
-     * @returns {any}
+     * Merkle roots of the [`ExtendedDataSquare`] columns.
+     * @returns {Array<any>}
      */
-    columnRoot(column) {
-        const ret = wasm.dataavailabilityheader_columnRoot(this.__wbg_ptr, column);
+    columnRoots() {
+        const ret = wasm.dataavailabilityheader_columnRoots(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Get the size of the [`ExtendedDataSquare`] for which this header was built.
+     * @returns {number}
+     */
+    squareWidth() {
+        const ret = wasm.dataavailabilityheader_squareWidth(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Compute the combined hash of all rows and columns.
      *
@@ -2830,14 +2864,6 @@ export class DataAvailabilityHeader {
         }
         return takeFromExternrefTable0(ret[0]);
     }
-    /**
-     * Get the size of the [`ExtendedDataSquare`] for which this header was built.
-     * @returns {number}
-     */
-    squareWidth() {
-        const ret = wasm.dataavailabilityheader_squareWidth(this.__wbg_ptr);
-        return ret;
-    }
 }
 
 const DuplicateVoteEvidenceFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3038,10 +3064,10 @@ export class ExtendedHeader {
 
     toJSON() {
         return {
-            dah: this.dah,
-            header: this.header,
-            commit: this.commit,
             validatorSet: this.validatorSet,
+            commit: this.commit,
+            header: this.header,
+            dah: this.dah,
         };
     }
 
@@ -3061,58 +3087,64 @@ export class ExtendedHeader {
         wasm.__wbg_extendedheader_free(ptr, 0);
     }
     /**
-     * Header of the block data availability.
-     * @returns {DataAvailabilityHeader}
-     */
-    get dah() {
-        const ret = wasm.__wbg_get_extendedheader_dah(this.__wbg_ptr);
-        return DataAvailabilityHeader.__wrap(ret);
-    }
-    /**
-     * Header of the block data availability.
-     * @param {DataAvailabilityHeader} arg0
-     */
-    set dah(arg0) {
-        _assertClass(arg0, DataAvailabilityHeader);
-        var ptr0 = arg0.__destroy_into_raw();
-        wasm.__wbg_set_extendedheader_dah(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * Clone a header producing a deep copy of it.
-     * @returns {ExtendedHeader}
+     * Decode protobuf encoded header and then validate it.
      */
-    clone() {
-        const ret = wasm.extendedheader_clone(this.__wbg_ptr);
-        return ExtendedHeader.__wrap(ret);
+    validate() {
+        const ret = wasm.extendedheader_validate(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Get the block height.
-     * @returns {bigint}
+     * Verify a chain of adjacent untrusted headers.
+     *
+     * # Note
+     *
+     * Provided headers will be consumed by this method, meaning
+     * they will no longer be accessible. If this behavior is not desired,
+     * consider using `ExtendedHeader.clone()`.
+     *
+     * ```js
+     * const genesis = hdr0;
+     * const headers = [hrd1, hdr2, hdr3];
+     * genesis.verifyRange(headers.map(h => h.clone()));
+     * ```
+     *
+     * # Errors
+     *
+     * If verification fails, this function will return an error with a reason of failure.
+     * This function will also return an error if untrusted headers are not adjacent
+     * to each other.
+     * @param {ExtendedHeader[]} untrusted
      */
-    height() {
-        const ret = wasm.extendedheader_height(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    verifyRange(untrusted) {
+        const ptr0 = passArrayJsValueToWasm0(untrusted, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.extendedheader_verifyRange(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Get the block time.
-     * @returns {number}
+     * Information about the set of validators commiting the block.
+     * @returns {any}
      */
-    time() {
-        const ret = wasm.extendedheader_time(this.__wbg_ptr);
+    get validatorSet() {
+        const ret = wasm.extendedheader_validatorSet(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0];
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Get the block hash.
+     * Get the hash of the previous header.
      * @returns {string}
      */
-    hash() {
+    previousHeaderHash() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.extendedheader_hash(this.__wbg_ptr);
+            const ret = wasm.extendedheader_previousHeaderHash(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3121,14 +3153,44 @@ export class ExtendedHeader {
         }
     }
     /**
-     * Get the hash of the previous header.
+     * Verify a chain of adjacent untrusted headers and make sure
+     * they are adjacent to `self`.
+     *
+     * # Note
+     *
+     * Provided headers will be consumed by this method, meaning
+     * they will no longer be accessible. If this behavior is not desired,
+     * consider using `ExtendedHeader.clone()`.
+     *
+     * ```js
+     * const genesis = hdr0;
+     * const headers = [hrd1, hdr2, hdr3];
+     * genesis.verifyAdjacentRange(headers.map(h => h.clone()));
+     * ```
+     *
+     * # Errors
+     *
+     * If verification fails, this function will return an error with a reason of failure.
+     * This function will also return an error if untrusted headers and `self` don't form contiguous range
+     * @param {ExtendedHeader[]} untrusted
+     */
+    verifyAdjacentRange(untrusted) {
+        const ptr0 = passArrayJsValueToWasm0(untrusted, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.extendedheader_verifyAdjacentRange(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Get the block hash.
      * @returns {string}
      */
-    previousHeaderHash() {
+    hash() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.extendedheader_previousHeaderHash(this.__wbg_ptr);
+            const ret = wasm.extendedheader_hash(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -3137,15 +3199,23 @@ export class ExtendedHeader {
         }
     }
     /**
-     * Tendermint block header.
-     * @returns {any}
+     * Get the block time.
+     * @returns {number}
      */
-    get header() {
-        const ret = wasm.extendedheader_header(this.__wbg_ptr);
+    time() {
+        const ret = wasm.extendedheader_time(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return ret[0];
+    }
+    /**
+     * Clone a header producing a deep copy of it.
+     * @returns {ExtendedHeader}
+     */
+    clone() {
+        const ret = wasm.extendedheader_clone(this.__wbg_ptr);
+        return ExtendedHeader.__wrap(ret);
     }
     /**
      * Commit metadata and signatures from validators committing the block.
@@ -3159,24 +3229,23 @@ export class ExtendedHeader {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Information about the set of validators commiting the block.
+     * Tendermint block header.
      * @returns {any}
      */
-    get validatorSet() {
-        const ret = wasm.extendedheader_validatorSet(this.__wbg_ptr);
+    get header() {
+        const ret = wasm.extendedheader_header(this.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Decode protobuf encoded header and then validate it.
+     * Get the block height.
+     * @returns {bigint}
      */
-    validate() {
-        const ret = wasm.extendedheader_validate(this.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    height() {
+        const ret = wasm.extendedheader_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
      * Verify a chain of adjacent untrusted headers and make sure
@@ -3196,64 +3265,21 @@ export class ExtendedHeader {
         }
     }
     /**
-     * Verify a chain of adjacent untrusted headers.
-     *
-     * # Note
-     *
-     * Provided headers will be consumed by this method, meaning
-     * they will no longer be accessible. If this behavior is not desired,
-     * consider using `ExtendedHeader.clone()`.
-     *
-     * ```js
-     * const genesis = hdr0;
-     * const headers = [hrd1, hdr2, hdr3];
-     * genesis.verifyRange(headers.map(h => h.clone()));
-     * ```
-     *
-     * # Errors
-     *
-     * If verification fails, this function will return an error with a reason of failure.
-     * This function will also return an error if untrusted headers are not adjacent
-     * to each other.
-     * @param {ExtendedHeader[]} untrusted
+     * Header of the block data availability.
+     * @returns {DataAvailabilityHeader}
      */
-    verifyRange(untrusted) {
-        const ptr0 = passArrayJsValueToWasm0(untrusted, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.extendedheader_verifyRange(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    get dah() {
+        const ret = wasm.__wbg_get_extendedheader_dah(this.__wbg_ptr);
+        return DataAvailabilityHeader.__wrap(ret);
     }
     /**
-     * Verify a chain of adjacent untrusted headers and make sure
-     * they are adjacent to `self`.
-     *
-     * # Note
-     *
-     * Provided headers will be consumed by this method, meaning
-     * they will no longer be accessible. If this behavior is not desired,
-     * consider using `ExtendedHeader.clone()`.
-     *
-     * ```js
-     * const genesis = hdr0;
-     * const headers = [hrd1, hdr2, hdr3];
-     * genesis.verifyAdjacentRange(headers.map(h => h.clone()));
-     * ```
-     *
-     * # Errors
-     *
-     * If verification fails, this function will return an error with a reason of failure.
-     * This function will also return an error if untrusted headers and `self` don't form contiguous range
-     * @param {ExtendedHeader[]} untrusted
+     * Header of the block data availability.
+     * @param {DataAvailabilityHeader} arg0
      */
-    verifyAdjacentRange(untrusted) {
-        const ptr0 = passArrayJsValueToWasm0(untrusted, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.extendedheader_verifyAdjacentRange(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    set dah(arg0) {
+        _assertClass(arg0, DataAvailabilityHeader);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_extendedheader_dah(this.__wbg_ptr, ptr0);
     }
 }
 
@@ -3531,7 +3557,7 @@ const GrpcClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_grpcclient_free(ptr >>> 0, 1));
 /**
- * Celestia GRPC client
+ * Celestia gRPC client, for builder see [`GrpcClientBuilder`]
  */
 export class GrpcClient {
 
@@ -3555,22 +3581,27 @@ export class GrpcClient {
         wasm.__wbg_grpcclient_free(ptr, 0);
     }
     /**
-     * Create a new client connected with the given `url`
-     * @param {string} url
-     * @returns {Promise<GrpcClient>}
+     * Issue a direct ABCI query to the application
+     * @param {Uint8Array} data
+     * @param {string} path
+     * @param {bigint} height
+     * @param {boolean} prove
+     * @returns {Promise<AbciQueryResponse>}
      */
-    static new(url) {
-        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    abciQuery(data, path, height, prove) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_new(ptr0, len0);
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_abciQuery(this.__wbg_ptr, ptr0, len0, ptr1, len1, height, prove);
         return ret;
     }
     /**
-     * Get auth params
-     * @returns {Promise<AuthParams>}
+     * AppVersion of the client
+     * @returns {Promise<AppVersion>}
      */
-    get_auth_params() {
-        const ret = wasm.grpcclient_get_auth_params(this.__wbg_ptr);
+    get appVersion() {
+        const ret = wasm.grpcclient_appVersion(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3578,80 +3609,122 @@ export class GrpcClient {
      * @param {string} account
      * @returns {Promise<BaseAccount>}
      */
-    get_account(account) {
+    getAccount(account) {
         const ptr0 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_get_account(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Get accounts
-     * @returns {Promise<BaseAccount[]>}
-     */
-    get_accounts() {
-        const ret = wasm.grpcclient_get_accounts(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get balance of coins with bond denom for the given address, together with a proof,
-     * and verify the returned balance against the corresponding block's app hash.
-     *
-     * NOTE: the balance returned is the balance reported by the parent block of
-     * the provided header. This is due to the fact that for block N, the block's
-     * app hash is the result of applying the previous block's transaction list.
-     * @param {string} address
-     * @param {ExtendedHeader} header
-     * @returns {Promise<Coin>}
-     */
-    get_verified_balance(address, header) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(header, ExtendedHeader);
-        const ret = wasm.grpcclient_get_verified_balance(this.__wbg_ptr, ptr0, len0, header.__wbg_ptr);
+        const ret = wasm.grpcclient_getAccount(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Get balance of coins with given denom
+     * Retrieves the Celestia coin balance for the given address.
      * @param {string} address
      * @param {string} denom
      * @returns {Promise<Coin>}
      */
-    get_balance(address, denom) {
+    getBalance(address, denom) {
         const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_get_balance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm.grpcclient_getBalance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
-     * Get balance of all coins
-     * @param {string} address
-     * @returns {Promise<Coin[]>}
+     * Broadcast prepared and serialised transaction
+     * @param {Uint8Array} tx_bytes
+     * @param {BroadcastMode} mode
+     * @returns {Promise<TxResponse>}
      */
-    get_all_balances(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    broadcastTx(tx_bytes, mode) {
+        const ptr0 = passArray8ToWasm0(tx_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_get_all_balances(this.__wbg_ptr, ptr0, len0);
+        _assertClass(mode, BroadcastMode);
+        const ret = wasm.grpcclient_broadcastTx(this.__wbg_ptr, ptr0, len0, mode.__wbg_ptr);
         return ret;
     }
     /**
-     * Get balance of all spendable coins
-     * @param {string} address
-     * @returns {Promise<Coin[]>}
+     * Get accounts
+     * @returns {Promise<BaseAccount[]>}
      */
-    get_spendable_balances(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    getAccounts() {
+        const ret = wasm.grpcclient_getAccounts(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Submit blobs to the celestia network.
+     *
+     * # Example
+     * ```js
+     * const ns = Namespace.newV0(new Uint8Array([97, 98, 99]));
+     * const data = new Uint8Array([100, 97, 116, 97]);
+     * const blob = new Blob(ns, data, AppVersion.latest());
+     *
+     * const txInfo = await txClient.submitBlobs([blob]);
+     * await txClient.submitBlobs([blob], { gasLimit: 100000n, gasPrice: 0.02, memo: "foo" });
+     * ```
+     *
+     * # Note
+     *
+     * Provided blobs will be consumed by this method, meaning
+     * they will no longer be accessible. If this behavior is not desired,
+     * consider using `Blob.clone()`.
+     *
+     * ```js
+     * const blobs = [blob1, blob2, blob3];
+     * await txClient.submitBlobs(blobs.map(b => b.clone()));
+     * ```
+     * @param {Blob[]} blobs
+     * @param {TxConfig | null} [tx_config]
+     * @returns {Promise<TxInfo>}
+     */
+    submitBlobs(blobs, tx_config) {
+        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_get_spendable_balances(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.grpcclient_submitBlobs(this.__wbg_ptr, ptr0, len0, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
         return ret;
     }
     /**
-     * Get total supply
-     * @returns {Promise<Coin[]>}
+     * Submit message to the celestia network.
+     *
+     * # Example
+     * ```js
+     * import { Registry } from "@cosmjs/proto-signing";
+     *
+     * const registry = new Registry();
+     * const sendMsg = {
+     *   typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+     *   value: {
+     *     fromAddress: "celestia169s50psyj2f4la9a2235329xz7rk6c53zhw9mm",
+     *     toAddress: "celestia1t52q7uqgnjfzdh3wx5m5phvma3umrq8k6tq2p9",
+     *     amount: [{ denom: "utia", amount: "10000" }],
+     *   },
+     * };
+     * const sendMsgAny = registry.encodeAsAny(sendMsg);
+     *
+     * const txInfo = await txClient.submitMessage(sendMsgAny);
+     * ```
+     * @param {ProtoAny} message
+     * @param {TxConfig | null} [tx_config]
+     * @returns {Promise<TxInfo>}
+     */
+    submitMessage(message, tx_config) {
+        const ret = wasm.grpcclient_submitMessage(this.__wbg_ptr, message, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
+        return ret;
+    }
+    /**
+     * Get auth params
+     * @returns {Promise<AuthParams>}
+     */
+    getAuthParams() {
+        const ret = wasm.grpcclient_getAuthParams(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get blob params
+     * @returns {Promise<BlobParams>}
      */
-    get_total_supply() {
-        const ret = wasm.grpcclient_get_total_supply(this.__wbg_ptr);
+    getBlobParams() {
+        const ret = wasm.grpcclient_getBlobParams(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3662,12 +3735,44 @@ export class GrpcClient {
         const ret = wasm.grpcclient_get_node_config(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Get balance of all coins
+     * @param {string} address
+     * @returns {Promise<Coin[]>}
+     */
+    getAllBalances(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_getAllBalances(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Get latest block
      * @returns {Promise<Block>}
      */
-    get_latest_block() {
-        const ret = wasm.grpcclient_get_latest_block(this.__wbg_ptr);
+    getLatestBlock() {
+        const ret = wasm.grpcclient_getLatestBlock(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get total supply
+     * @returns {Promise<Coin[]>}
+     */
+    getTotalSupply() {
+        const ret = wasm.grpcclient_getTotalSupply(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Estimate gas price for given transaction priority based
+     * on the gas prices of the transactions in the last five blocks.
+     *
+     * If no transaction is found in the last five blocks, return the network
+     * min gas price.
+     * @param {TxPriority} priority
+     * @returns {Promise<number>}
+     */
+    estimateGasPrice(priority) {
+        const ret = wasm.grpcclient_estimateGasPrice(this.__wbg_ptr, priority);
         return ret;
     }
     /**
@@ -3675,37 +3780,39 @@ export class GrpcClient {
      * @param {bigint} height
      * @returns {Promise<Block>}
      */
-    get_block_by_height(height) {
-        const ret = wasm.grpcclient_get_block_by_height(this.__wbg_ptr, height);
+    getBlockByHeight(height) {
+        const ret = wasm.grpcclient_getBlockByHeight(this.__wbg_ptr, height);
         return ret;
     }
     /**
-     * Issue a direct ABCI query to the application
-     * @param {Uint8Array} data
-     * @param {string} path
-     * @param {bigint} height
-     * @param {boolean} prove
-     * @returns {Promise<AbciQueryResponse>}
+     * Retrieves the verified Celestia coin balance for the address.
+     *
+     * # Notes
+     *
+     * This returns the verified balance which is the one that was reported by
+     * the previous network block. In other words, if you transfer some coins,
+     * you need to wait 1 more block in order to see the new balance. If you want
+     * something more immediate then use [`GrpcClient::get_balance`].
+     * @param {string} address
+     * @param {ExtendedHeader} header
+     * @returns {Promise<Coin>}
      */
-    abci_query(data, path, height, prove) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    getVerifiedBalance(address, header) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_abci_query(this.__wbg_ptr, ptr0, len0, ptr1, len1, height, prove);
+        _assertClass(header, ExtendedHeader);
+        const ret = wasm.grpcclient_getVerifiedBalance(this.__wbg_ptr, ptr0, len0, header.__wbg_ptr);
         return ret;
     }
     /**
-     * Broadcast prepared and serialised transaction
-     * @param {Uint8Array} tx_bytes
-     * @param {BroadcastMode} mode
-     * @returns {Promise<TxResponse>}
+     * Get balance of all spendable coins
+     * @param {string} address
+     * @returns {Promise<Coin[]>}
      */
-    broadcast_tx(tx_bytes, mode) {
-        const ptr0 = passArray8ToWasm0(tx_bytes, wasm.__wbindgen_malloc);
+    getSpendableBalances(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        _assertClass(mode, BroadcastMode);
-        const ret = wasm.grpcclient_broadcast_tx(this.__wbg_ptr, ptr0, len0, mode.__wbg_ptr);
+        const ret = wasm.grpcclient_getSpendableBalances(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -3713,10 +3820,18 @@ export class GrpcClient {
      * @param {string} hash
      * @returns {Promise<GetTxResponse>}
      */
-    get_tx(hash) {
+    getTx(hash) {
         const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_get_tx(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.grpcclient_getTx(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Chain id of the client
+     * @returns {Promise<string>}
+     */
+    get chainId() {
+        const ret = wasm.grpcclient_chainId(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3731,26 +3846,185 @@ export class GrpcClient {
         return ret;
     }
     /**
-     * Get blob params
-     * @returns {Promise<BlobParams>}
+     * Create a builder for [`GrpcClient`] connected to `url`
+     * @param {string} url
+     * @returns {GrpcClientBuilder}
      */
-    get_blob_params() {
-        const ret = wasm.grpcclient_get_blob_params(this.__wbg_ptr);
-        return ret;
+    static withUrl(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_withUrl(ptr0, len0);
+        return GrpcClientBuilder.__wrap(ret);
     }
     /**
      * Get status of the transaction
      * @param {string} hash
      * @returns {Promise<TxStatusResponse>}
      */
-    tx_status(hash) {
+    txStatus(hash) {
         const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_tx_status(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.grpcclient_txStatus(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
 }
 
+const GrpcClientBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_grpcclientbuilder_free(ptr >>> 0, 1));
+/**
+ * Builder for [`GrpcClient`] and [`TxClient`].
+ *
+ * Url must point to a [grpc-web proxy](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md).
+ *
+ * # Keyless client example
+ *
+ * ```js
+ * const client = await GrpcClient
+ *   .withUrl("http://127.0.0.1:18080")
+ *   .build()
+ * ```
+ *
+ * # Transaction client examples
+ *
+ * ## Example with noble/curves
+ * ```js
+ * import { secp256k1 } from "@noble/curves/secp256k1";
+ *
+ * const privKey = "fdc8ac75dfa1c142dbcba77938a14dd03078052ce0b49a529dcf72a9885a3abb";
+ * const pubKey = secp256k1.getPublicKey(privKey);
+ *
+ * const signer = (signDoc) => {
+ *   const bytes = protoEncodeSignDoc(signDoc);
+ *   const sig = secp256k1.sign(bytes, privKey, { prehash: true });
+ *   return sig.toCompactRawBytes();
+ * };
+ *
+ * const client = await GrpcClient
+ *   .withUrl("http://127.0.0.1:18080")
+ *   .withPubkeyAndSigner(pubKey, signer)
+ *   .build();
+ * ```
+ *
+ * ## Example with leap wallet
+ * ```js
+ * await window.leap.enable("mocha-4")
+ * const keys = await window.leap.getKey("mocha-4")
+ *
+ * const signer = (signDoc) => {
+ *   return window.leap.signDirect("mocha-4", keys.bech32Address, signDoc, { preferNoSetFee: true })
+ *     .then(sig => Uint8Array.from(atob(sig.signature.signature), c => c.charCodeAt(0)))
+ * }
+ *
+ * const client = await GrpcClient
+ *   .withUrl("http://127.0.0.1:18080")
+ *   .withPubkeyAndSigner(keys.pubKey, signer)
+ *   .build()
+ * ```
+ */
+export class GrpcClientBuilder {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GrpcClientBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        GrpcClientBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GrpcClientBuilderFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_grpcclientbuilder_free(ptr, 0);
+    }
+    /**
+     * Appends ascii metadata to all requests made by the client.
+     *
+     * Note that this method **consumes** builder and returns updated instance of it.
+     * Make sure to re-assign it if you keep builder in a variable.
+     * @param {string} key
+     * @param {string} value
+     * @returns {GrpcClientBuilder}
+     */
+    withMetadata(key, value) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclientbuilder_withMetadata(ptr, ptr0, len0, ptr1, len1);
+        return GrpcClientBuilder.__wrap(ret);
+    }
+    /**
+     * Appends binary metadata to all requests made by the client.
+     *
+     * Keys for binary metadata must have `-bin` suffix.
+     *
+     * Note that this method **consumes** builder and returns updated instance of it.
+     * Make sure to re-assign it if you keep builder in a variable.
+     * @param {string} key
+     * @param {Uint8Array} value
+     * @returns {GrpcClientBuilder}
+     */
+    withMetadataBin(key, value) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclientbuilder_withMetadataBin(ptr, ptr0, len0, value);
+        return GrpcClientBuilder.__wrap(ret);
+    }
+    /**
+     * Add public key and signer to the client being built
+     *
+     * Note that this method **consumes** builder and returns updated instance of it.
+     * Make sure to re-assign it if you keep builder in a variable.
+     * @param {Uint8Array} account_pubkey
+     * @param {SignerFn} signer_fn
+     * @returns {GrpcClientBuilder}
+     */
+    withPubkeyAndSigner(account_pubkey, signer_fn) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.grpcclientbuilder_withPubkeyAndSigner(ptr, account_pubkey, signer_fn);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GrpcClientBuilder.__wrap(ret[0]);
+    }
+    /**
+     * build gRPC client
+     * @returns {GrpcClient}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.grpcclientbuilder_build(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return GrpcClient.__wrap(ret[0]);
+    }
+    /**
+     * Set the `url` of the grpc-web server to connect to
+     *
+     * Note that this method **consumes** builder and returns updated instance of it.
+     * Make sure to re-assign it if you keep builder in a variable.
+     * @param {string} url
+     * @returns {GrpcClientBuilder}
+     */
+    withUrl(url) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclientbuilder_withUrl(ptr, ptr0, len0);
+        return GrpcClientBuilder.__wrap(ret);
+    }
+}
+
 const HeaderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_header_free(ptr >>> 0, 1));
@@ -4114,13 +4388,6 @@ export class IntoUnderlyingByteSource {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
     }
-    /**
-     * @returns {ReadableStreamType}
-     */
-    get type() {
-        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
-        return __wbindgen_enum_ReadableStreamType[ret];
-    }
     /**
      * @returns {number}
      */
@@ -4128,6 +4395,14 @@ export class IntoUnderlyingByteSource {
         const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {ReadableByteStreamController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
     /**
      * @param {ReadableByteStreamController} controller
      */
@@ -4135,12 +4410,11 @@ export class IntoUnderlyingByteSource {
         wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
     }
     /**
-     * @param {ReadableByteStreamController} controller
-     * @returns {Promise<any>}
+     * @returns {ReadableStreamType}
      */
-    pull(controller) {
-        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
-        return ret;
+    get type() {
+        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+        return __wbindgen_enum_ReadableStreamType[ret];
     }
     cancel() {
         const ptr = this.__destroy_into_raw();
@@ -4166,11 +4440,12 @@ export class IntoUnderlyingSink {
         wasm.__wbg_intounderlyingsink_free(ptr, 0);
     }
     /**
-     * @param {any} chunk
+     * @param {any} reason
      * @returns {Promise<any>}
      */
-    write(chunk) {
-        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
         return ret;
     }
     /**
@@ -4182,12 +4457,11 @@ export class IntoUnderlyingSink {
         return ret;
     }
     /**
-     * @param {any} reason
+     * @param {any} chunk
      * @returns {Promise<any>}
      */
-    abort(reason) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
         return ret;
     }
 }
@@ -4319,7 +4593,7 @@ export class JsEvent {
     set type(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_blockid_hash(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsbitvector_0(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @returns {JsEventAttribute[]}
@@ -4393,7 +4667,7 @@ export class JsEventAttribute {
     set key(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_blockid_hash(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsbitvector_0(this.__wbg_ptr, ptr0, len0);
     }
     /**
      * @returns {string}
@@ -4751,6 +5025,21 @@ export class ModeInfo {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_modeinfo_free(ptr, 0);
     }
+    /**
+     * Multi is the mode info for a multisig public key
+     * mode_infos is the corresponding modes of the signers of the multisig
+     * which could include nested multisig public keys
+     * @returns {ModeInfo[] | undefined}
+     */
+    get mode_infos() {
+        const ret = wasm.modeinfo_mode_infos(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Return signature mode for the stored signature(s)
      * @returns {SignatureMode}
@@ -4778,21 +5067,6 @@ export class ModeInfo {
         const ret = wasm.modeinfo_bitarray(this.__wbg_ptr);
         return ret === 0 ? undefined : JsBitVector.__wrap(ret);
     }
-    /**
-     * Multi is the mode info for a multisig public key
-     * mode_infos is the corresponding modes of the signers of the multisig
-     * which could include nested multisig public keys
-     * @returns {ModeInfo[] | undefined}
-     */
-    get mode_infos() {
-        const ret = wasm.modeinfo_mode_infos(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        }
-        return v1;
-    }
 }
 
 const NamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4832,14 +5106,14 @@ export class Namespace {
     toJSON() {
         return {
             NS_SIZE: this.NS_SIZE,
+            version: this.version,
             TRANSACTION: this.TRANSACTION,
+            PARITY_SHARE: this.PARITY_SHARE,
             PAY_FOR_BLOB: this.PAY_FOR_BLOB,
-            PRIMARY_RESERVED_PADDING: this.PRIMARY_RESERVED_PADDING,
+            TAIL_PADDING: this.TAIL_PADDING,
             MAX_PRIMARY_RESERVED: this.MAX_PRIMARY_RESERVED,
             MIN_SECONDARY_RESERVED: this.MIN_SECONDARY_RESERVED,
-            TAIL_PADDING: this.TAIL_PADDING,
-            PARITY_SHARE: this.PARITY_SHARE,
-            version: this.version,
+            PRIMARY_RESERVED_PADDING: this.PRIMARY_RESERVED_PADDING,
             id: this.id,
         };
     }
@@ -4867,6 +5141,44 @@ export class Namespace {
         const ret = wasm.namespace_NS_SIZE();
         return ret >>> 0;
     }
+    /**
+     * Returns the first byte indicating the version of the [`Namespace`].
+     * @returns {number}
+     */
+    get version() {
+        const ret = wasm.namespace_version(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Converts the [`Namespace`] to a byte slice.
+     * @returns {Uint8Array}
+     */
+    asBytes() {
+        const ret = wasm.namespace_asBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Create a new [`Namespace`] from the raw bytes.
+     *
+     * # Errors
+     *
+     * This function will return an error if the slice length is different than
+     * [`NS_SIZE`] or if the namespace is invalid. If you are constructing the
+     * version `0` namespace, check [`newV0`].
+     * @param {Uint8Array} raw
+     * @returns {Namespace}
+     */
+    static fromRaw(raw) {
+        const ptr0 = passArray8ToWasm0(raw, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.namespace_fromRaw(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Namespace.__wrap(ret[0]);
+    }
     /**
      * Primary reserved [`Namespace`] for the compact `Share`s with `cosmos SDK` transactions.
      * @returns {Namespace}
@@ -4875,6 +5187,18 @@ export class Namespace {
         const ret = wasm.namespace_TRANSACTION();
         return Namespace.__wrap(ret);
     }
+    /**
+     * The [`Namespace`] for `parity shares`.
+     *
+     * It is the namespace with which all the `parity shares` from
+     * `ExtendedDataSquare` are inserted to the `Nmt` when computing
+     * merkle roots.
+     * @returns {Namespace}
+     */
+    static get PARITY_SHARE() {
+        const ret = wasm.namespace_PARITY_SHARE();
+        return Namespace.__wrap(ret);
+    }
     /**
      * Primary reserved [`Namespace`] for the compact Shares with MsgPayForBlobs transactions.
      * @returns {Namespace}
@@ -4884,14 +5208,14 @@ export class Namespace {
         return Namespace.__wrap(ret);
     }
     /**
-     * Primary reserved [`Namespace`] for the `Share`s used for padding.
+     * Secondary reserved [`Namespace`] used for padding after the blobs.
      *
-     * `Share`s with this namespace are inserted after other shares from primary reserved namespace
-     * so that user-defined namespaces are correctly aligned in `ExtendedDataSquare`
+     * It is used to fill up the `original data square` after all user-submitted
+     * blobs before the parity data is generated for the `ExtendedDataSquare`.
      * @returns {Namespace}
      */
-    static get PRIMARY_RESERVED_PADDING() {
-        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
+    static get TAIL_PADDING() {
+        const ret = wasm.namespace_TAIL_PADDING();
         return Namespace.__wrap(ret);
     }
     /**
@@ -4915,27 +5239,25 @@ export class Namespace {
         return Namespace.__wrap(ret);
     }
     /**
-     * Secondary reserved [`Namespace`] used for padding after the blobs.
+     * Primary reserved [`Namespace`] for the `Share`s used for padding.
      *
-     * It is used to fill up the `original data square` after all user-submitted
-     * blobs before the parity data is generated for the `ExtendedDataSquare`.
+     * `Share`s with this namespace are inserted after other shares from primary reserved namespace
+     * so that user-defined namespaces are correctly aligned in `ExtendedDataSquare`
      * @returns {Namespace}
      */
-    static get TAIL_PADDING() {
-        const ret = wasm.namespace_TAIL_PADDING();
+    static get PRIMARY_RESERVED_PADDING() {
+        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
         return Namespace.__wrap(ret);
     }
     /**
-     * The [`Namespace`] for `parity shares`.
-     *
-     * It is the namespace with which all the `parity shares` from
-     * `ExtendedDataSquare` are inserted to the `Nmt` when computing
-     * merkle roots.
-     * @returns {Namespace}
+     * Returns the trailing 28 bytes indicating the id of the [`Namespace`].
+     * @returns {Uint8Array}
      */
-    static get PARITY_SHARE() {
-        const ret = wasm.namespace_PARITY_SHARE();
-        return Namespace.__wrap(ret);
+    get id() {
+        const ret = wasm.namespace_id(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
     /**
      * Create a new [`Namespace`] version `0` with given id.
@@ -4955,54 +5277,6 @@ export class Namespace {
         }
         return Namespace.__wrap(ret[0]);
     }
-    /**
-     * Create a new [`Namespace`] from the raw bytes.
-     *
-     * # Errors
-     *
-     * This function will return an error if the slice length is different than
-     * [`NS_SIZE`] or if the namespace is invalid. If you are constructing the
-     * version `0` namespace, check [`newV0`].
-     * @param {Uint8Array} raw
-     * @returns {Namespace}
-     */
-    static fromRaw(raw) {
-        const ptr0 = passArray8ToWasm0(raw, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.namespace_fromRaw(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Namespace.__wrap(ret[0]);
-    }
-    /**
-     * Converts the [`Namespace`] to a byte slice.
-     * @returns {Uint8Array}
-     */
-    asBytes() {
-        const ret = wasm.namespace_asBytes(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Returns the first byte indicating the version of the [`Namespace`].
-     * @returns {number}
-     */
-    get version() {
-        const ret = wasm.namespace_version(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Returns the trailing 28 bytes indicating the id of the [`Namespace`].
-     * @returns {Uint8Array}
-     */
-    get id() {
-        const ret = wasm.namespace_id(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
 }
 
 const NetworkInfoSnapshotFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -5107,24 +5381,6 @@ export class NodeClient {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_nodeclient_free(ptr, 0);
     }
-    /**
-     * Create a new connection to a Lumina node running in [`NodeWorker`]. Provided `port` is
-     * expected to have `MessagePort`-like interface for sending and receiving messages.
-     * @param {any} port
-     */
-    constructor(port) {
-        const ret = wasm.nodeclient_new(port);
-        return ret;
-    }
-    /**
-     * Establish a new connection to the existing worker over provided port
-     * @param {any} port
-     * @returns {Promise<void>}
-     */
-    addConnectionToWorker(port) {
-        const ret = wasm.nodeclient_addConnectionToWorker(this.__wbg_ptr, port);
-        return ret;
-    }
     /**
      * Check whether Lumina is currently running
      * @returns {Promise<boolean>}
@@ -5134,20 +5390,37 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Start a node with the provided config, if it's not running
-     * @param {NodeConfig} config
-     * @returns {Promise<void>}
+     * Get synced headers from the given heights range.
+     *
+     * If start of the range is undefined (None), the first returned header will be of height 1.
+     * If end of the range is undefined (None), the last returned header will be the last header in the
+     * store.
+     *
+     * # Errors
+     *
+     * If range contains a height of a header that is not found in the store.
+     * @param {bigint | null} [start_height]
+     * @param {bigint | null} [end_height]
+     * @returns {Promise<ExtendedHeader[]>}
      */
-    start(config) {
-        _assertClass(config, NodeConfig);
-        const ret = wasm.nodeclient_start(this.__wbg_ptr, config.__wbg_ptr);
+    getHeaders(start_height, end_height) {
+        const ret = wasm.nodeclient_getHeaders(this.__wbg_ptr, !isLikeNone(start_height), isLikeNone(start_height) ? BigInt(0) : start_height, !isLikeNone(end_height), isLikeNone(end_height) ? BigInt(0) : end_height);
         return ret;
     }
     /**
-     * @returns {Promise<void>}
+     * Get current header syncing info.
+     * @returns {Promise<SyncingInfoSnapshot>}
      */
-    stop() {
-        const ret = wasm.nodeclient_stop(this.__wbg_ptr);
+    syncerInfo() {
+        const ret = wasm.nodeclient_syncerInfo(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get current network info.
+     * @returns {Promise<NetworkInfoSnapshot>}
+     */
+    networkInfo() {
+        const ret = wasm.nodeclient_networkInfo(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -5159,63 +5432,71 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Get current [`PeerTracker`] info.
-     * @returns {Promise<PeerTrackerInfoSnapshot>}
+     * Returns a [`BroadcastChannel`] for events generated by [`Node`].
+     * @returns {Promise<BroadcastChannel>}
      */
-    peerTrackerInfo() {
-        const ret = wasm.nodeclient_peerTrackerInfo(this.__wbg_ptr);
+    eventsChannel() {
+        const ret = wasm.nodeclient_eventsChannel(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Wait until the node is connected to at least 1 peer.
+     * Trust or untrust the peer with a given ID.
+     * @param {string} peer_id
+     * @param {boolean} is_trusted
      * @returns {Promise<void>}
      */
-    waitConnected() {
-        const ret = wasm.nodeclient_waitConnected(this.__wbg_ptr);
+    setPeerTrust(peer_id, is_trusted) {
+        const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nodeclient_setPeerTrust(this.__wbg_ptr, ptr0, len0, is_trusted);
         return ret;
     }
     /**
-     * Wait until the node is connected to at least 1 trusted peer.
+     * Wait until the node is connected to at least 1 peer.
      * @returns {Promise<void>}
      */
-    waitConnectedTrusted() {
-        const ret = wasm.nodeclient_waitConnectedTrusted(this.__wbg_ptr);
+    waitConnected() {
+        const ret = wasm.nodeclient_waitConnected(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Get current network info.
-     * @returns {Promise<NetworkInfoSnapshot>}
+     * Get all the peers that node is connected to.
+     * @returns {Promise<Array<any>>}
      */
-    networkInfo() {
-        const ret = wasm.nodeclient_networkInfo(this.__wbg_ptr);
+    connectedPeers() {
+        const ret = wasm.nodeclient_connectedPeers(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Get all the multiaddresses on which the node listens.
-     * @returns {Promise<Array<any>>}
+     * Get current [`PeerTracker`] info.
+     * @returns {Promise<PeerTrackerInfoSnapshot>}
      */
-    listeners() {
-        const ret = wasm.nodeclient_listeners(this.__wbg_ptr);
+    peerTrackerInfo() {
+        const ret = wasm.nodeclient_peerTrackerInfo(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Get all the peers that node is connected to.
-     * @returns {Promise<Array<any>>}
+     * Request all blobs with provided namespace in the block corresponding to this header
+     * using bitswap protocol.
+     * @param {Namespace} namespace
+     * @param {bigint} block_height
+     * @param {number | null} [timeout_secs]
+     * @returns {Promise<Blob[]>}
      */
-    connectedPeers() {
-        const ret = wasm.nodeclient_connectedPeers(this.__wbg_ptr);
+    requestAllBlobs(namespace, block_height, timeout_secs) {
+        _assertClass(namespace, Namespace);
+        const ret = wasm.nodeclient_requestAllBlobs(this.__wbg_ptr, namespace.__wbg_ptr, block_height, !isLikeNone(timeout_secs), isLikeNone(timeout_secs) ? 0 : timeout_secs);
         return ret;
     }
     /**
-     * Trust or untrust the peer with a given ID.
-     * @param {string} peer_id
-     * @param {boolean} is_trusted
-     * @returns {Promise<void>}
+     * Get a synced header for the block with a given hash.
+     * @param {string} hash
+     * @returns {Promise<ExtendedHeader>}
      */
-    setPeerTrust(peer_id, is_trusted) {
-        const ptr0 = passStringToWasm0(peer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    getHeaderByHash(hash) {
+        const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.nodeclient_setPeerTrust(this.__wbg_ptr, ptr0, len0, is_trusted);
+        const ret = wasm.nodeclient_getHeaderByHash(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -5227,57 +5508,48 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Request a header for the block with a given hash from the network.
-     * @param {string} hash
+     * Get a synced header for the block with a given height.
+     * @param {bigint} height
      * @returns {Promise<ExtendedHeader>}
      */
-    requestHeaderByHash(hash) {
-        const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.nodeclient_requestHeaderByHash(this.__wbg_ptr, ptr0, len0);
+    getHeaderByHeight(height) {
+        const ret = wasm.nodeclient_getHeaderByHeight(this.__wbg_ptr, height);
         return ret;
     }
     /**
-     * Request a header for the block with a given height from the network.
-     * @param {bigint} height
+     * Get the latest locally synced header.
      * @returns {Promise<ExtendedHeader>}
      */
-    requestHeaderByHeight(height) {
-        const ret = wasm.nodeclient_requestHeaderByHeight(this.__wbg_ptr, height);
+    getLocalHeadHeader() {
+        const ret = wasm.nodeclient_getLocalHeadHeader(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Request headers in range (from, from + amount] from the network.
-     *
-     * The headers will be verified with the `from` header.
-     * @param {ExtendedHeader} from
-     * @param {bigint} amount
-     * @returns {Promise<ExtendedHeader[]>}
+     * Get data sampling metadata of an already sampled height.
+     * @param {bigint} height
+     * @returns {Promise<SamplingMetadata | undefined>}
      */
-    requestVerifiedHeaders(from, amount) {
-        _assertClass(from, ExtendedHeader);
-        const ret = wasm.nodeclient_requestVerifiedHeaders(this.__wbg_ptr, from.__wbg_ptr, amount);
+    getSamplingMetadata(height) {
+        const ret = wasm.nodeclient_getSamplingMetadata(this.__wbg_ptr, height);
         return ret;
     }
     /**
-     * Request all blobs with provided namespace in the block corresponding to this header
-     * using bitswap protocol.
-     * @param {Namespace} namespace
-     * @param {bigint} block_height
-     * @param {number | null} [timeout_secs]
-     * @returns {Promise<Blob[]>}
+     * Request a header for the block with a given hash from the network.
+     * @param {string} hash
+     * @returns {Promise<ExtendedHeader>}
      */
-    requestAllBlobs(namespace, block_height, timeout_secs) {
-        _assertClass(namespace, Namespace);
-        const ret = wasm.nodeclient_requestAllBlobs(this.__wbg_ptr, namespace.__wbg_ptr, block_height, !isLikeNone(timeout_secs), isLikeNone(timeout_secs) ? 0 : timeout_secs);
+    requestHeaderByHash(hash) {
+        const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nodeclient_requestHeaderByHash(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Get current header syncing info.
-     * @returns {Promise<SyncingInfoSnapshot>}
+     * Wait until the node is connected to at least 1 trusted peer.
+     * @returns {Promise<void>}
      */
-    syncerInfo() {
-        const ret = wasm.nodeclient_syncerInfo(this.__wbg_ptr);
+    waitConnectedTrusted() {
+        const ret = wasm.nodeclient_waitConnectedTrusted(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -5289,66 +5561,69 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Get the latest locally synced header.
-     * @returns {Promise<ExtendedHeader>}
+     * Establish a new connection to the existing worker over provided port
+     * @param {any} port
+     * @returns {Promise<void>}
      */
-    getLocalHeadHeader() {
-        const ret = wasm.nodeclient_getLocalHeadHeader(this.__wbg_ptr);
+    addConnectionToWorker(port) {
+        const ret = wasm.nodeclient_addConnectionToWorker(this.__wbg_ptr, port);
         return ret;
     }
     /**
-     * Get a synced header for the block with a given hash.
-     * @param {string} hash
+     * Request a header for the block with a given height from the network.
+     * @param {bigint} height
      * @returns {Promise<ExtendedHeader>}
      */
-    getHeaderByHash(hash) {
-        const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.nodeclient_getHeaderByHash(this.__wbg_ptr, ptr0, len0);
+    requestHeaderByHeight(height) {
+        const ret = wasm.nodeclient_requestHeaderByHeight(this.__wbg_ptr, height);
         return ret;
     }
     /**
-     * Get a synced header for the block with a given height.
-     * @param {bigint} height
-     * @returns {Promise<ExtendedHeader>}
+     * Request headers in range (from, from + amount] from the network.
+     *
+     * The headers will be verified with the `from` header.
+     * @param {ExtendedHeader} from
+     * @param {bigint} amount
+     * @returns {Promise<ExtendedHeader[]>}
      */
-    getHeaderByHeight(height) {
-        const ret = wasm.nodeclient_getHeaderByHeight(this.__wbg_ptr, height);
+    requestVerifiedHeaders(from, amount) {
+        _assertClass(from, ExtendedHeader);
+        const ret = wasm.nodeclient_requestVerifiedHeaders(this.__wbg_ptr, from.__wbg_ptr, amount);
         return ret;
     }
     /**
-     * Get synced headers from the given heights range.
-     *
-     * If start of the range is undefined (None), the first returned header will be of height 1.
-     * If end of the range is undefined (None), the last returned header will be the last header in the
-     * store.
-     *
-     * # Errors
-     *
-     * If range contains a height of a header that is not found in the store.
-     * @param {bigint | null} [start_height]
-     * @param {bigint | null} [end_height]
-     * @returns {Promise<ExtendedHeader[]>}
+     * Create a new connection to a Lumina node running in [`NodeWorker`]. Provided `port` is
+     * expected to have `MessagePort`-like interface for sending and receiving messages.
+     * @param {any} port
      */
-    getHeaders(start_height, end_height) {
-        const ret = wasm.nodeclient_getHeaders(this.__wbg_ptr, !isLikeNone(start_height), isLikeNone(start_height) ? BigInt(0) : start_height, !isLikeNone(end_height), isLikeNone(end_height) ? BigInt(0) : end_height);
+    constructor(port) {
+        const ret = wasm.nodeclient_new(port);
         return ret;
     }
     /**
-     * Get data sampling metadata of an already sampled height.
-     * @param {bigint} height
-     * @returns {Promise<SamplingMetadata | undefined>}
+     * Stop the node.
+     * @returns {Promise<void>}
      */
-    getSamplingMetadata(height) {
-        const ret = wasm.nodeclient_getSamplingMetadata(this.__wbg_ptr, height);
+    stop() {
+        const ret = wasm.nodeclient_stop(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Start the node with the provided config, if it's not running
+     * @param {NodeConfig} config
+     * @returns {Promise<void>}
+     */
+    start(config) {
+        _assertClass(config, NodeConfig);
+        const ret = wasm.nodeclient_start(this.__wbg_ptr, config.__wbg_ptr);
         return ret;
     }
     /**
-     * Returns a [`BroadcastChannel`] for events generated by [`Node`].
-     * @returns {Promise<BroadcastChannel>}
+     * Get all the multiaddresses on which the node listens.
+     * @returns {Promise<Array<any>>}
      */
-    eventsChannel() {
-        const ret = wasm.nodeclient_eventsChannel(this.__wbg_ptr);
+    listeners() {
+        const ret = wasm.nodeclient_listeners(this.__wbg_ptr);
         return ret;
     }
 }
@@ -5373,6 +5648,7 @@ export class NodeConfig {
         return {
             network: this.network,
             bootnodes: this.bootnodes,
+            identity_key: this.identity_key,
             usePersistentMemory: this.usePersistentMemory,
             customPruningWindowSecs: this.customPruningWindowSecs,
         };
@@ -5393,6 +5669,15 @@ export class NodeConfig {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_nodeconfig_free(ptr, 0);
     }
+    /**
+     * Get the configuration with default bootnodes for provided network
+     * @param {Network} network
+     * @returns {NodeConfig}
+     */
+    static default(network) {
+        const ret = wasm.nodeconfig_default(network);
+        return NodeConfig.__wrap(ret);
+    }
     /**
      * A network to connect to.
      * @returns {Network}
@@ -5427,6 +5712,30 @@ export class NodeConfig {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_nodeconfig_bootnodes(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Optionally start with a provided private key used as libp2p identity. Expects 32 bytes
+     * containing ed25519 secret key.
+     * @returns {Uint8Array | undefined}
+     */
+    get identity_key() {
+        const ret = wasm.__wbg_get_nodeconfig_identity_key(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Optionally start with a provided private key used as libp2p identity. Expects 32 bytes
+     * containing ed25519 secret key.
+     * @param {Uint8Array | null} [arg0]
+     */
+    set identity_key(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_nodeconfig_identity_key(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Whether to store data in persistent memory or not.
      *
@@ -5479,15 +5788,6 @@ export class NodeConfig {
     set customPruningWindowSecs(arg0) {
         wasm.__wbg_set_nodeconfig_customPruningWindowSecs(this.__wbg_ptr, isLikeNone(arg0) ? 0x100000001 : (arg0) >>> 0);
     }
-    /**
-     * Get the configuration with default bootnodes for provided network
-     * @param {Network} network
-     * @returns {NodeConfig}
-     */
-    static default(network) {
-        const ret = wasm.nodeconfig_default(network);
-        return NodeConfig.__wrap(ret);
-    }
 }
 
 const NodeWorkerFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -5513,6 +5813,7 @@ export class NodeWorker {
         wasm.__wbg_nodeworker_free(ptr, 0);
     }
     /**
+     * Create a new `NodeWorker` with a port-like JS object.
      * @param {any} port_like_object
      */
     constructor(port_like_object) {
@@ -5522,6 +5823,7 @@ export class NodeWorker {
         return this;
     }
     /**
+     * Run `NodeWorker` main loop.
      * @returns {Promise<void>}
      */
     run() {
@@ -5595,7 +5897,7 @@ export class PartsHeader {
     set hash(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_blockid_hash(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_jsbitvector_0(this.__wbg_ptr, ptr0, len0);
     }
 }
 
@@ -5846,7 +6148,7 @@ export class ProtocolVersion {
      * @returns {bigint}
      */
     get block() {
-        const ret = wasm.__wbg_get_jsvalidatorinfo_power(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_commit_height(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -5854,14 +6156,14 @@ export class ProtocolVersion {
      * @param {bigint} arg0
      */
     set block(arg0) {
-        wasm.__wbg_set_jsvalidatorinfo_power(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_commit_height(this.__wbg_ptr, arg0);
     }
     /**
      * app version
      * @returns {bigint}
      */
     get app() {
-        const ret = wasm.__wbg_get_jsvalidatorinfo_proposer_priority(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_protocolversion_app(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -5869,7 +6171,7 @@ export class ProtocolVersion {
      * @param {bigint} arg0
      */
     set app(arg0) {
-        wasm.__wbg_set_jsvalidatorinfo_proposer_priority(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_protocolversion_app(this.__wbg_ptr, arg0);
     }
 }
 
@@ -6054,6 +6356,16 @@ export class SignerInfo {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signerinfo_free(ptr, 0);
     }
+    /**
+     * public_key is the public key of the signer. It is optional for accounts
+     * that already exist in state. If unset, the verifier can use the required \
+     * signer address for this position and lookup the public key.
+     * @returns {ProtoAny | undefined}
+     */
+    public_key() {
+        const ret = wasm.signerinfo_public_key(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * mode_info describes the signing mode of the signer and is a nested
      * structure to support nested multisig pubkey's
@@ -6092,16 +6404,6 @@ export class SignerInfo {
     set sequence(arg0) {
         wasm.__wbg_set_signerinfo_sequence(this.__wbg_ptr, arg0);
     }
-    /**
-     * public_key is the public key of the signer. It is optional for accounts
-     * that already exist in state. If unset, the verifier can use the required \
-     * signer address for this position and lookup the public key.
-     * @returns {ProtoAny | undefined}
-     */
-    public_key() {
-        const ret = wasm.signerinfo_public_key(this.__wbg_ptr);
-        return ret;
-    }
 }
 
 const StringEventFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6351,336 +6653,87 @@ export class TxBody {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         TxBodyFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_txbody_free(ptr, 0);
-    }
-    /**
-     * `memo` is any arbitrary memo to be added to the transaction.
-     * @returns {string}
-     */
-    get memo() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.__wbg_get_txbody_memo(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * `memo` is any arbitrary memo to be added to the transaction.
-     * @param {string} arg0
-     */
-    set memo(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_txbody_memo(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * `messages` is a list of messages to be executed. The required signers of
-     * those messages define the number and order of elements in `AuthInfo`'s
-     * signer_infos and Tx's signatures. Each required signer address is added to
-     * the list only the first time it occurs.
-     *
-     * By convention, the first required signer (usually from the first message)
-     * is referred to as the primary signer and pays the fee for the whole
-     * transaction.
-     * @returns {ProtoAny[]}
-     */
-    messages() {
-        const ret = wasm.txbody_messages(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * `timeout` is the block height after which this transaction will not
-     * be processed by the chain
-     * @returns {bigint}
-     */
-    get timeout_height() {
-        const ret = wasm.txbody_timeout_height(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * `extension_options` are arbitrary options that can be added by chains
-     * when the default options are not sufficient. If any of these are present
-     * and can't be handled, the transaction will be rejected
-     * @returns {ProtoAny[]}
-     */
-    extension_options() {
-        const ret = wasm.txbody_extension_options(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * `extension_options` are arbitrary options that can be added by chains
-     * when the default options are not sufficient. If any of these are present
-     * and can't be handled, they will be ignored
-     * @returns {ProtoAny[]}
-     */
-    non_critical_extension_options() {
-        const ret = wasm.txbody_non_critical_extension_options(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-}
-
-const TxClientFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_txclient_free(ptr >>> 0, 1));
-/**
- * Celestia grpc transaction client.
- */
-export class TxClient {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(TxClient.prototype);
-        obj.__wbg_ptr = ptr;
-        TxClientFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TxClientFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_txclient_free(ptr, 0);
-    }
-    /**
-     * Create a new transaction client with the specified account.
-     *
-     * Url must point to a [grpc-web proxy](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md).
-     *
-     * # Example with noble/curves
-     * ```js
-     * import { secp256k1 } from "@noble/curves/secp256k1";
-     *
-     * const privKey = "fdc8ac75dfa1c142dbcba77938a14dd03078052ce0b49a529dcf72a9885a3abb";
-     * const pubKey = secp256k1.getPublicKey(privKey);
-     *
-     * const signer = (signDoc) => {
-     *   const bytes = protoEncodeSignDoc(signDoc);
-     *   const sig = secp256k1.sign(bytes, privKey, { prehash: true });
-     *   return sig.toCompactRawBytes();
-     * };
-     *
-     * const txClient = await new TxClient("http://127.0.0.1:18080", pubKey, signer);
-     * ```
-     *
-     * # Example with leap wallet
-     * ```js
-     * await window.leap.enable("mocha-4")
-     * const keys = await window.leap.getKey("mocha-4")
-     *
-     * const signer = (signDoc) => {
-     *   return window.leap.signDirect("mocha-4", keys.bech32Address, signDoc, { preferNoSetFee: true })
-     *     .then(sig => Uint8Array.from(atob(sig.signature.signature), c => c.charCodeAt(0)))
-     * }
-     *
-     * const tx_client = await new TxClient("http://127.0.0.1:18080", keys.pubKey, signer)
-     * ```
-     * @param {string} url
-     * @param {Uint8Array} pubkey
-     * @param {SignerFn} signer_fn
-     */
-    constructor(url, pubkey, signer_fn) {
-        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_new(ptr0, len0, pubkey, signer_fn);
-        return ret;
-    }
-    /**
-     * estimate_gas_price takes a transaction priority and estimates the gas price based
-     * on the gas prices of the transactions in the last five blocks.
-     *
-     * If no transaction is found in the last five blocks, return the network
-     * min gas price.
-     * @param {TxPriority} priority
-     * @returns {Promise<number>}
-     */
-    getEstimateGasPrice(priority) {
-        const ret = wasm.txclient_getEstimateGasPrice(this.__wbg_ptr, priority);
-        return ret;
-    }
-    /**
-     * Chain id of the client
-     * @returns {string}
-     */
-    get chainId() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.txclient_chainId(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * AppVersion of the client
-     * @returns {AppVersion}
-     */
-    get appVersion() {
-        const ret = wasm.txclient_appVersion(this.__wbg_ptr);
-        return AppVersion.__wrap(ret);
-    }
-    /**
-     * Submit blobs to the celestia network.
-     *
-     * When no `TxConfig` is provided, client will automatically calculate needed
-     * gas and update the `gasPrice`, if network agreed on a new minimal value.
-     * To enforce specific values use a `TxConfig`.
-     *
-     * # Example
-     * ```js
-     * const ns = Namespace.newV0(new Uint8Array([97, 98, 99]));
-     * const data = new Uint8Array([100, 97, 116, 97]);
-     * const blob = new Blob(ns, data, AppVersion.latest());
-     *
-     * const txInfo = await txClient.submitBlobs([blob]);
-     * await txClient.submitBlobs([blob], { gasLimit: 100000n, gasPrice: 0.02, memo: "foo" });
-     * ```
-     *
-     * # Note
-     *
-     * Provided blobs will be consumed by this method, meaning
-     * they will no longer be accessible. If this behavior is not desired,
-     * consider using `Blob.clone()`.
-     *
-     * ```js
-     * const blobs = [blob1, blob2, blob3];
-     * await txClient.submitBlobs(blobs.map(b => b.clone()));
-     * ```
-     * @param {Blob[]} blobs
-     * @param {TxConfig | null} [tx_config]
-     * @returns {Promise<TxInfo>}
-     */
-    submitBlobs(blobs, tx_config) {
-        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_submitBlobs(this.__wbg_ptr, ptr0, len0, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
-        return ret;
+        return ptr;
     }
-    /**
-     * Submit message to the celestia network.
-     *
-     * When no `TxConfig` is provided, client will automatically calculate needed
-     * gas and update the `gasPrice`, if network agreed on a new minimal value.
-     * To enforce specific values use a `TxConfig`.
-     *
-     * # Example
-     * ```js
-     * import { Registry } from "@cosmjs/proto-signing";
-     *
-     * const registry = new Registry();
-     * const sendMsg = {
-     *   typeUrl: "/cosmos.bank.v1beta1.MsgSend",
-     *   value: {
-     *     fromAddress: "celestia169s50psyj2f4la9a2235329xz7rk6c53zhw9mm",
-     *     toAddress: "celestia1t52q7uqgnjfzdh3wx5m5phvma3umrq8k6tq2p9",
-     *     amount: [{ denom: "utia", amount: "10000" }],
-     *   },
-     * };
-     * const sendMsgAny = registry.encodeAsAny(sendMsg);
-     *
-     * const txInfo = await txClient.submitMessage(sendMsgAny);
-     * ```
-     * @param {ProtoAny} message
-     * @param {TxConfig | null} [tx_config]
-     * @returns {Promise<TxInfo>}
-     */
-    submitMessage(message, tx_config) {
-        const ret = wasm.txclient_submitMessage(this.__wbg_ptr, message, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
-        return ret;
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_txbody_free(ptr, 0);
     }
     /**
-     * Get auth params
-     * @returns {Promise<AuthParams>}
+     * `memo` is any arbitrary memo to be added to the transaction.
+     * @returns {string}
      */
-    getAuthParams() {
-        const ret = wasm.txclient_getAuthParams(this.__wbg_ptr);
-        return ret;
+    get memo() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_txbody_memo(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Get account
-     * @param {string} account
-     * @returns {Promise<BaseAccount>}
+     * `memo` is any arbitrary memo to be added to the transaction.
+     * @param {string} arg0
      */
-    getAccount(account) {
-        const ptr0 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    set memo(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_getAccount(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Get accounts
-     * @returns {Promise<BaseAccount[]>}
-     */
-    getAccounts() {
-        const ret = wasm.txclient_getAccounts(this.__wbg_ptr);
-        return ret;
+        wasm.__wbg_set_txbody_memo(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Get balance of coins with given denom
-     * @param {string} address
-     * @param {string} denom
-     * @returns {Promise<Coin>}
+     * `timeout` is the block height after which this transaction will not
+     * be processed by the chain
+     * @returns {bigint}
      */
-    getBalance(address, denom) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(denom, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_getBalance(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        return ret;
+    get timeout_height() {
+        const ret = wasm.txbody_timeout_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * Get balance of all coins
-     * @param {string} address
-     * @returns {Promise<Coin[]>}
+     * `extension_options` are arbitrary options that can be added by chains
+     * when the default options are not sufficient. If any of these are present
+     * and can't be handled, the transaction will be rejected
+     * @returns {ProtoAny[]}
      */
-    getAllBalances(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_getAllBalances(this.__wbg_ptr, ptr0, len0);
-        return ret;
+    extension_options() {
+        const ret = wasm.txbody_extension_options(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * Get balance of all spendable coins
-     * @param {string} address
-     * @returns {Promise<Coin[]>}
+     * `extension_options` are arbitrary options that can be added by chains
+     * when the default options are not sufficient. If any of these are present
+     * and can't be handled, they will be ignored
+     * @returns {ProtoAny[]}
      */
-    getSpendableBalances(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txclient_getSpendableBalances(this.__wbg_ptr, ptr0, len0);
-        return ret;
+    non_critical_extension_options() {
+        const ret = wasm.txbody_non_critical_extension_options(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
-     * Get total supply
-     * @returns {Promise<Coin[]>}
+     * `messages` is a list of messages to be executed. The required signers of
+     * those messages define the number and order of elements in `AuthInfo`'s
+     * signer_infos and Tx's signatures. Each required signer address is added to
+     * the list only the first time it occurs.
+     *
+     * By convention, the first required signer (usually from the first message)
+     * is referred to as the primary signer and pays the fee for the whole
+     * transaction.
+     * @returns {ProtoAny[]}
      */
-    getTotalSupply() {
-        const ret = wasm.txclient_getTotalSupply(this.__wbg_ptr);
-        return ret;
+    messages() {
+        const ret = wasm.txbody_messages(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
 }
 
@@ -6711,6 +6764,27 @@ export class TxResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_txresponse_free(ptr, 0);
     }
+    /**
+     * Events defines all the events emitted by processing a transaction. Note,
+     * these events include those emitted by processing all the messages and those
+     * emitted from the ante. Whereas Logs contains the events, with
+     * additional metadata, emitted only by processing the messages.
+     * @returns {JsEvent[]}
+     */
+    get events() {
+        const ret = wasm.txresponse_events(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The block height
+     * @returns {bigint}
+     */
+    get height() {
+        const ret = wasm.txbody_timeout_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * Namespace for the Code
      * @returns {string}
@@ -6906,27 +6980,6 @@ export class TxResponse {
         const len0 = WASM_VECTOR_LEN;
         wasm.__wbg_set_txresponse_timestamp(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * The block height
-     * @returns {bigint}
-     */
-    get height() {
-        const ret = wasm.txbody_timeout_height(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * Events defines all the events emitted by processing a transaction. Note,
-     * these events include those emitted by processing all the messages and those
-     * emitted from the ante. Whereas Logs contains the events, with
-     * additional metadata, emitted only by processing the messages.
-     * @returns {JsEvent[]}
-     */
-    get events() {
-        const ret = wasm.txresponse_events(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
 }
 
 const TxStatusResponseFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6956,6 +7009,14 @@ export class TxStatusResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_txstatusresponse_free(ptr, 0);
     }
+    /**
+     * Height of the block in which the transaction was committed.
+     * @returns {bigint}
+     */
+    get height() {
+        const ret = wasm.txstatusresponse_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
     /**
      * Index of the transaction in block.
      * @returns {number}
@@ -7030,14 +7091,6 @@ export class TxStatusResponse {
     set status(arg0) {
         wasm.__wbg_set_txstatusresponse_status(this.__wbg_ptr, arg0);
     }
-    /**
-     * Height of the block in which the transaction was committed.
-     * @returns {bigint}
-     */
-    get height() {
-        const ret = wasm.txstatusresponse_height(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
 }
 
 const ValAddressFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -7369,6 +7422,16 @@ export class Vote {
     }
 }
 
+export function __wbg_Error_1f3748b298f99708(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_Number_577a493fc95ea223(arg0) {
+    const ret = Number(arg0);
+    return ret;
+};
+
 export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
     const ret = String(arg1);
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -7377,7 +7440,7 @@ export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_WorkerGlobalScope_4cdac01f57bb97d1(arg0) {
+export function __wbg_WorkerGlobalScope_68dbbc2404209578(arg0) {
     const ret = arg0.WorkerGlobalScope;
     return ret;
 };
@@ -7397,38 +7460,43 @@ export function __wbg_abciqueryresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_abort_99fc644e2c79c9fb() { return handleError(function (arg0) {
+export function __wbg_abort_496881624c2d80da() { return handleError(function (arg0) {
     arg0.abort();
 }, arguments) };
 
-export function __wbg_accountNumber_793fbe9e5a2fb839(arg0) {
+export function __wbg_accountNumber_8a52b3ddaecb3ddf(arg0) {
     const ret = arg0.accountNumber;
     return ret;
 };
 
-export function __wbg_add_4315fd553d714c24() { return handleError(function (arg0, arg1) {
-    const ret = arg0.add(arg1);
+export function __wbg_add_06c49d78d2836c4c() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.add(arg1, arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_add_9338901b80183e0f() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.add(arg1, arg2);
+export function __wbg_add_2af21486199bad83() { return handleError(function (arg0, arg1) {
+    const ret = arg0.add(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_advance_b3ccc91b80962d79() { return handleError(function (arg0, arg1) {
+export function __wbg_advance_29c64dfd5255179a() { return handleError(function (arg0, arg1) {
     arg0.advance(arg1 >>> 0);
 }, arguments) };
 
-export function __wbg_append_8c7dd8d641a5f01b() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_append_3e86b0cd6215edd8() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-export function __wbg_apply_eb9e9b97497f91e4() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_apply_90b47af8bf01ab0b() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.apply(arg0, arg1, arg2);
     return ret;
 }, arguments) };
 
+export function __wbg_appversion_new(arg0) {
+    const ret = AppVersion.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_attribute_new(arg0) {
     const ret = Attribute.__wrap(arg0);
     return ret;
@@ -7439,7 +7507,7 @@ export function __wbg_attribute_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_authInfoBytes_459e81f30c0e9c13(arg0, arg1) {
+export function __wbg_authInfoBytes_0a5d207619ad0422(arg0, arg1) {
     const ret = arg1.authInfoBytes;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7477,7 +7545,7 @@ export function __wbg_blockrange_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_bodyBytes_caa9f71ff12973cf(arg0, arg1) {
+export function __wbg_bodyBytes_75efcd7cc8472ddf(arg0, arg1) {
     const ret = arg1.bodyBytes;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7485,67 +7553,62 @@ export function __wbg_bodyBytes_caa9f71ff12973cf(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_body_0b8fd1fe671660df(arg0) {
+export function __wbg_body_be60ee806470b990(arg0) {
     const ret = arg0.body;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_buffer_09165b52af8c5237(arg0) {
-    const ret = arg0.buffer;
-    return ret;
-};
-
-export function __wbg_buffer_609cc3eee51ed158(arg0) {
+export function __wbg_buffer_1f897e9f3ed6b41d(arg0) {
     const ret = arg0.buffer;
     return ret;
 };
 
-export function __wbg_bufferedAmount_a482960ac51b25e8(arg0) {
+export function __wbg_bufferedAmount_ea4c08c898c11537(arg0) {
     const ret = arg0.bufferedAmount;
     return ret;
 };
 
-export function __wbg_byobRequest_77d9adf63337edfb(arg0) {
+export function __wbg_byobRequest_ba853121442653bf(arg0) {
     const ret = arg0.byobRequest;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_byteLength_e674b853d9c77e1d(arg0) {
+export function __wbg_byteLength_7029fecd0c136e6d(arg0) {
     const ret = arg0.byteLength;
     return ret;
 };
 
-export function __wbg_byteOffset_fd862df290ef848d(arg0) {
+export function __wbg_byteOffset_8161a341c0d72844(arg0) {
     const ret = arg0.byteOffset;
     return ret;
 };
 
-export function __wbg_call_672a4d21634d4a24() { return handleError(function (arg0, arg1) {
+export function __wbg_call_2f8d426a20a307fe() { return handleError(function (arg0, arg1) {
     const ret = arg0.call(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_call_7cccdd69e0791ae2() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_call_f53f0647ceb9c567() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_cancel_8a308660caa6cadf(arg0) {
+export function __wbg_cancel_8fc34c38a41c5d07(arg0) {
     const ret = arg0.cancel();
     return ret;
 };
 
-export function __wbg_catch_a6e601879b2610e9(arg0, arg1) {
+export function __wbg_catch_70a1618b6f59db8a(arg0, arg1) {
     const ret = arg0.catch(arg1);
     return ret;
 };
 
-export function __wbg_cause_9940c4e8dfcd5129(arg0) {
+export function __wbg_cause_94f62e1c92956ce2(arg0) {
     const ret = arg0.cause;
     return ret;
 };
 
-export function __wbg_chainId_7cdd8a461ddd3dd2(arg0, arg1) {
+export function __wbg_chainId_2a4115c1298b59d8(arg0, arg1) {
     const ret = arg1.chainId;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7553,7 +7616,7 @@ export function __wbg_chainId_7cdd8a461ddd3dd2(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_clearInterval_ad2594253cc39c4b(arg0, arg1) {
+export function __wbg_clearInterval_8488d01fe6397e53(arg0, arg1) {
     arg0.clearInterval(arg1);
 };
 
@@ -7562,14 +7625,10 @@ export function __wbg_clearInterval_dd1e598f425db353(arg0) {
     return ret;
 };
 
-export function __wbg_clearInterval_eba67734fd13a7f1(arg0, arg1) {
+export function __wbg_clearInterval_e65bc4d23bbf1edb(arg0, arg1) {
     arg0.clearInterval(arg1);
 };
 
-export function __wbg_clearTimeout_0b4dcb73f78d2d53(arg0) {
-    clearTimeout(arg0);
-};
-
 export function __wbg_clearTimeout_5a54f8841c30079a(arg0) {
     const ret = clearTimeout(arg0);
     return ret;
@@ -7580,42 +7639,46 @@ export function __wbg_clearTimeout_96804de0ab838f26(arg0) {
     return ret;
 };
 
-export function __wbg_clear_f450db7eeb71163f() { return handleError(function (arg0) {
+export function __wbg_clearTimeout_d270f24e5d43eaf7(arg0) {
+    clearTimeout(arg0);
+};
+
+export function __wbg_clear_7ddff460554dd8f9() { return handleError(function (arg0) {
     const ret = arg0.clear();
     return ret;
 }, arguments) };
 
-export function __wbg_close_26fc2e6856d8567a(arg0) {
+export function __wbg_close_5c0c68ce107ac21e(arg0) {
     arg0.close();
 };
 
-export function __wbg_close_304cc1fef3466669() { return handleError(function (arg0) {
-    arg0.close();
-}, arguments) };
-
-export function __wbg_close_5ce03e29be453811() { return handleError(function (arg0) {
-    arg0.close();
-}, arguments) };
-
-export function __wbg_close_e1253d480ed93ce3() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_close_62eb30084a8993bf() { return handleError(function (arg0, arg1, arg2, arg3) {
     arg0.close(arg1, getStringFromWasm0(arg2, arg3));
 }, arguments) };
 
-export function __wbg_close_e5b8cb333358ff37(arg0) {
+export function __wbg_close_7dcca1557b5bd08b(arg0) {
     arg0.close();
 };
 
-export function __wbg_close_fa50b16598acbea1(arg0) {
+export function __wbg_close_a90439b2444e47b4() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments) };
+
+export function __wbg_close_bffe85e60f8b736d(arg0) {
     const ret = arg0.close();
     return ret;
 };
 
-export function __wbg_closed_e969addb486e4f10(arg0) {
+export function __wbg_close_f602227805f17f95() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments) };
+
+export function __wbg_closed_2934f4ed093a9d95(arg0) {
     const ret = arg0.closed;
     return ret;
 };
 
-export function __wbg_closed_fc8592426214ee75(arg0) {
+export function __wbg_closed_8b9d023c2484076c(arg0) {
     const ret = arg0.closed;
     return ret;
 };
@@ -7630,7 +7693,7 @@ export function __wbg_coin_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_commit_ee33ba79d75a9134() { return handleError(function (arg0) {
+export function __wbg_commit_61c8d53ee2eb6843() { return handleError(function (arg0) {
     arg0.commit();
 }, arguments) };
 
@@ -7649,100 +7712,105 @@ export function __wbg_configresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_continue_91e59787d3598bbb() { return handleError(function (arg0, arg1) {
-    arg0.continue(arg1);
+export function __wbg_continue_e37b78917b01b67f() { return handleError(function (arg0) {
+    arg0.continue();
 }, arguments) };
 
-export function __wbg_continue_c46c11d3dbe1b030() { return handleError(function (arg0) {
-    arg0.continue();
+export function __wbg_continue_ff2028eeeedc8304() { return handleError(function (arg0, arg1) {
+    arg0.continue(arg1);
 }, arguments) };
 
-export function __wbg_count_613cb921d67a4f26() { return handleError(function (arg0) {
+export function __wbg_count_9a21aa97cae2b4d6() { return handleError(function (arg0) {
     const ret = arg0.count();
     return ret;
 }, arguments) };
 
-export function __wbg_count_6b062e9114662540() { return handleError(function (arg0, arg1) {
+export function __wbg_count_9d30285250b9065f() { return handleError(function (arg0, arg1) {
     const ret = arg0.count(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_count_9dbedee4d2474ff8() { return handleError(function (arg0, arg1) {
-    const ret = arg0.count(arg1);
+export function __wbg_count_d0c45be30c157193() { return handleError(function (arg0) {
+    const ret = arg0.count();
     return ret;
 }, arguments) };
 
-export function __wbg_count_ea1a2987dff7759e() { return handleError(function (arg0) {
-    const ret = arg0.count();
+export function __wbg_count_ee083e36b5119925() { return handleError(function (arg0, arg1) {
+    const ret = arg0.count(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_createBidirectionalStream_ce0a5d8a6cf37e1f(arg0) {
+export function __wbg_createBidirectionalStream_2b56e05ee223119c(arg0) {
     const ret = arg0.createBidirectionalStream();
     return ret;
 };
 
-export function __wbg_createIndex_873ac48adc772309() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_createIndex_35a1f70c8314a7de() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.createIndex(getStringFromWasm0(arg1, arg2), arg3, arg4);
     return ret;
 }, arguments) };
 
-export function __wbg_createObjectStore_d2f9e1016f4d81b9() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_createObjectStore_7e79e7f6de6b5f4a() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.createObjectStore(getStringFromWasm0(arg1, arg2), arg3);
     return ret;
 }, arguments) };
 
-export function __wbg_crypto_ed58b8e10a292839(arg0) {
+export function __wbg_crypto_574e78ad8b13b65f(arg0) {
     const ret = arg0.crypto;
     return ret;
 };
 
-export function __wbg_data_432d9c3df2630942(arg0) {
+export function __wbg_data_d1e564c046e31ed9(arg0) {
     const ret = arg0.data;
     return ret;
 };
 
-export function __wbg_debug_3cb59063b29f58c1(arg0) {
+export function __wbg_debug_9a166dc82b4ba6a6(arg0) {
     console.debug(arg0);
 };
 
-export function __wbg_deleteIndex_e6717aa0e9691894() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_deleteIndex_315fda5b473605cf() { return handleError(function (arg0, arg1, arg2) {
     arg0.deleteIndex(getStringFromWasm0(arg1, arg2));
 }, arguments) };
 
-export function __wbg_deleteObjectStore_3f08ae00cd288224() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_deleteObjectStore_8a252d9a253df02b() { return handleError(function (arg0, arg1, arg2) {
     arg0.deleteObjectStore(getStringFromWasm0(arg1, arg2));
 }, arguments) };
 
-export function __wbg_delete_200677093b4cf756() { return handleError(function (arg0, arg1) {
+export function __wbg_delete_570e5d01c731e067() { return handleError(function (arg0, arg1) {
     const ret = arg0.delete(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_desiredSize_5f5e5285daee0299() { return handleError(function (arg0, arg1) {
+export function __wbg_desiredSize_c849ec0ed245f271() { return handleError(function (arg0, arg1) {
     const ret = arg1.desiredSize;
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 }, arguments) };
 
-export function __wbg_done_769e5ede4b31c67b(arg0) {
+export function __wbg_done_4a7743b6f942c9f3(arg0) {
     const ret = arg0.done;
     return ret;
 };
 
-export function __wbg_enqueue_bb16ba72f537dc9e() { return handleError(function (arg0, arg1) {
+export function __wbg_enqueue_1e58bed4477a141f() { return handleError(function (arg0, arg1) {
     arg0.enqueue(arg1);
 }, arguments) };
 
-export function __wbg_entries_3265d4158b33e5dc(arg0) {
+export function __wbg_entries_17f7acbc2d691c0d(arg0) {
     const ret = Object.entries(arg0);
     return ret;
 };
 
-export function __wbg_error_524f506f44df1645(arg0) {
+export function __wbg_error_41f0589870426ea4(arg0) {
     console.error(arg0);
 };
 
+export function __wbg_error_443a583c581ba303() { return handleError(function (arg0) {
+    const ret = arg0.error;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}, arguments) };
+
 export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
     let deferred0_0;
     let deferred0_1;
@@ -7755,16 +7823,11 @@ export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
     }
 };
 
-export function __wbg_error_e9332df4e7a14612(arg0) {
+export function __wbg_error_cbb036e477c7f898(arg0) {
     const ret = arg0.error;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_error_ff4ddaabdfc5dbb3() { return handleError(function (arg0) {
-    const ret = arg0.error;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-}, arguments) };
-
 export function __wbg_evidence_new(arg0) {
     const ret = Evidence.__wrap(arg0);
     return ret;
@@ -7780,33 +7843,33 @@ export function __wbg_extendedheader_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_fetch_07cd86dd296a5a63(arg0, arg1, arg2) {
-    const ret = arg0.fetch(arg1, arg2);
+export function __wbg_fetch_12e13d0511844bfd(arg0) {
+    const ret = fetch(arg0);
     return ret;
 };
 
-export function __wbg_fetch_769f3df592e37b75(arg0, arg1) {
-    const ret = fetch(arg0, arg1);
+export function __wbg_fetch_4fae101547df73b6(arg0, arg1, arg2) {
+    const ret = arg0.fetch(arg1, arg2);
     return ret;
 };
 
-export function __wbg_fetch_fcf712d17584da96(arg0) {
-    const ret = fetch(arg0);
+export function __wbg_fetch_f083e6da40cefe09(arg0, arg1) {
+    const ret = fetch(arg0, arg1);
     return ret;
 };
 
-export function __wbg_from_2a5d3e218e67aa85(arg0) {
+export function __wbg_from_237b1ad767238d8b(arg0) {
     const ret = Array.from(arg0);
     return ret;
 };
 
-export function __wbg_gasLimit_311f647474d3aead(arg0, arg1) {
+export function __wbg_gasLimit_156da322edae975b(arg0, arg1) {
     const ret = arg1.gasLimit;
     getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 };
 
-export function __wbg_gasPrice_3c8789c4d0cbcbbf(arg0, arg1) {
+export function __wbg_gasPrice_7ed979d29f5321b7(arg0, arg1) {
     const ret = arg1.gasPrice;
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
@@ -7817,89 +7880,93 @@ export function __wbg_gasinfo_new(arg0) {
     return ret;
 };
 
-export function __wbg_getAllKeys_5ca511ce480c8e9b() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_getAllKeys_09176d0529f9a4f9() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.getAllKeys(arg1, arg2 >>> 0);
     return ret;
 }, arguments) };
 
-export function __wbg_getAllKeys_b0b997beb6dc99f8() { return handleError(function (arg0, arg1) {
-    const ret = arg0.getAllKeys(arg1);
+export function __wbg_getAllKeys_4c8918fa0a4d954c() { return handleError(function (arg0) {
+    const ret = arg0.getAllKeys();
     return ret;
 }, arguments) };
 
-export function __wbg_getAllKeys_b11d8835dc4be0e8() { return handleError(function (arg0) {
-    const ret = arg0.getAllKeys();
+export function __wbg_getAllKeys_bf368a2862c61f56() { return handleError(function (arg0, arg1) {
+    const ret = arg0.getAllKeys(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_getAll_1de5635a99f2dae8() { return handleError(function (arg0) {
+export function __wbg_getAll_2a18c462536d7d5b() { return handleError(function (arg0) {
     const ret = arg0.getAll();
     return ret;
 }, arguments) };
 
-export function __wbg_getAll_e1f497a121218ab5() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_getAll_2e19a7bbbe1ec181() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.getAll(arg1, arg2 >>> 0);
     return ret;
 }, arguments) };
 
-export function __wbg_getAll_e6903c610babcd42() { return handleError(function (arg0, arg1) {
+export function __wbg_getAll_7a5b8dd1d868e440() { return handleError(function (arg0, arg1) {
     const ret = arg0.getAll(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_getRandomValues_bcb4912f16000dc4() { return handleError(function (arg0, arg1) {
+export function __wbg_getRandomValues_3c9c0d586e575a16() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments) };
+
+export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
     arg0.getRandomValues(arg1);
 }, arguments) };
 
-export function __wbg_getReader_48e00749fe3f6089() { return handleError(function (arg0) {
+export function __wbg_getReader_27f9715838e256b2(arg0) {
     const ret = arg0.getReader();
     return ret;
-}, arguments) };
+};
 
-export function __wbg_getReader_be0d36e5873a525b(arg0) {
+export function __wbg_getReader_48e00749fe3f6089() { return handleError(function (arg0) {
     const ret = arg0.getReader();
     return ret;
-};
+}, arguments) };
 
-export function __wbg_getTime_46267b1c24877e30(arg0) {
+export function __wbg_getTime_5b1dd03bb6d4b784(arg0) {
     const ret = arg0.getTime();
     return ret;
 };
 
-export function __wbg_getWriter_6ce182d0adc3f96b() { return handleError(function (arg0) {
+export function __wbg_getWriter_fec94836a07e1d6d() { return handleError(function (arg0) {
     const ret = arg0.getWriter();
     return ret;
 }, arguments) };
 
-export function __wbg_get_4f73335ab78445db(arg0, arg1, arg2) {
-    const ret = arg1[arg2 >>> 0];
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-};
-
-export function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) {
+export function __wbg_get_27b4bcbec57323ca() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_get_8da03f81f6a1111e() { return handleError(function (arg0, arg1) {
+export function __wbg_get_59c6316d15f9f1d0(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+};
+
+export function __wbg_get_5cb5417d5a49cef1() { return handleError(function (arg0, arg1) {
     const ret = arg0.get(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_get_93e54e8e166fbcab() { return handleError(function (arg0, arg1) {
+export function __wbg_get_a0f588b1e212306e() { return handleError(function (arg0, arg1) {
     const ret = arg0.get(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
-    const ret = arg0[arg1 >>> 0];
-    return ret;
+export function __wbg_get_ff3a515076fdddd7(arg0, arg1, arg2) {
+    const ret = arg1[arg2 >>> 0];
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_getdone_d47073731acd3e74(arg0) {
+export function __wbg_getdone_8d12e2c5bfa23fbd(arg0) {
     const ret = arg0.done;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 };
@@ -7909,7 +7976,7 @@ export function __wbg_gettxresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_getvalue_009dcd63692bee1f(arg0) {
+export function __wbg_getvalue_8d746ccec318477b(arg0) {
     const ret = arg0.value;
     return ret;
 };
@@ -7919,46 +7986,41 @@ export function __wbg_getwithrefkey_1dc361bd10053bfe(arg0, arg1) {
     return ret;
 };
 
-export function __wbg_grpcclient_new(arg0) {
-    const ret = GrpcClient.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_has_a5ea9117f258a0ec() { return handleError(function (arg0, arg1) {
+export function __wbg_has_85abdd8aeb8edebf() { return handleError(function (arg0, arg1) {
     const ret = Reflect.has(arg0, arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_headers_7852a8ea641c1379(arg0) {
+export function __wbg_headers_177bc880a5823968(arg0) {
     const ret = arg0.headers;
     return ret;
 };
 
-export function __wbg_headers_9cb51cfd2ac780a4(arg0) {
+export function __wbg_headers_391e2f64884c873b(arg0) {
     const ret = arg0.headers;
     return ret;
 };
 
-export function __wbg_incomingBidirectionalStreams_45cd400ea1420fe3(arg0) {
+export function __wbg_incomingBidirectionalStreams_ed7915830e8f8998(arg0) {
     const ret = arg0.incomingBidirectionalStreams;
     return ret;
 };
 
-export function __wbg_indexNames_0ed82a19d7d88aa3(arg0) {
+export function __wbg_indexNames_b7e419e1b5950062(arg0) {
     const ret = arg0.indexNames;
     return ret;
 };
 
-export function __wbg_index_e00ca5fff206ee3e() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_index_7f799b7efa7c11c6() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.index(getStringFromWasm0(arg1, arg2));
     return ret;
 }, arguments) };
 
-export function __wbg_info_3daf2e093e091b66(arg0) {
+export function __wbg_info_ed6e390d09c09062(arg0) {
     console.info(arg0);
 };
 
-export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
+export function __wbg_instanceof_ArrayBuffer_59339a3a6f0c10ea(arg0) {
     let result;
     try {
         result = arg0 instanceof ArrayBuffer;
@@ -7969,7 +8031,7 @@ export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_DedicatedWorkerGlobalScope_a688e81380e34e02(arg0) {
+export function __wbg_instanceof_DedicatedWorkerGlobalScope_95bda3b36127a15b(arg0) {
     let result;
     try {
         result = arg0 instanceof DedicatedWorkerGlobalScope;
@@ -7980,7 +8042,7 @@ export function __wbg_instanceof_DedicatedWorkerGlobalScope_a688e81380e34e02(arg
     return ret;
 };
 
-export function __wbg_instanceof_Error_4d54113b22d20306(arg0) {
+export function __wbg_instanceof_Error_1e51a63e1736444c(arg0) {
     let result;
     try {
         result = arg0 instanceof Error;
@@ -7991,7 +8053,7 @@ export function __wbg_instanceof_Error_4d54113b22d20306(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbCursorWithValue_18f39d69ed298f6f(arg0) {
+export function __wbg_instanceof_IdbCursorWithValue_bbe42f8954141db8(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBCursorWithValue;
@@ -8002,7 +8064,7 @@ export function __wbg_instanceof_IdbCursorWithValue_18f39d69ed298f6f(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbDatabase_a3ef009ca00059f9(arg0) {
+export function __wbg_instanceof_IdbDatabase_48c551909b7652c5(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBDatabase;
@@ -8013,7 +8075,7 @@ export function __wbg_instanceof_IdbDatabase_a3ef009ca00059f9(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbFactory_12eaba3366f4302f(arg0) {
+export function __wbg_instanceof_IdbFactory_e429f3e72d6a6d94(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBFactory;
@@ -8024,7 +8086,7 @@ export function __wbg_instanceof_IdbFactory_12eaba3366f4302f(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbOpenDbRequest_a3416e156c9db893(arg0) {
+export function __wbg_instanceof_IdbOpenDbRequest_822b13f85bf6d91f(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBOpenDBRequest;
@@ -8035,7 +8097,7 @@ export function __wbg_instanceof_IdbOpenDbRequest_a3416e156c9db893(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbRequest_4813c3f207666aa4(arg0) {
+export function __wbg_instanceof_IdbRequest_591f189bf6c335cc(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBRequest;
@@ -8046,7 +8108,7 @@ export function __wbg_instanceof_IdbRequest_4813c3f207666aa4(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_IdbTransaction_746ea660d347650d(arg0) {
+export function __wbg_instanceof_IdbTransaction_7a1d07a52299c4f9(arg0) {
     let result;
     try {
         result = arg0 instanceof IDBTransaction;
@@ -8057,7 +8119,7 @@ export function __wbg_instanceof_IdbTransaction_746ea660d347650d(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
+export function __wbg_instanceof_Map_dd89a82d76d1b25f(arg0) {
     let result;
     try {
         result = arg0 instanceof Map;
@@ -8068,7 +8130,7 @@ export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_Promise_935168b8f4b49db3(arg0) {
+export function __wbg_instanceof_Promise_1147df2e75727145(arg0) {
     let result;
     try {
         result = arg0 instanceof Promise;
@@ -8079,7 +8141,7 @@ export function __wbg_instanceof_Promise_935168b8f4b49db3(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_ReadableStreamDefaultReader_056dcea99b3557aa(arg0) {
+export function __wbg_instanceof_ReadableStreamDefaultReader_0c3606441afabcc8(arg0) {
     let result;
     try {
         result = arg0 instanceof ReadableStreamDefaultReader;
@@ -8090,7 +8152,7 @@ export function __wbg_instanceof_ReadableStreamDefaultReader_056dcea99b3557aa(ar
     return ret;
 };
 
-export function __wbg_instanceof_Response_f2cc20d9f7dfd644(arg0) {
+export function __wbg_instanceof_Response_0ab386c6818f788a(arg0) {
     let result;
     try {
         result = arg0 instanceof Response;
@@ -8101,7 +8163,7 @@ export function __wbg_instanceof_Response_f2cc20d9f7dfd644(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_ServiceWorkerGlobalScope_9662fcbac1190e8b(arg0) {
+export function __wbg_instanceof_ServiceWorkerGlobalScope_8b30335633410516(arg0) {
     let result;
     try {
         result = arg0 instanceof ServiceWorkerGlobalScope;
@@ -8112,7 +8174,7 @@ export function __wbg_instanceof_ServiceWorkerGlobalScope_9662fcbac1190e8b(arg0)
     return ret;
 };
 
-export function __wbg_instanceof_SharedWorkerGlobalScope_1796b9b4c3344538(arg0) {
+export function __wbg_instanceof_SharedWorkerGlobalScope_c0b9e45163c1a675(arg0) {
     let result;
     try {
         result = arg0 instanceof SharedWorkerGlobalScope;
@@ -8123,7 +8185,7 @@ export function __wbg_instanceof_SharedWorkerGlobalScope_1796b9b4c3344538(arg0)
     return ret;
 };
 
-export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
+export function __wbg_instanceof_Uint8Array_91f3c5adee7e6672(arg0) {
     let result;
     try {
         result = arg0 instanceof Uint8Array;
@@ -8134,7 +8196,7 @@ export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_WebTransportBidirectionalStream_e00b12a4618e81ef(arg0) {
+export function __wbg_instanceof_WebTransportBidirectionalStream_65ff63c49f91f97a(arg0) {
     let result;
     try {
         result = arg0 instanceof WebTransportBidirectionalStream;
@@ -8145,7 +8207,7 @@ export function __wbg_instanceof_WebTransportBidirectionalStream_e00b12a4618e81e
     return ret;
 };
 
-export function __wbg_instanceof_Window_def73ea0955fc569(arg0) {
+export function __wbg_instanceof_Window_7f29e5c72acbfd60(arg0) {
     let result;
     try {
         result = arg0 instanceof Window;
@@ -8156,17 +8218,22 @@ export function __wbg_instanceof_Window_def73ea0955fc569(arg0) {
     return ret;
 };
 
-export function __wbg_isArray_a1eab7e0d067391b(arg0) {
+export function __wbg_isArray_55c23353d58297fd(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 };
 
-export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) {
+export function __wbg_isArray_bc2498eba6fcb71f(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+};
+
+export function __wbg_isSafeInteger_6091d6e3ee1b65fd(arg0) {
     const ret = Number.isSafeInteger(arg0);
     return ret;
 };
 
-export function __wbg_iterator_9a24c88df860dc65() {
+export function __wbg_iterator_96378c3c9a17347c() {
     const ret = Symbol.iterator;
     return ret;
 };
@@ -8186,7 +8253,7 @@ export function __wbg_jseventattribute_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_json_1671bfa3e3625686() { return handleError(function (arg0) {
+export function __wbg_json_dbaa85a926a80ed5() { return handleError(function (arg0) {
     const ret = arg0.json();
     return ret;
 }, arguments) };
@@ -8201,32 +8268,32 @@ export function __wbg_jsvalidatorinfo_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_keyPath_443ecf3f74202169() { return handleError(function (arg0) {
+export function __wbg_keyPath_2635ad1da5c21128() { return handleError(function (arg0) {
     const ret = arg0.keyPath;
     return ret;
 }, arguments) };
 
-export function __wbg_key_29fefecef430db96() { return handleError(function (arg0) {
+export function __wbg_key_54dc8730fa36ae65() { return handleError(function (arg0) {
     const ret = arg0.key;
     return ret;
 }, arguments) };
 
-export function __wbg_length_52b6c4580c5ec934(arg0) {
+export function __wbg_length_1161036d400ff5c6(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-export function __wbg_length_a446193dc22c12f8(arg0) {
+export function __wbg_length_246fa1f85a0dea5b(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-export function __wbg_length_e2d2a49132c1b256(arg0) {
+export function __wbg_length_904c0910ed998bf3(arg0) {
     const ret = arg0.length;
     return ret;
 };
 
-export function __wbg_memo_06f326dadb7e1baa(arg0, arg1) {
+export function __wbg_memo_aceadb714ed9785c(arg0, arg1) {
     const ret = arg1.memo;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len1 = WASM_VECTOR_LEN;
@@ -8234,7 +8301,7 @@ export function __wbg_memo_06f326dadb7e1baa(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_message_97a2af9b89d693a3(arg0) {
+export function __wbg_message_86bd7dcf158b1dda(arg0) {
     const ret = arg0.message;
     return ret;
 };
@@ -8244,27 +8311,27 @@ export function __wbg_modeinfo_new(arg0) {
     return ret;
 };
 
-export function __wbg_msCrypto_0a36e2ec3a343d26(arg0) {
+export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
     const ret = arg0.msCrypto;
     return ret;
 };
 
-export function __wbg_multiEntry_c146ebd38a5de9ea(arg0) {
+export function __wbg_multiEntry_a88b8b7336fb09ab(arg0) {
     const ret = arg0.multiEntry;
     return ret;
 };
 
-export function __wbg_name_0b327d569f00ebee(arg0) {
+export function __wbg_name_4eed68a70c7faf2a(arg0) {
     const ret = arg0.name;
     return ret;
 };
 
-export function __wbg_navigator_0a9bf1120e24fec2(arg0) {
+export function __wbg_navigator_2de7a59c1ede3ea5(arg0) {
     const ret = arg0.navigator;
     return ret;
 };
 
-export function __wbg_navigator_1577371c070c8947(arg0) {
+export function __wbg_navigator_b6d1cae68d750613(arg0) {
     const ret = arg0.navigator;
     return ret;
 };
@@ -8274,24 +8341,49 @@ export function __wbg_networkinfosnapshot_new(arg0) {
     return ret;
 };
 
-export function __wbg_new0_f788a2397c7ca929() {
+export function __wbg_new0_85cc856927102294() {
     const ret = new Date();
     return ret;
 };
 
-export function __wbg_new_018dcc2d6c8c2f6a() { return handleError(function () {
+export function __wbg_new_12588505388d0897() { return handleError(function () {
     const ret = new Headers();
     return ret;
 }, arguments) };
 
-export function __wbg_new_23a2665fac83c611(arg0, arg1) {
+export function __wbg_new_1930cbb8d9ffc31b() {
+    const ret = new Object();
+    return ret;
+};
+
+export function __wbg_new_56407f99198feff7() {
+    const ret = new Map();
+    return ret;
+};
+
+export function __wbg_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return ret;
+};
+
+export function __wbg_new_9190433fb67ed635(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+export function __wbg_new_97ddeb994a38bb69(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+export function __wbg_new_d5e3800b120e37e1(arg0, arg1) {
     try {
         var state0 = {a: arg0, b: arg1};
         var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_985(a, state0.b, arg0, arg1);
+                return __wbg_adapter_982(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -8303,87 +8395,67 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
     }
 };
 
-export function __wbg_new_405e22f390576ce2() {
-    const ret = new Object();
-    return ret;
-};
-
-export function __wbg_new_5e0be73521bc8c17() {
-    const ret = new Map();
+export function __wbg_new_d85e20a34917132b() { return handleError(function (arg0, arg1) {
+    const ret = new WebTransport(getStringFromWasm0(arg0, arg1));
     return ret;
-};
+}, arguments) };
 
-export function __wbg_new_78feb108b6472713() {
+export function __wbg_new_e969dc3f68d25093() {
     const ret = new Array();
     return ret;
 };
 
-export function __wbg_new_7f19378ebfdc87d5() { return handleError(function (arg0, arg1) {
+export function __wbg_new_f450b111eed28700() { return handleError(function (arg0, arg1) {
     const ret = new BroadcastChannel(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-export function __wbg_new_8a6f238a6ece86ea() {
-    const ret = new Error();
-    return ret;
-};
-
-export function __wbg_new_92c54fc74574ef55() { return handleError(function (arg0, arg1) {
+export function __wbg_new_fb0d376a3c915f60() { return handleError(function (arg0, arg1) {
     const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
     return ret;
 }, arguments) };
 
-export function __wbg_new_a12002a7f91c75be(arg0) {
-    const ret = new Uint8Array(arg0);
-    return ret;
-};
-
-export function __wbg_new_c68d7209be747379(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
+export function __wbg_newfromslice_d0d56929c6d9c842(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
     return ret;
 };
 
-export function __wbg_new_e5bafad665ca8709() { return handleError(function (arg0, arg1) {
-    const ret = new WebTransport(getStringFromWasm0(arg0, arg1));
-    return ret;
-}, arguments) };
-
-export function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) {
+export function __wbg_newnoargs_a81330f6e05d8aca(arg0, arg1) {
     const ret = new Function(getStringFromWasm0(arg0, arg1));
     return ret;
 };
 
-export function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
+export function __wbg_newwithbyteoffsetandlength_9aade108cd45cf37(arg0, arg1, arg2) {
     const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
 
-export function __wbg_newwithlength_a381634e90c276d4(arg0) {
+export function __wbg_newwithlength_ed0ee6c1edca86fc(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
 };
 
-export function __wbg_newwithoptions_b1f31e2ae78beef9() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_newwithoptions_1ba541b69f220543() { return handleError(function (arg0, arg1, arg2) {
     const ret = new WebTransport(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_newwithstrandinit_06c535e0a867c635() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_newwithstrandinit_e8e22e9851f3c2fe() { return handleError(function (arg0, arg1, arg2) {
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_next_25feadfc0913fea9(arg0) {
-    const ret = arg0.next;
-    return ret;
-};
-
-export function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg0) {
+export function __wbg_next_2e6b37020ac5fe58() { return handleError(function (arg0) {
     const ret = arg0.next();
     return ret;
 }, arguments) };
 
-export function __wbg_node_02999533c4ea02e3(arg0) {
+export function __wbg_next_3de8f2669431a3ff(arg0) {
+    const ret = arg0.next;
+    return ret;
+};
+
+export function __wbg_node_905d3e251edff8a2(arg0) {
     const ret = arg0.node;
     return ret;
 };
@@ -8393,62 +8465,62 @@ export function __wbg_nodeclient_new(arg0) {
     return ret;
 };
 
-export function __wbg_now_2c95c9de01293173(arg0) {
+export function __wbg_now_1f875e5cd673bc3c(arg0) {
     const ret = arg0.now();
     return ret;
 };
 
-export function __wbg_now_807e54c39636c349() {
-    const ret = Date.now();
+export function __wbg_now_2c95c9de01293173(arg0) {
+    const ret = arg0.now();
     return ret;
 };
 
-export function __wbg_now_d18023d54d4e5500(arg0) {
-    const ret = arg0.now();
+export function __wbg_now_e3057dd824ca0191() {
+    const ret = Date.now();
     return ret;
 };
 
-export function __wbg_objectStoreNames_9bb1ab04a7012aaf(arg0) {
+export function __wbg_objectStoreNames_9f871922c78ae388(arg0) {
     const ret = arg0.objectStoreNames;
     return ret;
 };
 
-export function __wbg_objectStore_21878d46d25b64b6() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_objectStore_4f9dafdbff77fd83() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.objectStore(getStringFromWasm0(arg1, arg2));
     return ret;
 }, arguments) };
 
-export function __wbg_of_2eaf5a02d443ef03(arg0) {
+export function __wbg_of_0082112f5d8d608a(arg0) {
     const ret = Array.of(arg0);
     return ret;
 };
 
-export function __wbg_only_f1a0276dacb43f09() { return handleError(function (arg0) {
+export function __wbg_only_1c4292e278018189() { return handleError(function (arg0) {
     const ret = IDBKeyRange.only(arg0);
     return ret;
 }, arguments) };
 
-export function __wbg_openCursor_238e247d18bde2cd() { return handleError(function (arg0) {
-    const ret = arg0.openCursor();
+export function __wbg_openCursor_2b0233fcb8713b84() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.openCursor(arg1, __wbindgen_enum_IdbCursorDirection[arg2]);
     return ret;
 }, arguments) };
 
-export function __wbg_openCursor_6fd4dab51810d238() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.openCursor(arg1, __wbindgen_enum_IdbCursorDirection[arg2]);
+export function __wbg_openCursor_46a38ced59324ff5() { return handleError(function (arg0) {
+    const ret = arg0.openCursor();
     return ret;
 }, arguments) };
 
-export function __wbg_openCursor_f4b061aa6d804b93() { return handleError(function (arg0, arg1) {
+export function __wbg_openCursor_f0969faec4c47a9f() { return handleError(function (arg0, arg1) {
     const ret = arg0.openCursor(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_open_88b1390d99a7c691() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_open_4ccfb9986e8733c9() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.open(getStringFromWasm0(arg1, arg2));
     return ret;
 }, arguments) };
 
-export function __wbg_open_e0c0b2993eb596e1() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_open_bf329a7c677f6eb3() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
     return ret;
 }, arguments) };
@@ -8463,34 +8535,34 @@ export function __wbg_performance_7a3ffd0b17f663ad(arg0) {
     return ret;
 };
 
-export function __wbg_persist_61cdcca08bf2d1a2() { return handleError(function (arg0) {
+export function __wbg_persist_1bb8fe4abf4a1238() { return handleError(function (arg0) {
     const ret = arg0.persist();
     return ret;
 }, arguments) };
 
-export function __wbg_ports_b00492ca2866b691(arg0) {
+export function __wbg_ports_9c55c10a9e47462c(arg0) {
     const ret = arg0.ports;
     return ret;
 };
 
-export function __wbg_postMessage_78b9d96b91e90fe8() { return handleError(function (arg0, arg1, arg2) {
-    arg0.postMessage(arg1, arg2);
+export function __wbg_postMessage_3b4fb1cda6756bf0() { return handleError(function (arg0, arg1) {
+    arg0.postMessage(arg1);
 }, arguments) };
 
-export function __wbg_postMessage_bb72e89e7ba80355() { return handleError(function (arg0, arg1) {
-    arg0.postMessage(arg1);
+export function __wbg_postMessage_b9234f931da7f86a() { return handleError(function (arg0, arg1, arg2) {
+    arg0.postMessage(arg1, arg2);
 }, arguments) };
 
-export function __wbg_postMessage_dad5a2d9dc6765f8() { return handleError(function (arg0, arg1) {
+export function __wbg_postMessage_ecb1e9ee54a5b2f1() { return handleError(function (arg0, arg1) {
     arg0.postMessage(arg1);
 }, arguments) };
 
-export function __wbg_priority_d731a1c041cc1e6f(arg0) {
+export function __wbg_priority_1990e2825970b82f(arg0) {
     const ret = arg0.priority;
     return isLikeNone(ret) ? 0 : ret;
 };
 
-export function __wbg_process_5c1d670bc53614b8(arg0) {
+export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
     const ret = arg0.process;
     return ret;
 };
@@ -8505,88 +8577,97 @@ export function __wbg_proofop_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_push_737cfc8c1432c2c6(arg0, arg1) {
+export function __wbg_prototypesetcall_c5f74efd31aea86b(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+export function __wbg_push_cd3ac7d5b094565d(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
 };
 
-export function __wbg_put_066faa31a6a88f5b() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_put_26029bce45af287b() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.put(arg1, arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_put_9ef5363941008835() { return handleError(function (arg0, arg1) {
+export function __wbg_put_adbbd8f247db7544() { return handleError(function (arg0, arg1) {
     const ret = arg0.put(arg1);
     return ret;
 }, arguments) };
 
-export function __wbg_queueMicrotask_97d92b4fcc8a61c5(arg0) {
-    queueMicrotask(arg0);
-};
-
-export function __wbg_queueMicrotask_d3219def82552485(arg0) {
+export function __wbg_queueMicrotask_bcc6e26d899696db(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
 };
 
-export function __wbg_randomFillSync_ab2cfe79ebbf2740() { return handleError(function (arg0, arg1) {
+export function __wbg_queueMicrotask_f24a794d09c42640(arg0) {
+    queueMicrotask(arg0);
+};
+
+export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
     arg0.randomFillSync(arg1);
 }, arguments) };
 
-export function __wbg_random_3ad904d98382defe() {
+export function __wbg_random_57255a777f5a0573() {
     const ret = Math.random();
     return ret;
 };
 
-export function __wbg_read_a2434af1186cb56c(arg0) {
+export function __wbg_read_dc3d89b58ce2ae65(arg0) {
     const ret = arg0.read();
     return ret;
 };
 
-export function __wbg_readable_dd443629eabf2027(arg0) {
+export function __wbg_readable_e39b6396dce1aa98(arg0) {
     const ret = arg0.readable;
     return ret;
 };
 
-export function __wbg_readyState_7ef6e63c349899ed(arg0) {
+export function __wbg_readyState_e97ec9955f858a83(arg0) {
     const ret = arg0.readyState;
     return ret;
 };
 
-export function __wbg_ready_103c23b8fd46adc5(arg0) {
+export function __wbg_ready_a624cdffdc1b39dc(arg0) {
     const ret = arg0.ready;
     return ret;
 };
 
-export function __wbg_ready_480b0e63c18378c7(arg0) {
+export function __wbg_ready_a8d2b97e1fe33dcb(arg0) {
     const ret = arg0.ready;
     return ret;
 };
 
-export function __wbg_releaseLock_091899af97991d2e(arg0) {
+export function __wbg_releaseLock_fbec365467db2e6c(arg0) {
     arg0.releaseLock();
 };
 
-export function __wbg_request_695d684a1f4bb96e(arg0) {
+export function __wbg_request_3be0f0335cc6a465(arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.request(getStringFromWasm0(arg1, arg2), arg3, arg4);
+    return ret;
+};
+
+export function __wbg_request_d6e49e725ba3024b(arg0) {
     const ret = arg0.request;
     return ret;
 };
 
-export function __wbg_require_79b1e9274cde3c87() { return handleError(function () {
+export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
     const ret = module.require;
     return ret;
 }, arguments) };
 
-export function __wbg_resolve_4851785c9c5f573d(arg0) {
+export function __wbg_resolve_5775c0ef9222f556(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
 };
 
-export function __wbg_respond_1f279fa9f8edcb1c() { return handleError(function (arg0, arg1) {
+export function __wbg_respond_0003f7c68aa35ef6() { return handleError(function (arg0, arg1) {
     arg0.respond(arg1 >>> 0);
 }, arguments) };
 
-export function __wbg_result_f29afabdf2c05826() { return handleError(function (arg0) {
+export function __wbg_result_b30a0a7bc6b6345f() { return handleError(function (arg0) {
     const ret = arg0.result;
     return ret;
 }, arguments) };
@@ -8596,16 +8677,16 @@ export function __wbg_samplingmetadata_new(arg0) {
     return ret;
 };
 
-export function __wbg_send_fc0c204e8a1757f4() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_send_f0af552dcc5d8183() { return handleError(function (arg0, arg1, arg2) {
     arg0.send(getArrayU8FromWasm0(arg1, arg2));
 }, arguments) };
 
-export function __wbg_setInterval_83d54331ceeda644() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_setInterval_a708e6782af78d02() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.setInterval(arg1, arg2, ...arg3);
     return ret;
 }, arguments) };
 
-export function __wbg_setInterval_d4f8bdcc1d5b1da9() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_setInterval_deb388473d598809() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.setInterval(arg1, arg2, ...arg3);
     return ret;
 }, arguments) };
@@ -8615,7 +8696,7 @@ export function __wbg_setInterval_ed3b5e3c3ebb8a6d() { return handleError(functi
     return ret;
 }, arguments) };
 
-export function __wbg_setTimeout_683839f43a962892(arg0, arg1) {
+export function __wbg_setTimeout_c19d61d90c66d11f(arg0, arg1) {
     const ret = setTimeout(arg0, arg1 >>> 0);
     return ret;
 };
@@ -8630,137 +8711,137 @@ export function __wbg_setTimeout_eefe7f4c234b0c6b() { return handleError(functio
     return ret;
 }, arguments) };
 
-export function __wbg_set_11cd83f45504cedf() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_set_1d5fe1e3f51a48d8(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
+};
+
+export function __wbg_set_2df374478acad331() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
 
-export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
-    arg0[arg1 >>> 0] = arg2;
+export function __wbg_set_31197016f65a6a19(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
 };
 
 export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
     arg0[arg1] = arg2;
 };
 
-export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
-    arg0.set(arg1, arg2 >>> 0);
-};
-
-export function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) {
-    const ret = arg0.set(arg1, arg2);
-    return ret;
-};
-
-export function __wbg_set_bb8cecf6a62b9f46() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_set_b33e7a98099eed58() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(arg0, arg1, arg2);
     return ret;
 }, arguments) };
 
-export function __wbg_setautoincrement_8b4327709e9ee7d9(arg0, arg1) {
+export function __wbg_set_d636a0463acf1dbc(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+export function __wbg_setautoincrement_5ae17c87fe2d4f9b(arg0, arg1) {
     arg0.autoIncrement = arg1 !== 0;
 };
 
-export function __wbg_setbinaryType_92fa1ffd873b327c(arg0, arg1) {
+export function __wbg_setbinaryType_c6d319ec56ffc9f5(arg0, arg1) {
     arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
 };
 
-export function __wbg_setbody_5923b78a95eedf29(arg0, arg1) {
+export function __wbg_setbody_e324371c31597f2a(arg0, arg1) {
     arg0.body = arg1;
 };
 
-export function __wbg_setcache_12f17c3a980650e4(arg0, arg1) {
+export function __wbg_setcache_7c95e3469a5bfb76(arg0, arg1) {
     arg0.cache = __wbindgen_enum_RequestCache[arg1];
 };
 
-export function __wbg_setcause_180f5110152d3ce3(arg0, arg1) {
+export function __wbg_setcause_b0108db2f5bad08c(arg0, arg1) {
     arg0.cause = arg1;
 };
 
-export function __wbg_setcredentials_c3a22f1cd105a2c6(arg0, arg1) {
+export function __wbg_setcredentials_55a9317ed2777533(arg0, arg1) {
     arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
 };
 
-export function __wbg_setheaders_834c0bdb6a8949ad(arg0, arg1) {
+export function __wbg_setheaders_ac0b1e4890a949cd(arg0, arg1) {
     arg0.headers = arg1;
 };
 
-export function __wbg_setintegrity_564a2397cf837760(arg0, arg1, arg2) {
+export function __wbg_setintegrity_b99a69a0174d6d2d(arg0, arg1, arg2) {
     arg0.integrity = getStringFromWasm0(arg1, arg2);
 };
 
-export function __wbg_setkeypath_691179e313c26ae1(arg0, arg1) {
+export function __wbg_setkeypath_8d8c800a95646c4d(arg0, arg1) {
     arg0.keyPath = arg1;
 };
 
-export function __wbg_setmethod_3c5280fe5d890842(arg0, arg1, arg2) {
+export function __wbg_setmethod_9ce6e95af1ae0eaf(arg0, arg1, arg2) {
     arg0.method = getStringFromWasm0(arg1, arg2);
 };
 
-export function __wbg_setmode_5dc300b865044b65(arg0, arg1) {
+export function __wbg_setmode_b89d1784e7e7f118(arg0, arg1) {
     arg0.mode = __wbindgen_enum_RequestMode[arg1];
 };
 
-export function __wbg_setmultientry_4c4eee871f29837a(arg0, arg1) {
+export function __wbg_setmultientry_2d965bfbe831d349(arg0, arg1) {
     arg0.multiEntry = arg1 !== 0;
 };
 
-export function __wbg_setonabort_3bf4db6614fa98e9(arg0, arg1) {
+export function __wbg_setonabort_2b64fe553e1f30a5(arg0, arg1) {
     arg0.onabort = arg1;
 };
 
-export function __wbg_setonclose_14fc475a49d488fc(arg0, arg1) {
+export function __wbg_setonclose_31fecac020b76f64(arg0, arg1) {
     arg0.onclose = arg1;
 };
 
-export function __wbg_setoncomplete_4d19df0dadb7c4d4(arg0, arg1) {
+export function __wbg_setoncomplete_2dee9e6e91eb390c(arg0, arg1) {
     arg0.oncomplete = arg1;
 };
 
-export function __wbg_setonerror_8639efe354b947cd(arg0, arg1) {
+export function __wbg_setonerror_12c7b6aa014e29ff(arg0, arg1) {
     arg0.onerror = arg1;
 };
 
-export function __wbg_setonerror_b0d9d723b8fddbbb(arg0, arg1) {
+export function __wbg_setonerror_1c09126416a8732a(arg0, arg1) {
     arg0.onerror = arg1;
 };
 
-export function __wbg_setonerror_d7e3056cc6e56085(arg0, arg1) {
+export function __wbg_setonerror_d12d470adff34fe2(arg0, arg1) {
     arg0.onerror = arg1;
 };
 
-export function __wbg_setonmessage_6eccab530a8fb4c7(arg0, arg1) {
+export function __wbg_setonmessage_202c21ecebb3d86d(arg0, arg1) {
     arg0.onmessage = arg1;
 };
 
-export function __wbg_setonopen_2da654e1f39745d5(arg0, arg1) {
+export function __wbg_setonopen_dbb4e4d6121f7c34(arg0, arg1) {
     arg0.onopen = arg1;
 };
 
-export function __wbg_setonsuccess_afa464ee777a396d(arg0, arg1) {
+export function __wbg_setonsuccess_81a109828a9b7d7c(arg0, arg1) {
     arg0.onsuccess = arg1;
 };
 
-export function __wbg_setonupgradeneeded_fcf7ce4f2eb0cb5f(arg0, arg1) {
+export function __wbg_setonupgradeneeded_41c59fde839b5142(arg0, arg1) {
     arg0.onupgradeneeded = arg1;
 };
 
-export function __wbg_setonversionchange_6ee07fa49ee1e3a5(arg0, arg1) {
+export function __wbg_setonversionchange_6d4cf4b5eafafccc(arg0, arg1) {
     arg0.onversionchange = arg1;
 };
 
-export function __wbg_setredirect_40e6a7f717a2f86a(arg0, arg1) {
+export function __wbg_setredirect_4017ceebe5aecf8c(arg0, arg1) {
     arg0.redirect = __wbindgen_enum_RequestRedirect[arg1];
 };
 
-export function __wbg_setreferrer_fea46c1230e5e29a(arg0, arg1, arg2) {
+export function __wbg_setreferrer_4625041984f4c279(arg0, arg1, arg2) {
     arg0.referrer = getStringFromWasm0(arg1, arg2);
 };
 
-export function __wbg_setreferrerpolicy_b73612479f761b6f(arg0, arg1) {
+export function __wbg_setreferrerpolicy_16cc29e0e528b435(arg0, arg1) {
     arg0.referrerPolicy = __wbindgen_enum_ReferrerPolicy[arg1];
 };
 
-export function __wbg_setunique_dd24c422aa05df89(arg0, arg1) {
+export function __wbg_setunique_bccba0d1ccd21f16(arg0, arg1) {
     arg0.unique = arg1 !== 0;
 };
 
@@ -8779,7 +8860,7 @@ export function __wbg_signerinfo_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_slice_9272f90890997145(arg0, arg1, arg2) {
+export function __wbg_slice_4d3ad79b14a0c0ec(arg0, arg1, arg2) {
     const ret = arg0.slice(arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
@@ -8792,37 +8873,37 @@ export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_static_accessor_GLOBAL_88a902d13a557d07() {
+export function __wbg_static_accessor_GLOBAL_1f13249cc3acc96d() {
     const ret = typeof global === 'undefined' ? null : global;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() {
+export function __wbg_static_accessor_GLOBAL_THIS_df7ae94b1e0ed6a3() {
     const ret = typeof globalThis === 'undefined' ? null : globalThis;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_static_accessor_SELF_37c5d418e4bf5819() {
+export function __wbg_static_accessor_SELF_6265471db3b3c228() {
     const ret = typeof self === 'undefined' ? null : self;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_static_accessor_WINDOW_5de37043a91a9c40() {
+export function __wbg_static_accessor_WINDOW_16fb482f8ec52863() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_status_f6360336ca686bf0(arg0) {
+export function __wbg_status_31874648c8651949(arg0) {
     const ret = arg0.status;
     return ret;
 };
 
-export function __wbg_storage_07eb754b88898955(arg0) {
+export function __wbg_storage_144f3515656273ac(arg0) {
     const ret = arg0.storage;
     return ret;
 };
 
-export function __wbg_storage_89a3fec18b19e1aa(arg0) {
+export function __wbg_storage_f49596759b4c8730(arg0) {
     const ret = arg0.storage;
     return ret;
 };
@@ -8837,7 +8918,7 @@ export function __wbg_stringevent_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_subarray_aa9065fa9dc5df96(arg0, arg1, arg2) {
+export function __wbg_subarray_a219824899e59712(arg0, arg1, arg2) {
     const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
     return ret;
 };
@@ -8847,45 +8928,40 @@ export function __wbg_syncinginfosnapshot_new(arg0) {
     return ret;
 };
 
-export function __wbg_target_0a62d9d79a2a1ede(arg0) {
+export function __wbg_target_bfb4281bfa013115(arg0) {
     const ret = arg0.target;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_then_44b73946d2fb3e7d(arg0, arg1) {
-    const ret = arg0.then(arg1);
+export function __wbg_then_8d2fcccde5380a03(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
     return ret;
 };
 
-export function __wbg_then_48b406749878a531(arg0, arg1, arg2) {
-    const ret = arg0.then(arg1, arg2);
+export function __wbg_then_9cc266be2bf537b6(arg0, arg1) {
+    const ret = arg0.then(arg1);
     return ret;
 };
 
-export function __wbg_toString_5285597960676b7b(arg0) {
+export function __wbg_toString_1144ec2f872e8cf3(arg0) {
     const ret = arg0.toString();
     return ret;
 };
 
-export function __wbg_toString_c813bbd34d063839(arg0) {
+export function __wbg_toString_1588a16751ba3f70(arg0) {
     const ret = arg0.toString();
     return ret;
 };
 
-export function __wbg_transaction_d6d07c3c9963c49e() { return handleError(function (arg0, arg1, arg2) {
-    const ret = arg0.transaction(arg1, __wbindgen_enum_IdbTransactionMode[arg2]);
-    return ret;
-}, arguments) };
-
-export function __wbg_transaction_e713aa7b07ccaedd(arg0) {
+export function __wbg_transaction_8267254fd462a1bb(arg0) {
     const ret = arg0.transaction;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_txclient_new(arg0) {
-    const ret = TxClient.__wrap(arg0);
+export function __wbg_transaction_fca796495943f7a5() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.transaction(arg1, __wbindgen_enum_IdbTransactionMode[arg2]);
     return ret;
-};
+}, arguments) };
 
 export function __wbg_txresponse_new(arg0) {
     const ret = TxResponse.__wrap(arg0);
@@ -8897,7 +8973,7 @@ export function __wbg_txstatusresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_typeUrl_2c98c99b2904d84c(arg0, arg1) {
+export function __wbg_typeUrl_3684fcca6ad58882(arg0, arg1) {
     const ret = arg1.typeUrl;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -8905,12 +8981,12 @@ export function __wbg_typeUrl_2c98c99b2904d84c(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_unique_23ddfed89bddb31d(arg0) {
+export function __wbg_unique_2ffe24c606d8bfd2(arg0) {
     const ret = arg0.unique;
     return ret;
 };
 
-export function __wbg_userAgent_12e9d8e62297563f() { return handleError(function (arg0, arg1) {
+export function __wbg_userAgent_1157325f8a8128d1() { return handleError(function (arg0, arg1) {
     const ret = arg1.userAgent;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -8918,7 +8994,7 @@ export function __wbg_userAgent_12e9d8e62297563f() { return handleError(function
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }, arguments) };
 
-export function __wbg_userAgent_d036e8722fea0cde() { return handleError(function (arg0, arg1) {
+export function __wbg_userAgent_9b943f9412e5e199() { return handleError(function (arg0, arg1) {
     const ret = arg1.userAgent;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -8926,12 +9002,12 @@ export function __wbg_userAgent_d036e8722fea0cde() { return handleError(function
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }, arguments) };
 
-export function __wbg_value_68c4e9a54bb7fd5e() { return handleError(function (arg0) {
+export function __wbg_value_09d0b4eaab48b91d(arg0) {
     const ret = arg0.value;
     return ret;
-}, arguments) };
+};
 
-export function __wbg_value_9d0a1475adca6e41(arg0, arg1) {
+export function __wbg_value_1c415f2db45fc801(arg0, arg1) {
     const ret = arg1.value;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -8939,244 +9015,272 @@ export function __wbg_value_9d0a1475adca6e41(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_value_cd1ffa7b1ab794f1(arg0) {
+export function __wbg_value_3e45d77a58bc804d() { return handleError(function (arg0) {
     const ret = arg0.value;
     return ret;
-};
+}, arguments) };
 
-export function __wbg_versions_c71aa1626a93e0a1(arg0) {
+export function __wbg_versions_c01dfd4722a88165(arg0) {
     const ret = arg0.versions;
     return ret;
 };
 
-export function __wbg_view_fd8a56e8983f448d(arg0) {
+export function __wbg_view_d36d28552eb70661(arg0) {
     const ret = arg0.view;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_warn_4ca3906c248c47c4(arg0) {
+export function __wbg_warn_07ef1f61c52799fb(arg0) {
     console.warn(arg0);
 };
 
-export function __wbg_writable_a00d38c47378fae8(arg0) {
-    const ret = arg0.writable;
-    return ret;
+export function __wbg_wbindgenbigintgetasi64_7637cb1a7fb9a81e(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 };
 
-export function __wbg_write_311434e30ee214e5(arg0, arg1) {
-    const ret = arg0.write(arg1);
-    return ret;
+export function __wbg_wbindgenbooleanget_59f830b1a70d2530(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 };
 
-export function __wbindgen_array_new() {
-    const ret = [];
+export function __wbg_wbindgencbdrop_a85ed476c6a370b9(arg0) {
+    const obj = arg0.original;
+    if (obj.cnt-- == 1) {
+        obj.a = 0;
+        return true;
+    }
+    const ret = false;
     return ret;
 };
 
-export function __wbindgen_array_push(arg0, arg1) {
-    arg0.push(arg1);
+export function __wbg_wbindgendebugstring_bb652b1bc2061b6d(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbindgen_as_number(arg0) {
-    const ret = +arg0;
+export function __wbg_wbindgenin_192b210aa1c401e9(arg0, arg1) {
+    const ret = arg0 in arg1;
     return ret;
 };
 
-export function __wbindgen_bigint_from_i64(arg0) {
-    const ret = arg0;
+export function __wbg_wbindgenisbigint_7d76a1ca6454e439(arg0) {
+    const ret = typeof(arg0) === 'bigint';
     return ret;
 };
 
-export function __wbindgen_bigint_from_u64(arg0) {
-    const ret = BigInt.asUintN(64, arg0);
+export function __wbg_wbindgenisfalsy_a15841cca6156044(arg0) {
+    const ret = !arg0;
     return ret;
 };
 
-export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
-    const v = arg1;
-    const ret = typeof(v) === 'bigint' ? v : undefined;
-    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+export function __wbg_wbindgenisfunction_ea72b9d66a0e1705(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
 };
 
-export function __wbindgen_boolean_get(arg0) {
-    const v = arg0;
-    const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+export function __wbg_wbindgenisnull_e1388bbe88158c3f(arg0) {
+    const ret = arg0 === null;
     return ret;
 };
 
-export function __wbindgen_cb_drop(arg0) {
-    const obj = arg0.original;
-    if (obj.cnt-- == 1) {
-        obj.a = 0;
-        return true;
-    }
-    const ret = false;
+export function __wbg_wbindgenisobject_dfe064a121d87553(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
     return ret;
 };
 
-export function __wbindgen_closure_wrapper1276(arg0, arg1, arg2) {
-    const ret = makeClosure(arg0, arg1, 311, __wbg_adapter_64);
+export function __wbg_wbindgenisstring_4b74e4111ba029e6(arg0) {
+    const ret = typeof(arg0) === 'string';
     return ret;
 };
 
-export function __wbindgen_closure_wrapper1277(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 311, __wbg_adapter_67);
+export function __wbg_wbindgenisundefined_71f08a6ade4354e7(arg0) {
+    const ret = arg0 === undefined;
     return ret;
 };
 
-export function __wbindgen_closure_wrapper4831(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1612, __wbg_adapter_70);
+export function __wbg_wbindgenjsvaleq_f27272c0a890df7f(arg0, arg1) {
+    const ret = arg0 === arg1;
     return ret;
 };
 
-export function __wbindgen_closure_wrapper4832(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1612, __wbg_adapter_70);
+export function __wbg_wbindgenjsvallooseeq_9dd7bb4b95ac195c(arg0, arg1) {
+    const ret = arg0 == arg1;
     return ret;
 };
 
-export function __wbindgen_closure_wrapper4833(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1612, __wbg_adapter_70);
-    return ret;
+export function __wbg_wbindgennumberget_d855f947247a3fbc(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 };
 
-export function __wbindgen_closure_wrapper6385(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2165, __wbg_adapter_77);
-    return ret;
+export function __wbg_wbindgenstringget_43fe05afe34b0cb1(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbindgen_closure_wrapper8490(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2685, __wbg_adapter_80);
-    return ret;
+export function __wbg_wbindgenthrow_4c11a24fca429ccf(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
-export function __wbindgen_closure_wrapper8537(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2704, __wbg_adapter_83);
+export function __wbg_wbindgentypeof_7219206940ac0898(arg0) {
+    const ret = typeof arg0;
     return ret;
 };
 
-export function __wbindgen_closure_wrapper8846(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2810, __wbg_adapter_86);
+export function __wbg_writable_4f9d2cae62a7c0cb(arg0) {
+    const ret = arg0.writable;
     return ret;
 };
 
-export function __wbindgen_debug_string(arg0, arg1) {
-    const ret = debugString(arg1);
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+export function __wbg_write_39d7c51f917777a5(arg0, arg1) {
+    const ret = arg0.write(arg1);
+    return ret;
 };
 
-export function __wbindgen_error_new(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
+export function __wbindgen_cast_0d71f2ff3d5df848(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2886, function: Function { arguments: [], shim_idx: 2887, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2886, __wbg_adapter_13);
     return ret;
 };
 
-export function __wbindgen_in(arg0, arg1) {
-    const ret = arg0 in arg1;
+export function __wbindgen_cast_13f728beb3308701(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("Coin")) -> Externref`.
+    const ret = v0;
     return ret;
 };
 
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_export_4;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
+export function __wbindgen_cast_1549fdb98e982686(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 669, function: Function { arguments: [Externref], shim_idx: 675, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_38);
+    return ret;
 };
 
-export function __wbindgen_is_array(arg0) {
-    const ret = Array.isArray(arg0);
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 };
 
-export function __wbindgen_is_bigint(arg0) {
-    const ret = typeof(arg0) === 'bigint';
+export function __wbindgen_cast_2d3f4f6921336305(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1784, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1785, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1784, __wbg_adapter_8);
     return ret;
 };
 
-export function __wbindgen_is_falsy(arg0) {
-    const ret = !arg0;
+export function __wbindgen_cast_439df55617f52063(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 669, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 673, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+    const ret = makeClosure(arg0, arg1, 669, __wbg_adapter_47);
     return ret;
 };
 
-export function __wbindgen_is_function(arg0) {
-    const ret = typeof(arg0) === 'function';
+export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
     return ret;
 };
 
-export function __wbindgen_is_null(arg0) {
-    const ret = arg0 === null;
+export function __wbindgen_cast_5ce2b55b30716d02(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2976, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2977, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2976, __wbg_adapter_16);
     return ret;
 };
 
-export function __wbindgen_is_object(arg0) {
-    const val = arg0;
-    const ret = typeof(val) === 'object' && val !== null;
+export function __wbindgen_cast_6fcc2e550fb2fc08(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2874, function: Function { arguments: [Externref], shim_idx: 2875, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2874, __wbg_adapter_33);
     return ret;
 };
 
-export function __wbindgen_is_string(arg0) {
-    const ret = typeof(arg0) === 'string';
+export function __wbindgen_cast_76a0f6231a633ad2(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("BaseAccount")) -> Externref`.
+    const ret = v0;
     return ret;
 };
 
-export function __wbindgen_is_undefined(arg0) {
-    const ret = arg0 === undefined;
+export function __wbindgen_cast_84b488785ba1336b(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1784, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1785, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1784, __wbg_adapter_8);
     return ret;
 };
 
-export function __wbindgen_jsval_eq(arg0, arg1) {
-    const ret = arg0 === arg1;
+export function __wbindgen_cast_999e199e4c24168d(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("Blob")) -> Externref`.
+    const ret = v0;
     return ret;
 };
 
-export function __wbindgen_jsval_loose_eq(arg0, arg1) {
-    const ret = arg0 == arg1;
+export function __wbindgen_cast_9ae0607507abb057(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-export function __wbindgen_memory() {
-    const ret = wasm.memory;
+export function __wbindgen_cast_b48b6bd0973f59e2(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1784, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1785, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1784, __wbg_adapter_8);
     return ret;
 };
 
-export function __wbindgen_number_get(arg0, arg1) {
-    const obj = arg1;
-    const ret = typeof(obj) === 'number' ? obj : undefined;
-    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+export function __wbindgen_cast_b56f0f95b6de8085(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2337, function: Function { arguments: [], shim_idx: 2338, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2337, __wbg_adapter_19);
+    return ret;
 };
 
-export function __wbindgen_number_new(arg0) {
-    const ret = arg0;
+export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 };
 
-export function __wbindgen_string_get(arg0, arg1) {
-    const obj = arg1;
-    const ret = typeof(obj) === 'string' ? obj : undefined;
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+export function __wbindgen_cast_cdc847d25519f930(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 669, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 670, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 669, __wbg_adapter_28);
+    return ret;
 };
 
-export function __wbindgen_string_new(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
     return ret;
 };
 
-export function __wbindgen_throw(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
+export function __wbindgen_cast_da0d185114cf54d4(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("ExtendedHeader")) -> Externref`.
+    const ret = v0;
+    return ret;
 };
 
-export function __wbindgen_typeof(arg0) {
-    const ret = typeof arg0;
-    return ret;
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_4;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
 };