lumina-node-wasm 0.11.0 → 0.12.0

package/lumina_node_wasm_bg.js

@@ -199,22 +199,11 @@ function debugString(val) {
     return className;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(
 state => {
-    wasm.__wbindgen_export_7.get(state.dtor)(state.a, state.b);
+    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
 }
 );
 
@@ -232,7 +221,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
             return f(a, state.b, ...args);
         } finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_7.get(state.dtor)(a, state.b);
+                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
                 CLOSURE_DTORS.unregister(state);
             } else {
                 state.a = a;
@@ -244,6 +233,17 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function makeClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
     const real = (...args) => {
@@ -256,7 +256,7 @@ function makeClosure(arg0, arg1, dtor, f) {
             return f(state.a, state.b, ...args);
         } finally {
             if (--state.cnt === 0) {
-                wasm.__wbindgen_export_7.get(state.dtor)(state.a, state.b); state.a = 0;
+                wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b); state.a = 0;
                 CLOSURE_DTORS.unregister(state);
             }
         }
@@ -305,41 +305,41 @@ export function protoEncodeSignDoc(sign_doc) {
     return v1;
 }
 
-function __wbg_adapter_8(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hfede219244329fd3(arg0, arg1);
+function __wbg_adapter_8(arg0, arg1, arg2) {
+    wasm.closure1785_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_11(arg0, arg1, arg2) {
-    wasm.closure1749_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_13(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h2abc87618de50089(arg0, arg1);
 }
 
-function __wbg_adapter_20(arg0, arg1, arg2) {
-    wasm.closure731_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_16(arg0, arg1, arg2) {
+    wasm.closure2977_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_23(arg0, arg1, arg2) {
-    wasm.closure2841_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_19(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hc000bd3f01dbb89a(arg0, arg1);
 }
 
-function __wbg_adapter_26(arg0, arg1, arg2) {
-    wasm.closure727_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_28(arg0, arg1, arg2) {
+    wasm.closure670_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_31(arg0, arg1, arg2) {
-    wasm.closure2961_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_33(arg0, arg1, arg2) {
+    wasm.closure2875_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_44(arg0, arg1, arg2) {
-    const ret = wasm.closure729_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_38(arg0, arg1, arg2) {
+    const ret = wasm.closure675_externref_shim(arg0, arg1, arg2);
     return ret;
 }
 
-function __wbg_adapter_47(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h7953c2fdc3875afe(arg0, arg1);
+function __wbg_adapter_47(arg0, arg1, arg2) {
+    wasm.closure673_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_960(arg0, arg1, arg2, arg3) {
-    wasm.closure2981_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_982(arg0, arg1, arg2, arg3) {
+    wasm.closure3002_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -714,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({
     /**
@@ -729,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
@@ -887,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}
@@ -1058,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')
@@ -1899,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);
     }
     /**
@@ -2468,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) {
@@ -2792,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.
      *
@@ -2850,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')
@@ -3058,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,
         };
     }
 
@@ -3081,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]);
@@ -3141,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]);
@@ -3157,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.
@@ -3179,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
@@ -3216,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);
     }
 }
 
@@ -3575,22 +3581,27 @@ export class GrpcClient {
         wasm.__wbg_grpcclient_free(ptr, 0);
     }
     /**
-     * Create a builder for [`GrpcClient`] connected to `url`
-     * @param {string} url
-     * @returns {GrpcClientBuilder}
+     * Issue a direct ABCI query to the application
+     * @param {Uint8Array} data
+     * @param {string} path
+     * @param {bigint} height
+     * @param {boolean} prove
+     * @returns {Promise<AbciQueryResponse>}
      */
-    static withUrl(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_withUrl(ptr0, len0);
-        return GrpcClientBuilder.__wrap(ret);
+        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>}
      */
-    getAuthParams() {
-        const ret = wasm.grpcclient_getAuthParams(this.__wbg_ptr);
+    get appVersion() {
+        const ret = wasm.grpcclient_appVersion(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3604,34 +3615,6 @@ export class GrpcClient {
         const ret = wasm.grpcclient_getAccount(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
-    /**
-     * Get accounts
-     * @returns {Promise<BaseAccount[]>}
-     */
-    getAccounts() {
-        const ret = wasm.grpcclient_getAccounts(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * 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>}
-     */
-    getVerifiedBalance(address, header) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(header, ExtendedHeader);
-        const ret = wasm.grpcclient_getVerifiedBalance(this.__wbg_ptr, ptr0, len0, header.__wbg_ptr);
-        return ret;
-    }
     /**
      * Retrieves the Celestia coin balance for the given address.
      * @param {string} address
@@ -3647,33 +3630,101 @@ export class GrpcClient {
         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>}
      */
-    getAllBalances(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_getAllBalances(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[]>}
      */
-    getSpendableBalances(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_getSpendableBalances(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>}
      */
-    getTotalSupply() {
-        const ret = wasm.grpcclient_getTotalSupply(this.__wbg_ptr);
+    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>}
+     */
+    getBlobParams() {
+        const ret = wasm.grpcclient_getBlobParams(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3684,6 +3735,17 @@ 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>}
@@ -3693,41 +3755,64 @@ export class GrpcClient {
         return ret;
     }
     /**
-     * Get block by height
-     * @param {bigint} height
-     * @returns {Promise<Block>}
+     * Get total supply
+     * @returns {Promise<Coin[]>}
      */
-    getBlockByHeight(height) {
-        const ret = wasm.grpcclient_getBlockByHeight(this.__wbg_ptr, height);
+    getTotalSupply() {
+        const ret = wasm.grpcclient_getTotalSupply(this.__wbg_ptr);
         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>}
+     * 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>}
      */
-    abciQuery(data, path, height, prove) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    estimateGasPrice(priority) {
+        const ret = wasm.grpcclient_estimateGasPrice(this.__wbg_ptr, priority);
+        return ret;
+    }
+    /**
+     * Get block by height
+     * @param {bigint} height
+     * @returns {Promise<Block>}
+     */
+    getBlockByHeight(height) {
+        const ret = wasm.grpcclient_getBlockByHeight(this.__wbg_ptr, height);
+        return ret;
+    }
+    /**
+     * 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>}
+     */
+    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_abciQuery(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[]>}
      */
-    broadcastTx(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_broadcastTx(this.__wbg_ptr, ptr0, len0, mode.__wbg_ptr);
+        const ret = wasm.grpcclient_getSpendableBalances(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -3741,6 +3826,14 @@ export class GrpcClient {
         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;
+    }
     /**
      * Simulate prepared and serialised transaction, returning simulated gas usage
      * @param {Uint8Array} tx_bytes
@@ -3753,12 +3846,15 @@ export class GrpcClient {
         return ret;
     }
     /**
-     * Get blob params
-     * @returns {Promise<BlobParams>}
+     * Create a builder for [`GrpcClient`] connected to `url`
+     * @param {string} url
+     * @returns {GrpcClientBuilder}
      */
-    getBlobParams() {
-        const ret = wasm.grpcclient_getBlobParams(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
@@ -3771,96 +3867,6 @@ export class GrpcClient {
         const ret = wasm.grpcclient_txStatus(this.__wbg_ptr, ptr0, len0);
         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;
-    }
-    /**
-     * Chain id of the client
-     * @returns {Promise<string>}
-     */
-    get chainId() {
-        const ret = wasm.grpcclient_chainId(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * AppVersion of the client
-     * @returns {Promise<AppVersion>}
-     */
-    get appVersion() {
-        const ret = wasm.grpcclient_appVersion(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_submitBlobs(this.__wbg_ptr, ptr0, len0, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
-        return ret;
-    }
-    /**
-     * 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;
-    }
 }
 
 const GrpcClientBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3937,38 +3943,6 @@ export class GrpcClientBuilder {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_grpcclientbuilder_free(ptr, 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);
-    }
-    /**
-     * 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]);
-    }
     /**
      * Appends ascii metadata to all requests made by the client.
      *
@@ -4005,6 +3979,23 @@ export class GrpcClientBuilder {
         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}
@@ -4017,6 +4008,21 @@ export class GrpcClientBuilder {
         }
         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')
@@ -4382,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}
      */
@@ -4396,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
      */
@@ -4403,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();
@@ -4434,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;
     }
     /**
@@ -4450,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;
     }
 }
@@ -4823,7 +4829,7 @@ export class JsValidatorInfo {
      * @returns {bigint}
      */
     get power() {
-        const ret = wasm.__wbg_get_data_square_size(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_jsvalidatorinfo_power(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -4831,7 +4837,7 @@ export class JsValidatorInfo {
      * @param {bigint} arg0
      */
     set power(arg0) {
-        wasm.__wbg_set_data_square_size(this.__wbg_ptr, arg0);
+        wasm.__wbg_set_jsvalidatorinfo_power(this.__wbg_ptr, arg0);
     }
     /**
      * Validator name
@@ -5019,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}
@@ -5046,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')
@@ -5100,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,
         };
     }
@@ -5135,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}
@@ -5143,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}
@@ -5152,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);
     }
     /**
@@ -5183,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.
@@ -5223,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')
@@ -5375,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>}
@@ -5402,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;
     }
     /**
@@ -5427,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;
     }
     /**
@@ -5495,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;
     }
     /**
@@ -5557,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;
     }
     /**
-     * Returns a [`BroadcastChannel`] for events generated by [`Node`].
-     * @returns {Promise<BroadcastChannel>}
+     * Start the node with the provided config, if it's not running
+     * @param {NodeConfig} config
+     * @returns {Promise<void>}
      */
-    eventsChannel() {
-        const ret = wasm.nodeclient_eventsChannel(this.__wbg_ptr);
+    start(config) {
+        _assertClass(config, NodeConfig);
+        const ret = wasm.nodeclient_start(this.__wbg_ptr, config.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get all the multiaddresses on which the node listens.
+     * @returns {Promise<Array<any>>}
+     */
+    listeners() {
+        const ret = wasm.nodeclient_listeners(this.__wbg_ptr);
         return ret;
     }
 }
@@ -5662,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}
@@ -5772,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')
@@ -5806,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) {
@@ -5815,6 +5823,7 @@ export class NodeWorker {
         return this;
     }
     /**
+     * Run `NodeWorker` main loop.
      * @returns {Promise<void>}
      */
     run() {
@@ -6347,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
@@ -6385,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')
@@ -6676,23 +6685,6 @@ export class TxBody {
         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
@@ -6726,6 +6718,23 @@ export class TxBody {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * `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;
+    }
 }
 
 const TxResponseFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6755,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}
@@ -6950,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')
@@ -7000,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}
@@ -7074,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')
@@ -7455,7 +7464,7 @@ export function __wbg_abort_496881624c2d80da() { return handleError(function (ar
     arg0.abort();
 }, arguments) };
 
-export function __wbg_accountNumber_39d1c298f9e5c082(arg0) {
+export function __wbg_accountNumber_8a52b3ddaecb3ddf(arg0) {
     const ret = arg0.accountNumber;
     return ret;
 };
@@ -7498,7 +7507,7 @@ export function __wbg_attribute_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_authInfoBytes_b318cc80cf9d2ff8(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;
@@ -7536,7 +7545,7 @@ export function __wbg_blockrange_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_bodyBytes_cd75eac0b845f014(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;
@@ -7549,11 +7558,6 @@ export function __wbg_body_be60ee806470b990(arg0) {
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbg_bound_5807fb7ebc427c03() { return handleError(function (arg0, arg1, arg2, arg3) {
-    const ret = IDBKeyRange.bound(arg0, arg1, arg2 !== 0, arg3 !== 0);
-    return ret;
-}, arguments) };
-
 export function __wbg_buffer_1f897e9f3ed6b41d(arg0) {
     const ret = arg0.buffer;
     return ret;
@@ -7604,7 +7608,7 @@ export function __wbg_cause_94f62e1c92956ce2(arg0) {
     return ret;
 };
 
-export function __wbg_chainId_2d57400a28824c3f(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;
@@ -7635,7 +7639,7 @@ export function __wbg_clearTimeout_96804de0ab838f26(arg0) {
     return ret;
 };
 
-export function __wbg_clearTimeout_e1b14c330a6c41a6(arg0) {
+export function __wbg_clearTimeout_d270f24e5d43eaf7(arg0) {
     clearTimeout(arg0);
 };
 
@@ -7839,13 +7843,13 @@ export function __wbg_extendedheader_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_fetch_4fae101547df73b6(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_b21de99222e9f4e1(arg0) {
-    const ret = fetch(arg0);
+export function __wbg_fetch_4fae101547df73b6(arg0, arg1, arg2) {
+    const ret = arg0.fetch(arg1, arg2);
     return ret;
 };
 
@@ -7859,13 +7863,13 @@ export function __wbg_from_237b1ad767238d8b(arg0) {
     return ret;
 };
 
-export function __wbg_gasLimit_c7b776728a12cf83(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_9c07555b88b11910(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);
@@ -8289,7 +8293,7 @@ export function __wbg_length_904c0910ed998bf3(arg0) {
     return ret;
 };
 
-export function __wbg_memo_48d219ed93452445(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;
@@ -8379,7 +8383,7 @@ export function __wbg_new_d5e3800b120e37e1(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_960(a, state0.b, arg0, arg1);
+                return __wbg_adapter_982(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -8545,15 +8549,15 @@ export function __wbg_postMessage_3b4fb1cda6756bf0() { return handleError(functi
     arg0.postMessage(arg1);
 }, arguments) };
 
-export function __wbg_postMessage_6c2e3d58e6b58b4a() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_postMessage_b9234f931da7f86a() { return handleError(function (arg0, arg1, arg2) {
     arg0.postMessage(arg1, arg2);
 }, arguments) };
 
-export function __wbg_postMessage_748559745b3b6020() { return handleError(function (arg0, arg1) {
+export function __wbg_postMessage_ecb1e9ee54a5b2f1() { return handleError(function (arg0, arg1) {
     arg0.postMessage(arg1);
 }, arguments) };
 
-export function __wbg_priority_e414ab055c0d0a08(arg0) {
+export function __wbg_priority_1990e2825970b82f(arg0) {
     const ret = arg0.priority;
     return isLikeNone(ret) ? 0 : ret;
 };
@@ -8639,7 +8643,7 @@ export function __wbg_releaseLock_fbec365467db2e6c(arg0) {
     arg0.releaseLock();
 };
 
-export function __wbg_request_537c0a65e46ce7cb(arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_request_3be0f0335cc6a465(arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.request(getStringFromWasm0(arg1, arg2), arg3, arg4);
     return ret;
 };
@@ -8692,7 +8696,7 @@ export function __wbg_setInterval_ed3b5e3c3ebb8a6d() { return handleError(functi
     return ret;
 }, arguments) };
 
-export function __wbg_setTimeout_6d5804197b438320(arg0, arg1) {
+export function __wbg_setTimeout_c19d61d90c66d11f(arg0, arg1) {
     const ret = setTimeout(arg0, arg1 >>> 0);
     return ret;
 };
@@ -8969,7 +8973,7 @@ export function __wbg_txstatusresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_typeUrl_f02514616b090ac1(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;
@@ -9003,7 +9007,7 @@ export function __wbg_value_09d0b4eaab48b91d(arg0) {
     return ret;
 };
 
-export function __wbg_value_3c6f117eabb16ab3(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;
@@ -9147,6 +9151,12 @@ export function __wbg_write_39d7c51f917777a5(arg0, arg1) {
     return ret;
 };
 
+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_cast_13f728beb3308701(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
@@ -9155,9 +9165,9 @@ export function __wbindgen_cast_13f728beb3308701(arg0, arg1) {
     return ret;
 };
 
-export function __wbindgen_cast_17625ed3b4da24cb(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1748, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1749, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1748, __wbg_adapter_11);
+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;
 };
 
@@ -9167,39 +9177,33 @@ export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     return ret;
 };
 
-export function __wbindgen_cast_3d27ec27b68ba2cd(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1748, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1749, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1748, __wbg_adapter_11);
-    return ret;
-};
-
-export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
-    // Cast intrinsic for `U64 -> Externref`.
-    const ret = BigInt.asUintN(64, arg0);
+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_cast_4b1e345b770365a0(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 726, function: Function { arguments: [Externref], shim_idx: 729, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 726, __wbg_adapter_44);
+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_cast_6cadf2dadb047667(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 2840, function: Function { arguments: [Externref], shim_idx: 2841, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 2840, __wbg_adapter_23);
+export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
     return ret;
 };
 
-export function __wbindgen_cast_7052a031800ef013(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 726, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 727, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
-    const ret = makeClosure(arg0, arg1, 726, __wbg_adapter_26);
+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_cast_70bf32696ce323a8(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 2852, function: Function { arguments: [], shim_idx: 2853, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 2852, __wbg_adapter_47);
+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;
 };
 
@@ -9211,9 +9215,9 @@ export function __wbindgen_cast_76a0f6231a633ad2(arg0, arg1) {
     return ret;
 };
 
-export function __wbindgen_cast_780e81115060bad4(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1748, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1749, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1748, __wbg_adapter_11);
+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;
 };
 
@@ -9231,15 +9235,27 @@ export function __wbindgen_cast_9ae0607507abb057(arg0) {
     return ret;
 };
 
+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_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_cast_cb9088102bce6b30(arg0, arg1) {
     // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
     const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 };
 
-export function __wbindgen_cast_d144656a3d1ab4ad(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 2960, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2961, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 2960, __wbg_adapter_31);
+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;
 };
 
@@ -9249,12 +9265,6 @@ export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
     return ret;
 };
 
-export function __wbindgen_cast_d81407fed0b5a02d(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 2294, function: Function { arguments: [], shim_idx: 2295, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 2294, __wbg_adapter_8);
-    return ret;
-};
-
 export function __wbindgen_cast_da0d185114cf54d4(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
@@ -9263,12 +9273,6 @@ export function __wbindgen_cast_da0d185114cf54d4(arg0, arg1) {
     return ret;
 };
 
-export function __wbindgen_cast_f2aa4ac7119e14c0(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 726, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 731, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 726, __wbg_adapter_20);
-    return ret;
-};
-
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_export_4;
     const offset = table.grow(4);