lumina-node-wasm 0.11.0 → 0.13.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);
             }
         }
@@ -265,12 +265,6 @@ function makeClosure(arg0, arg1, dtor, f) {
     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)) {
@@ -287,6 +281,12 @@ function passArrayJsValueToWasm0(array, malloc) {
     WASM_VECTOR_LEN = array.length;
     return ptr;
 }
+/**
+ * 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);
@@ -305,41 +305,46 @@ 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_6(arg0, arg1, arg2) {
+    wasm.closure313_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_11(arg0, arg1, arg2) {
-    wasm.closure1749_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_9(arg0, arg1, arg2) {
+    wasm.closure1892_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_20(arg0, arg1, arg2) {
-    wasm.closure731_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_14(arg0, arg1, arg2) {
+    wasm.closure2958_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_23(arg0, arg1, arg2) {
-    wasm.closure2841_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_23(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hbc27f06da80e4608(arg0, arg1);
 }
 
-function __wbg_adapter_26(arg0, arg1, arg2) {
-    wasm.closure727_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_28(arg0, arg1, arg2) {
+    wasm.closure311_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_31(arg0, arg1, arg2) {
-    wasm.closure2961_externref_shim(arg0, arg1, arg2);
+    const ret = wasm.closure308_externref_shim(arg0, arg1, arg2);
+    return ret;
 }
 
-function __wbg_adapter_44(arg0, arg1, arg2) {
-    const ret = wasm.closure729_externref_shim(arg0, arg1, arg2);
-    return ret;
+function __wbg_adapter_34(arg0, arg1, arg2) {
+    wasm.closure3066_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_47(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h7953c2fdc3875afe(arg0, arg1);
+    const ret = wasm.closure315_externref_shim(arg0, arg1);
+    return ret;
+}
+
+function __wbg_adapter_52(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h4a5ee0ea235e8a7d(arg0, arg1);
 }
 
-function __wbg_adapter_960(arg0, arg1, arg2, arg3) {
-    wasm.closure2981_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_940(arg0, arg1, arg2, arg3) {
+    wasm.closure3085_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -714,7 +719,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 +734,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 +896,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 +1078,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')
@@ -1194,6 +1203,47 @@ export class AppVersion {
     }
 }
 
+const AsyncIteratorImplFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_asynciteratorimpl_free(ptr >>> 0, 1));
+
+export class AsyncIteratorImpl {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AsyncIteratorImpl.prototype);
+        obj.__wbg_ptr = ptr;
+        AsyncIteratorImplFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AsyncIteratorImplFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_asynciteratorimpl_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    return_self() {
+        const ret = wasm.asynciteratorimpl_return_self(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    next() {
+        const ret = wasm.asynciteratorimpl_next(this.__wbg_ptr);
+        return ret;
+    }
+}
+
 const AttributeFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_attribute_free(ptr >>> 0, 1));
@@ -1613,6 +1663,80 @@ export class BlobParams {
     }
 }
 
+const BlobsAtHeightFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_blobsatheight_free(ptr >>> 0, 1));
+/**
+ * List of blobs together with height they were published at
+ */
+export class BlobsAtHeight {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(BlobsAtHeight.prototype);
+        obj.__wbg_ptr = ptr;
+        BlobsAtHeightFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    toJSON() {
+        return {
+            height: this.height,
+            blobs: this.blobs,
+        };
+    }
+
+    toString() {
+        return JSON.stringify(this);
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BlobsAtHeightFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_blobsatheight_free(ptr, 0);
+    }
+    /**
+     * Height the blobs were published at
+     * @returns {bigint}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_blobparams_gov_max_square_size(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Height the blobs were published at
+     * @param {bigint} arg0
+     */
+    set height(arg0) {
+        wasm.__wbg_set_blobparams_gov_max_square_size(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Published blobs
+     * @returns {Blob[]}
+     */
+    get blobs() {
+        const ret = wasm.__wbg_get_blobsatheight_blobs(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Published blobs
+     * @param {Blob[]} arg0
+     */
+    set blobs(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_blobsatheight_blobs(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
 const BlockFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_block_free(ptr >>> 0, 1));
@@ -1899,21 +2023,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 +2592,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) {
@@ -2743,7 +2869,7 @@ const DataAvailabilityHeaderFinalization = (typeof FinalizationRegistry === 'und
  * # fn extended_header() -> ExtendedHeader {
  * #     unimplemented!();
  * # }
- * # fn shares_with_proof(_: Height, _: &Namespace) -> (Vec<Share>, NamespaceProof) {
+ * # fn shares_with_proof(_: u64, _: &Namespace) -> (Vec<Share>, NamespaceProof) {
  * #     unimplemented!();
  * # }
  * // fetch the block header and data for your namespace
@@ -2792,51 +2918,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 +2984,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 +3184,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 +3207,64 @@ export class ExtendedHeader {
         wasm.__wbg_extendedheader_free(ptr, 0);
     }
     /**
-     * Header of the block data availability.
-     * @returns {DataAvailabilityHeader}
+     * Decode protobuf encoded header and then validate it.
      */
-    get dah() {
-        const ret = wasm.__wbg_get_extendedheader_dah(this.__wbg_ptr);
-        return DataAvailabilityHeader.__wrap(ret);
+    validate() {
+        const ret = wasm.extendedheader_validate(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Header of the block data availability.
-     * @param {DataAvailabilityHeader} arg0
+     * 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
      */
-    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}
-     */
-    clone() {
-        const ret = wasm.extendedheader_clone(this.__wbg_ptr);
-        return ExtendedHeader.__wrap(ret);
-    }
-    /**
-     * Get the block height.
-     * @returns {bigint}
-     */
-    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 +3273,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 +3319,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 +3349,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 +3385,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 +3701,49 @@ 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>}
+     * Confirm transaction broadcasted with [`broadcast_blobs`] or [`broadcast_message`].
+     *
+     * # 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 broadcastedTx = await txClient.broadcastBlobs([blob]);
+     * console.log("Tx hash:", broadcastedTx.hash);
+     * const txInfo = await txClient.confirmTx(broadcastedTx);
+     * console.log("Confirmed at height:", txInfo.height);
+     * ```
+     * @param {BroadcastedTx} broadcasted_tx
+     * @param {TxConfig | null} [tx_config]
+     * @returns {Promise<TxInfo>}
      */
-    getAuthParams() {
-        const ret = wasm.grpcclient_getAuthParams(this.__wbg_ptr);
+    confirmTx(broadcasted_tx, tx_config) {
+        const ret = wasm.grpcclient_confirmTx(this.__wbg_ptr, broadcasted_tx, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
+        return ret;
+    }
+    /**
+     * AppVersion of the client
+     * @returns {Promise<AppVersion>}
+     */
+    get appVersion() {
+        const ret = wasm.grpcclient_appVersion(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -3604,34 +3757,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 +3772,135 @@ 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);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_getAllBalances(this.__wbg_ptr, ptr0, len0);
+    broadcastTx(tx_bytes, mode) {
+        const ptr0 = passArray8ToWasm0(tx_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        _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;
+    }
+    /**
+     * Broadcast blobs to the celestia network, and return without confirming.
+     *
+     * # 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 broadcastedTx = await txClient.broadcastBlobs([blob]);
+     * console.log("Tx hash:", broadcastedTx.hash);
+     * const txInfo = await txClient.confirmTx(broadcastedTx);
+     * ```
+     *
+     * # 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.broadcastBlobs(blobs.map(b => b.clone()));
+     * ```
+     * @param {Blob[]} blobs
+     * @param {TxConfig | null} [tx_config]
+     * @returns {Promise<BroadcastedTx>}
+     */
+    broadcastBlobs(blobs, tx_config) {
+        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_broadcastBlobs(this.__wbg_ptr, ptr0, len0, 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 +3911,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>}
@@ -3692,6 +3930,57 @@ export class GrpcClient {
         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;
+    }
+    /**
+     * Broadcast message to the celestia network, and return without confirming.
+     *
+     * # 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 broadcastedTx = await txClient.broadcastMessage(sendMsgAny);
+     * console.log("Tx hash:", broadcastedTx.hash);
+     * const txInfo = await txClient.confirmTx(broadcastedTx);
+     * ```
+     * @param {ProtoAny} message
+     * @param {TxConfig | null} [tx_config]
+     * @returns {Promise<BroadcastedTx>}
+     */
+    broadcastMessage(message, tx_config) {
+        const ret = wasm.grpcclient_broadcastMessage(this.__wbg_ptr, message, isLikeNone(tx_config) ? 0 : addToExternrefTable0(tx_config));
+        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;
+    }
     /**
      * Get block by height
      * @param {bigint} height
@@ -3702,32 +3991,34 @@ export class GrpcClient {
         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>}
      */
-    abciQuery(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_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 +4032,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 +4052,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
@@ -3772,94 +4074,18 @@ export class GrpcClient {
         return ret;
     }
     /**
-     * Estimate gas price for given transaction priority based
-     * on the gas prices of the transactions in the last five blocks.
+     * Create a builder for [`GrpcClient`] with multiple URL endpoints for fallback support.
      *
-     * 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>}
+     * When multiple endpoints are configured, the client will automatically
+     * fall back to the next endpoint if a network-related error occurs.
+     * @param {string[]} urls
+     * @returns {GrpcClientBuilder}
      */
-    submitBlobs(blobs, tx_config) {
-        const ptr0 = passArrayJsValueToWasm0(blobs, wasm.__wbindgen_malloc);
+    static withUrls(urls) {
+        const ptr0 = passArrayJsValueToWasm0(urls, 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 ret = wasm.grpcclient_withUrls(ptr0, len0);
+        return GrpcClientBuilder.__wrap(ret);
     }
 }
 
@@ -3876,6 +4102,7 @@ const GrpcClientBuilderFinalization = (typeof FinalizationRegistry === 'undefine
  * ```js
  * const client = await GrpcClient
  *   .withUrl("http://127.0.0.1:18080")
+ *   .withTimeout(5000)  // Optional: 5 second timeout
  *   .build()
  * ```
  *
@@ -3938,18 +4165,52 @@ export class GrpcClientBuilder {
         wasm.__wbg_grpcclientbuilder_free(ptr, 0);
     }
     /**
-     * Set the `url` of the grpc-web server to connect to
+     * Sets the request timeout in milliseconds, overriding default one from the transport.
      *
      * 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
+     * @param {bigint} timeout_ms
      * @returns {GrpcClientBuilder}
      */
-    withUrl(url) {
+    withTimeout(timeout_ms) {
         const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ret = wasm.grpcclientbuilder_withTimeout(ptr, timeout_ms);
+        return GrpcClientBuilder.__wrap(ret);
+    }
+    /**
+     * 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 ret = wasm.grpcclientbuilder_withUrl(ptr, ptr0, len0);
+        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);
     }
     /**
@@ -3970,53 +4231,50 @@ export class GrpcClientBuilder {
         return GrpcClientBuilder.__wrap(ret[0]);
     }
     /**
-     * Appends ascii metadata to all requests made by the client.
+     * 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} key
-     * @param {string} value
+     * @param {string} url
      * @returns {GrpcClientBuilder}
      */
-    withMetadata(key, value) {
+    withUrl(url) {
         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);
+        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);
     }
     /**
-     * Appends binary metadata to all requests made by the client.
+     * Add multiple URL endpoints at once for fallback support.
      *
-     * Keys for binary metadata must have `-bin` suffix.
+     * When multiple endpoints are configured, the client will automatically
+     * fall back to the next endpoint if a network-related error occurs.
      *
      * 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
+     * @param {string[]} urls
      * @returns {GrpcClientBuilder}
      */
-    withMetadataBin(key, value) {
+    withUrls(urls) {
         const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const ptr0 = passArrayJsValueToWasm0(urls, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclientbuilder_withMetadataBin(ptr, ptr0, len0, value);
+        const ret = wasm.grpcclientbuilder_withUrls(ptr, ptr0, len0);
         return GrpcClientBuilder.__wrap(ret);
     }
-    /**
-     * 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]);
-    }
 }
 
 const HeaderFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4382,13 +4640,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 +4647,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 +4662,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 +4692,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 +4709,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;
     }
 }
@@ -4491,6 +4749,69 @@ export class IntoUnderlyingSource {
     }
 }
 
+const IteratorResultObjectFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_iteratorresultobject_free(ptr >>> 0, 1));
+
+export class IteratorResultObject {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IteratorResultObject.prototype);
+        obj.__wbg_ptr = ptr;
+        IteratorResultObjectFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IteratorResultObjectFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_iteratorresultobject_free(ptr, 0);
+    }
+    /**
+     * Has the value true if the iterator is past the end of the
+     * iterated sequence. In this case value optionally specifies
+     * the return value of the iterator.
+     * @returns {boolean}
+     */
+    get done() {
+        const ret = wasm.__wbg_get_iteratorresultobject_done(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Has the value true if the iterator is past the end of the
+     * iterated sequence. In this case value optionally specifies
+     * the return value of the iterator.
+     * @param {boolean} arg0
+     */
+    set done(arg0) {
+        wasm.__wbg_set_iteratorresultobject_done(this.__wbg_ptr, arg0);
+    }
+    /**
+     * Any JavaScript value returned by the iterator.
+     * Can be omitted when done is true.
+     * @returns {any}
+     */
+    get value() {
+        const ret = wasm.__wbg_get_iteratorresultobject_value(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Any JavaScript value returned by the iterator.
+     * Can be omitted when done is true.
+     * @param {any} arg0
+     */
+    set value(arg0) {
+        wasm.__wbg_set_iteratorresultobject_value(this.__wbg_ptr, arg0);
+    }
+}
+
 const JsBitVectorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_jsbitvector_free(ptr >>> 0, 1));
@@ -4823,7 +5144,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 +5152,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 +5340,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 +5382,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 +5421,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,
         };
     }
@@ -5136,50 +5457,69 @@ export class Namespace {
         return ret >>> 0;
     }
     /**
-     * Primary reserved [`Namespace`] for the compact `Share`s with `cosmos SDK` transactions.
-     * @returns {Namespace}
+     * Returns the first byte indicating the version of the [`Namespace`].
+     * @returns {number}
      */
-    static get TRANSACTION() {
-        const ret = wasm.namespace_TRANSACTION();
-        return Namespace.__wrap(ret);
+    get version() {
+        const ret = wasm.namespace_version(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Primary reserved [`Namespace`] for the compact Shares with MsgPayForBlobs transactions.
-     * @returns {Namespace}
+     * Converts the [`Namespace`] to a byte slice.
+     * @returns {Uint8Array}
      */
-    static get PAY_FOR_BLOB() {
-        const ret = wasm.namespace_PAY_FOR_BLOB();
-        return Namespace.__wrap(ret);
+    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;
     }
     /**
-     * Primary reserved [`Namespace`] for the `Share`s used for padding.
+     * Create a new [`Namespace`] from the raw bytes.
      *
-     * `Share`s with this namespace are inserted after other shares from primary reserved namespace
-     * so that user-defined namespaces are correctly aligned in `ExtendedDataSquare`
+     * # 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 get PRIMARY_RESERVED_PADDING() {
-        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
+    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}
+     */
+    static get TRANSACTION() {
+        const ret = wasm.namespace_TRANSACTION();
         return Namespace.__wrap(ret);
     }
     /**
-     * Maximal primary reserved [`Namespace`].
+     * The [`Namespace`] for `parity shares`.
      *
-     * Used to indicate the end of the primary reserved group.
+     * 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 MAX_PRIMARY_RESERVED() {
-        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
+    static get PARITY_SHARE() {
+        const ret = wasm.namespace_PARITY_SHARE();
         return Namespace.__wrap(ret);
     }
     /**
-     * Minimal secondary reserved [`Namespace`].
-     *
-     * Used to indicate the beginning of the secondary reserved group.
+     * Primary reserved [`Namespace`] for the compact Shares with MsgPayForBlobs transactions.
      * @returns {Namespace}
      */
-    static get MIN_SECONDARY_RESERVED() {
-        const ret = wasm.namespace_MIN_SECONDARY_RESERVED();
+    static get PAY_FOR_BLOB() {
+        const ret = wasm.namespace_PAY_FOR_BLOB();
         return Namespace.__wrap(ret);
     }
     /**
@@ -5194,72 +5534,35 @@ export class Namespace {
         return Namespace.__wrap(ret);
     }
     /**
-     * The [`Namespace`] for `parity shares`.
+     * Maximal primary reserved [`Namespace`].
      *
-     * It is the namespace with which all the `parity shares` from
-     * `ExtendedDataSquare` are inserted to the `Nmt` when computing
-     * merkle roots.
+     * Used to indicate the end of the primary reserved group.
      * @returns {Namespace}
      */
-    static get PARITY_SHARE() {
-        const ret = wasm.namespace_PARITY_SHARE();
+    static get MAX_PRIMARY_RESERVED() {
+        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
         return Namespace.__wrap(ret);
     }
     /**
-     * Create a new [`Namespace`] version `0` with given id.
-     *
-     * Check [`Namespace::new_v0`] for more details.
-     *
-     * [`Namespace::new_v0`]: https://docs.rs/celestia-types/latest/celestia_types/nmt/struct.Namespace.html#method.new_v0
-     * @param {Uint8Array} id
-     * @returns {Namespace}
-     */
-    static newV0(id) {
-        const ptr0 = passArray8ToWasm0(id, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.namespace_newV0(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        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}
+     * Minimal secondary reserved [`Namespace`].
+     *
+     * Used to indicate the beginning of the secondary reserved group.
+     * @returns {Namespace}
      */
-    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;
+    static get MIN_SECONDARY_RESERVED() {
+        const ret = wasm.namespace_MIN_SECONDARY_RESERVED();
+        return Namespace.__wrap(ret);
     }
     /**
-     * Returns the first byte indicating the version of the [`Namespace`].
-     * @returns {number}
+     * Primary reserved [`Namespace`] for the `Share`s used for padding.
+     *
+     * `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}
      */
-    get version() {
-        const ret = wasm.namespace_version(this.__wbg_ptr);
-        return ret;
+    static get PRIMARY_RESERVED_PADDING() {
+        const ret = wasm.namespace_MAX_PRIMARY_RESERVED();
+        return Namespace.__wrap(ret);
     }
     /**
      * Returns the trailing 28 bytes indicating the id of the [`Namespace`].
@@ -5271,6 +5574,24 @@ export class Namespace {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Create a new [`Namespace`] version `0` with given id.
+     *
+     * Check [`Namespace::new_v0`] for more details.
+     *
+     * [`Namespace::new_v0`]: https://docs.rs/celestia-types/latest/celestia_types/nmt/struct.Namespace.html#method.new_v0
+     * @param {Uint8Array} id
+     * @returns {Namespace}
+     */
+    static newV0(id) {
+        const ptr0 = passArray8ToWasm0(id, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.namespace_newV0(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Namespace.__wrap(ret[0]);
+    }
 }
 
 const NetworkInfoSnapshotFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -5375,24 +5696,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 +5705,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,11 +5747,37 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Get current [`PeerTracker`] info.
-     * @returns {Promise<PeerTrackerInfoSnapshot>}
+     * Subscribe to the shares from the namespace, as new headers are received by the node
+     *
+     * Return an async iterator which will yield all the blobs from the namespace, as the new headers
+     * are being received by the node, starting from the first header received after the call.
+     * @param {Namespace} namespace
+     * @returns {AsyncIterable<BlobsAtHeight | SubscriptionError>}
      */
-    peerTrackerInfo() {
-        const ret = wasm.nodeclient_peerTrackerInfo(this.__wbg_ptr);
+    blobSubscribe(namespace) {
+        _assertClass(namespace, Namespace);
+        var ptr0 = namespace.__destroy_into_raw();
+        const ret = wasm.nodeclient_blobSubscribe(this.__wbg_ptr, ptr0);
+        return ret;
+    }
+    /**
+     * Returns a [`BroadcastChannel`] for events generated by [`Node`].
+     * @returns {Promise<BroadcastChannel>}
+     */
+    eventsChannel() {
+        const ret = wasm.nodeclient_eventsChannel(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Trust or untrust the peer with a given ID.
+     * @param {string} peer_id
+     * @param {boolean} is_trusted
+     * @returns {Promise<void>}
+     */
+    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;
     }
     /**
@@ -5443,47 +5789,68 @@ export class NodeClient {
         return ret;
     }
     /**
-     * Wait until the node is connected to at least 1 trusted peer.
-     * @returns {Promise<void>}
+     * Get all the peers that node is connected to.
+     * @returns {Promise<Array<any>>}
      */
-    waitConnectedTrusted() {
-        const ret = wasm.nodeclient_waitConnectedTrusted(this.__wbg_ptr);
+    connectedPeers() {
+        const ret = wasm.nodeclient_connectedPeers(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Get current network info.
-     * @returns {Promise<NetworkInfoSnapshot>}
+     * Subscribe to new headers received by the node from the network.
+     *
+     * Return an async iterator which will yield all the headers, as they are being received by the
+     * node, starting from the first header received after the call.
+     * @returns {AsyncIterable<ExtendedHeader | SubscriptionError>}
      */
-    networkInfo() {
-        const ret = wasm.nodeclient_networkInfo(this.__wbg_ptr);
+    headerSubscribe() {
+        const ret = wasm.nodeclient_headerSubscribe(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;
+    }
+    /**
+     * Subscribe to the blobs from the namespace, as new headers are received by the node
+     *
+     * Return an async iterator which will yield all the shares from the namespace, as the new headers
+     * are being received by the node, starting from the first header received after the call.
+     * @param {Namespace} namespace
+     * @returns {AsyncIterable<SharesAtHeight | SubscriptionError>}
+     */
+    namespaceSubscribe(namespace) {
+        _assertClass(namespace, Namespace);
+        var ptr0 = namespace.__destroy_into_raw();
+        const ret = wasm.nodeclient_namespaceSubscribe(this.__wbg_ptr, ptr0);
         return ret;
     }
     /**
@@ -5495,57 +5862,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 +5915,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;
+    }
+    /**
+     * 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[]>}
+     */
+    requestVerifiedHeaders(from, amount) {
+        _assertClass(from, ExtendedHeader);
+        const ret = wasm.nodeclient_requestVerifiedHeaders(this.__wbg_ptr, from.__wbg_ptr, amount);
         return ret;
     }
     /**
-     * Get a synced header for the block with a given height.
-     * @param {bigint} 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
      */
-    getHeaderByHeight(height) {
-        const ret = wasm.nodeclient_getHeaderByHeight(this.__wbg_ptr, height);
+    constructor(port) {
+        const ret = wasm.nodeclient_new(port);
         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[]>}
+     * Stop the node.
+     * @returns {Promise<void>}
      */
-    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);
+    stop() {
+        const ret = wasm.nodeclient_stop(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Get data sampling metadata of an already sampled height.
-     * @param {bigint} height
-     * @returns {Promise<SamplingMetadata | undefined>}
+     * Start the node with the provided config, if it's not running
+     * @param {NodeConfig} config
+     * @returns {Promise<void>}
      */
-    getSamplingMetadata(height) {
-        const ret = wasm.nodeclient_getSamplingMetadata(this.__wbg_ptr, height);
+    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;
     }
 }
@@ -5662,6 +6023,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 +6142,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 +6167,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 +6177,7 @@ export class NodeWorker {
         return this;
     }
     /**
+     * Run `NodeWorker` main loop.
      * @returns {Promise<void>}
      */
     run() {
@@ -5888,7 +6251,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_jsbitvector_0(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_partsheader_hash(this.__wbg_ptr, ptr0, len0);
     }
 }
 
@@ -6207,6 +6570,139 @@ export class SamplingMetadata {
     }
 }
 
+const ShareFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_share_free(ptr >>> 0, 1));
+/**
+ * A single fixed-size chunk of data which is used to form an [`ExtendedDataSquare`].
+ *
+ * All data in Celestia is split into [`Share`]s before being put into a
+ * block's data square. See [`Blob::to_shares`].
+ *
+ * All shares have the fixed size of 512 bytes and the following structure:
+ *
+ * ```text
+ * | Namespace | InfoByte | (optional) sequence length | data |
+ * ```
+ *
+ * `sequence length` is the length of the original data in bytes and is present only in the first of the shares the data was split into.
+ *
+ * [`ExtendedDataSquare`]: crate::eds::ExtendedDataSquare
+ * [`Blob::to_shares`]: crate::Blob::to_shares
+ */
+export class Share {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Share.prototype);
+        obj.__wbg_ptr = ptr;
+        ShareFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Share)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    toJSON() {
+        return {
+        };
+    }
+
+    toString() {
+        return JSON.stringify(this);
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ShareFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_share_free(ptr, 0);
+    }
+}
+
+const SharesAtHeightFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sharesatheight_free(ptr >>> 0, 1));
+/**
+ * A list of shares that were published at particular height.
+ */
+export class SharesAtHeight {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SharesAtHeight.prototype);
+        obj.__wbg_ptr = ptr;
+        SharesAtHeightFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    toJSON() {
+        return {
+            height: this.height,
+            shares: this.shares,
+        };
+    }
+
+    toString() {
+        return JSON.stringify(this);
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SharesAtHeightFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sharesatheight_free(ptr, 0);
+    }
+    /**
+     * height the shares were published at
+     * @returns {bigint}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_sharesatheight_height(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * height the shares were published at
+     * @param {bigint} arg0
+     */
+    set height(arg0) {
+        wasm.__wbg_set_sharesatheight_height(this.__wbg_ptr, arg0);
+    }
+    /**
+     * shares published
+     * @returns {Share[]}
+     */
+    get shares() {
+        const ret = wasm.__wbg_get_sharesatheight_shares(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * shares published
+     * @param {Share[]} arg0
+     */
+    set shares(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_sharesatheight_shares(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
 const SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_signature_free(ptr >>> 0, 1));
@@ -6347,6 +6843,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,61 +6891,136 @@ export class SignerInfo {
     set sequence(arg0) {
         wasm.__wbg_set_signerinfo_sequence(this.__wbg_ptr, arg0);
     }
+}
+
+const StringEventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stringevent_free(ptr >>> 0, 1));
+/**
+ * StringEvent defines en Event object wrapper where all the attributes
+ * contain key/value pairs that are strings instead of raw bytes.
+ */
+export class StringEvent {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StringEvent.prototype);
+        obj.__wbg_ptr = ptr;
+        StringEventFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof StringEvent)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StringEventFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stringevent_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}
+     * @returns {string}
      */
-    public_key() {
-        const ret = wasm.signerinfo_public_key(this.__wbg_ptr);
-        return ret;
+    get type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.__wbg_get_stringevent_type(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set type(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_abcimessagelog_log(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {Attribute[]}
+     */
+    get attributes() {
+        const ret = wasm.__wbg_get_stringevent_attributes(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {Attribute[]} arg0
+     */
+    set attributes(arg0) {
+        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_stringevent_attributes(this.__wbg_ptr, ptr0, len0);
     }
 }
 
-const StringEventFinalization = (typeof FinalizationRegistry === 'undefined')
+const SubscriptionErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_stringevent_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_subscriptionerror_free(ptr >>> 0, 1));
 /**
- * StringEvent defines en Event object wrapper where all the attributes
- * contain key/value pairs that are strings instead of raw bytes.
+ * Error thrown while processing subscription
  */
-export class StringEvent {
+export class SubscriptionError {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(StringEvent.prototype);
+        const obj = Object.create(SubscriptionError.prototype);
         obj.__wbg_ptr = ptr;
-        StringEventFinalization.register(obj, obj.__wbg_ptr, obj);
+        SubscriptionErrorFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof StringEvent)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        StringEventFinalization.unregister(this);
+        SubscriptionErrorFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_stringevent_free(ptr, 0);
+        wasm.__wbg_subscriptionerror_free(ptr, 0);
+    }
+    /**
+     * Height at which the error occurred, if applicable
+     * @returns {bigint | undefined}
+     */
+    get height() {
+        const ret = wasm.__wbg_get_subscriptionerror_height(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * Height at which the error occurred, if applicable
+     * @param {bigint | null} [arg0]
+     */
+    set height(arg0) {
+        wasm.__wbg_set_subscriptionerror_height(this.__wbg_ptr, !isLikeNone(arg0), isLikeNone(arg0) ? BigInt(0) : arg0);
     }
     /**
+     * error message
      * @returns {string}
      */
-    get type() {
+    get error() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.__wbg_get_stringevent_type(this.__wbg_ptr);
+            const ret = wasm.__wbg_get_subscriptionerror_error(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -6448,29 +7029,13 @@ export class StringEvent {
         }
     }
     /**
+     * error message
      * @param {string} arg0
      */
-    set type(arg0) {
+    set error(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_abcimessagelog_log(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @returns {Attribute[]}
-     */
-    get attributes() {
-        const ret = wasm.__wbg_get_stringevent_attributes(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @param {Attribute[]} arg0
-     */
-    set attributes(arg0) {
-        const ptr0 = passArrayJsValueToWasm0(arg0, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_stringevent_attributes(this.__wbg_ptr, ptr0, len0);
+        wasm.__wbg_set_subscriptionerror_error(this.__wbg_ptr, ptr0, len0);
     }
 }
 
@@ -6676,23 +7241,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 +7274,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 +7320,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 +7536,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 +7565,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 +7647,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')
@@ -7413,6 +7978,11 @@ export class Vote {
     }
 }
 
+export function __wbg_BigInt_d53045318206d695(arg0) {
+    const ret = BigInt(arg0);
+    return ret;
+};
+
 export function __wbg_Error_1f3748b298f99708(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
@@ -7455,7 +8025,7 @@ export function __wbg_abort_496881624c2d80da() { return handleError(function (ar
     arg0.abort();
 }, arguments) };
 
-export function __wbg_accountNumber_39d1c298f9e5c082(arg0) {
+export function __wbg_accountNumber_e4a313c9dfc978c5(arg0) {
     const ret = arg0.accountNumber;
     return ret;
 };
@@ -7488,6 +8058,16 @@ export function __wbg_appversion_new(arg0) {
     return ret;
 };
 
+export function __wbg_asyncIterator_787398a275d49dae() {
+    const ret = Symbol.asyncIterator;
+    return ret;
+};
+
+export function __wbg_asynciteratorimpl_new(arg0) {
+    const ret = AsyncIteratorImpl.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_attribute_new(arg0) {
     const ret = Attribute.__wrap(arg0);
     return ret;
@@ -7498,7 +8078,7 @@ export function __wbg_attribute_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_authInfoBytes_b318cc80cf9d2ff8(arg0, arg1) {
+export function __wbg_authInfoBytes_5c381613b1053434(arg0, arg1) {
     const ret = arg1.authInfoBytes;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7521,6 +8101,11 @@ export function __wbg_blobparams_new(arg0) {
     return ret;
 };
 
+export function __wbg_blobsatheight_new(arg0) {
+    const ret = BlobsAtHeight.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_block_new(arg0) {
     const ret = Block.__wrap(arg0);
     return ret;
@@ -7536,7 +8121,7 @@ export function __wbg_blockrange_unwrap(arg0) {
     return ret;
 };
 
-export function __wbg_bodyBytes_cd75eac0b845f014(arg0, arg1) {
+export function __wbg_bodyBytes_b4d1c4630cd77e30(arg0, arg1) {
     const ret = arg1.bodyBytes;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7549,11 +8134,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 +8184,7 @@ export function __wbg_cause_94f62e1c92956ce2(arg0) {
     return ret;
 };
 
-export function __wbg_chainId_2d57400a28824c3f(arg0, arg1) {
+export function __wbg_chainId_27f066fe40ecb0f5(arg0, arg1) {
     const ret = arg1.chainId;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -7635,7 +8215,7 @@ export function __wbg_clearTimeout_96804de0ab838f26(arg0) {
     return ret;
 };
 
-export function __wbg_clearTimeout_e1b14c330a6c41a6(arg0) {
+export function __wbg_clearTimeout_da6ef1364d77d96a(arg0) {
     clearTimeout(arg0);
 };
 
@@ -7652,7 +8232,7 @@ export function __wbg_close_62eb30084a8993bf() { return handleError(function (ar
     arg0.close(arg1, getStringFromWasm0(arg2, arg3));
 }, arguments) };
 
-export function __wbg_close_7dcca1557b5bd08b(arg0) {
+export function __wbg_close_6f082e93cbded9b8(arg0) {
     arg0.close();
 };
 
@@ -7669,12 +8249,12 @@ export function __wbg_close_f602227805f17f95() { return handleError(function (ar
     arg0.close();
 }, arguments) };
 
-export function __wbg_closed_2934f4ed093a9d95(arg0) {
+export function __wbg_closed_8b9d023c2484076c(arg0) {
     const ret = arg0.closed;
     return ret;
 };
 
-export function __wbg_closed_8b9d023c2484076c(arg0) {
+export function __wbg_closed_964e107ead6defb4(arg0) {
     const ret = arg0.closed;
     return ret;
 };
@@ -7736,7 +8316,7 @@ export function __wbg_count_ee083e36b5119925() { return handleError(function (ar
     return ret;
 }, arguments) };
 
-export function __wbg_createBidirectionalStream_2b56e05ee223119c(arg0) {
+export function __wbg_createBidirectionalStream_5eee908ceaaa9e36(arg0) {
     const ret = arg0.createBidirectionalStream();
     return ret;
 };
@@ -7844,7 +8424,7 @@ export function __wbg_fetch_4fae101547df73b6(arg0, arg1, arg2) {
     return ret;
 };
 
-export function __wbg_fetch_b21de99222e9f4e1(arg0) {
+export function __wbg_fetch_ed9498ce5d2cc14d(arg0) {
     const ret = fetch(arg0);
     return ret;
 };
@@ -7859,13 +8439,13 @@ export function __wbg_from_237b1ad767238d8b(arg0) {
     return ret;
 };
 
-export function __wbg_gasLimit_c7b776728a12cf83(arg0, arg1) {
+export function __wbg_gasLimit_e6cc908a06e35f02(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_0591321ee8ff7383(arg0, arg1) {
     const ret = arg1.gasPrice;
     getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
@@ -7987,6 +8567,14 @@ export function __wbg_has_85abdd8aeb8edebf() { return handleError(function (arg0
     return ret;
 }, arguments) };
 
+export function __wbg_hash_8e74ca0df9d12a2f(arg0, arg1) {
+    const ret = arg1.hash;
+    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_headers_177bc880a5823968(arg0) {
     const ret = arg0.headers;
     return ret;
@@ -7997,7 +8585,7 @@ export function __wbg_headers_391e2f64884c873b(arg0) {
     return ret;
 };
 
-export function __wbg_incomingBidirectionalStreams_ed7915830e8f8998(arg0) {
+export function __wbg_incomingBidirectionalStreams_6ba630fafda86b63(arg0) {
     const ret = arg0.incomingBidirectionalStreams;
     return ret;
 };
@@ -8192,7 +8780,7 @@ export function __wbg_instanceof_Uint8Array_91f3c5adee7e6672(arg0) {
     return ret;
 };
 
-export function __wbg_instanceof_WebTransportBidirectionalStream_65ff63c49f91f97a(arg0) {
+export function __wbg_instanceof_WebTransportBidirectionalStream_2a24a578d4c55677(arg0) {
     let result;
     try {
         result = arg0 instanceof WebTransportBidirectionalStream;
@@ -8234,6 +8822,11 @@ export function __wbg_iterator_96378c3c9a17347c() {
     return ret;
 };
 
+export function __wbg_iteratorresultobject_new(arg0) {
+    const ret = IteratorResultObject.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_jsevent_new(arg0) {
     const ret = JsEvent.__wrap(arg0);
     return ret;
@@ -8289,7 +8882,7 @@ export function __wbg_length_904c0910ed998bf3(arg0) {
     return ret;
 };
 
-export function __wbg_memo_48d219ed93452445(arg0, arg1) {
+export function __wbg_memo_fc769b7610d2662c(arg0, arg1) {
     const ret = arg1.memo;
     var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len1 = WASM_VECTOR_LEN;
@@ -8357,6 +8950,16 @@ export function __wbg_new_56407f99198feff7() {
     return ret;
 };
 
+export function __wbg_new_6c91424bc2a93552() { return handleError(function (arg0, arg1) {
+    const ret = new WebTransport(getStringFromWasm0(arg0, arg1));
+    return ret;
+}, arguments) };
+
+export function __wbg_new_700f5e18c06513d6() { return handleError(function () {
+    const ret = new MessageChannel();
+    return ret;
+}, arguments) };
+
 export function __wbg_new_8a6f238a6ece86ea() {
     const ret = new Error();
     return ret;
@@ -8379,7 +8982,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_940(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -8391,11 +8994,6 @@ export function __wbg_new_d5e3800b120e37e1(arg0, arg1) {
     }
 };
 
-export function __wbg_new_d85e20a34917132b() { return handleError(function (arg0, arg1) {
-    const ret = new WebTransport(getStringFromWasm0(arg0, arg1));
-    return ret;
-}, arguments) };
-
 export function __wbg_new_e969dc3f68d25093() {
     const ret = new Array();
     return ret;
@@ -8431,7 +9029,7 @@ export function __wbg_newwithlength_ed0ee6c1edca86fc(arg0) {
     return ret;
 };
 
-export function __wbg_newwithoptions_1ba541b69f220543() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_newwithoptions_54c812898eb97a22() { return handleError(function (arg0, arg1, arg2) {
     const ret = new WebTransport(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments) };
@@ -8536,6 +9134,16 @@ export function __wbg_persist_1bb8fe4abf4a1238() { return handleError(function (
     return ret;
 }, arguments) };
 
+export function __wbg_port1_0618b5fb086e0c75(arg0) {
+    const ret = arg0.port1;
+    return ret;
+};
+
+export function __wbg_port2_11f233fda4932fc1(arg0) {
+    const ret = arg0.port2;
+    return ret;
+};
+
 export function __wbg_ports_9c55c10a9e47462c(arg0) {
     const ret = arg0.ports;
     return ret;
@@ -8545,15 +9153,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_3b56bfba80404bfb() { 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_ceb4f5a96dc39ace() { return handleError(function (arg0, arg1) {
     arg0.postMessage(arg1);
 }, arguments) };
 
-export function __wbg_priority_e414ab055c0d0a08(arg0) {
+export function __wbg_priority_b4a3ae75003a0632(arg0) {
     const ret = arg0.priority;
     return isLikeNone(ret) ? 0 : ret;
 };
@@ -8615,7 +9223,7 @@ export function __wbg_read_dc3d89b58ce2ae65(arg0) {
     return ret;
 };
 
-export function __wbg_readable_e39b6396dce1aa98(arg0) {
+export function __wbg_readable_0e549655ea988517(arg0) {
     const ret = arg0.readable;
     return ret;
 };
@@ -8630,7 +9238,7 @@ export function __wbg_ready_a624cdffdc1b39dc(arg0) {
     return ret;
 };
 
-export function __wbg_ready_a8d2b97e1fe33dcb(arg0) {
+export function __wbg_ready_cc3fb68899282d02(arg0) {
     const ret = arg0.ready;
     return ret;
 };
@@ -8639,7 +9247,7 @@ export function __wbg_releaseLock_fbec365467db2e6c(arg0) {
     arg0.releaseLock();
 };
 
-export function __wbg_request_537c0a65e46ce7cb(arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_request_596555d7d2f95c6b(arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.request(getStringFromWasm0(arg1, arg2), arg3, arg4);
     return ret;
 };
@@ -8677,6 +9285,11 @@ export function __wbg_send_f0af552dcc5d8183() { return handleError(function (arg
     arg0.send(getArrayU8FromWasm0(arg1, arg2));
 }, arguments) };
 
+export function __wbg_sequence_73d147c1f7e4790c(arg0) {
+    const ret = arg0.sequence;
+    return ret;
+};
+
 export function __wbg_setInterval_a708e6782af78d02() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.setInterval(arg1, arg2, ...arg3);
     return ret;
@@ -8692,7 +9305,7 @@ export function __wbg_setInterval_ed3b5e3c3ebb8a6d() { return handleError(functi
     return ret;
 }, arguments) };
 
-export function __wbg_setTimeout_6d5804197b438320(arg0, arg1) {
+export function __wbg_setTimeout_8d0ca6852dbf5ded(arg0, arg1) {
     const ret = setTimeout(arg0, arg1 >>> 0);
     return ret;
 };
@@ -8841,6 +9454,21 @@ export function __wbg_setunique_bccba0d1ccd21f16(arg0, arg1) {
     arg0.unique = arg1 !== 0;
 };
 
+export function __wbg_share_new(arg0) {
+    const ret = Share.__wrap(arg0);
+    return ret;
+};
+
+export function __wbg_share_unwrap(arg0) {
+    const ret = Share.__unwrap(arg0);
+    return ret;
+};
+
+export function __wbg_sharesatheight_new(arg0) {
+    const ret = SharesAtHeight.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_signature_new(arg0) {
     const ret = Signature.__wrap(arg0);
     return ret;
@@ -8919,6 +9547,11 @@ export function __wbg_subarray_a219824899e59712(arg0, arg1, arg2) {
     return ret;
 };
 
+export function __wbg_subscriptionerror_new(arg0) {
+    const ret = SubscriptionError.__wrap(arg0);
+    return ret;
+};
+
 export function __wbg_syncinginfosnapshot_new(arg0) {
     const ret = SyncingInfoSnapshot.__wrap(arg0);
     return ret;
@@ -8949,6 +9582,14 @@ export function __wbg_toString_1588a16751ba3f70(arg0) {
     return ret;
 };
 
+export function __wbg_toString_22c84ec5b4e33ea4(arg0, arg1, arg2) {
+    const ret = arg1.toString(arg2);
+    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_transaction_8267254fd462a1bb(arg0) {
     const ret = arg0.transaction;
     return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -8959,6 +9600,14 @@ export function __wbg_transaction_fca796495943f7a5() { return handleError(functi
     return ret;
 }, arguments) };
 
+export function __wbg_tx_a9e8b830cc737b89(arg0, arg1) {
+    const ret = arg1.tx;
+    const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
 export function __wbg_txresponse_new(arg0) {
     const ret = TxResponse.__wrap(arg0);
     return ret;
@@ -8969,7 +9618,7 @@ export function __wbg_txstatusresponse_new(arg0) {
     return ret;
 };
 
-export function __wbg_typeUrl_f02514616b090ac1(arg0, arg1) {
+export function __wbg_typeUrl_4c4eb539151a91f5(arg0, arg1) {
     const ret = arg1.typeUrl;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -9003,7 +9652,12 @@ export function __wbg_value_09d0b4eaab48b91d(arg0) {
     return ret;
 };
 
-export function __wbg_value_3c6f117eabb16ab3(arg0, arg1) {
+export function __wbg_value_3e45d77a58bc804d() { return handleError(function (arg0) {
+    const ret = arg0.value;
+    return ret;
+}, arguments) };
+
+export function __wbg_value_91f0ed317ab02220(arg0, arg1) {
     const ret = arg1.value;
     const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
@@ -9011,11 +9665,6 @@ export function __wbg_value_3c6f117eabb16ab3(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_value_3e45d77a58bc804d() { return handleError(function (arg0) {
-    const ret = arg0.value;
-    return ret;
-}, arguments) };
-
 export function __wbg_versions_c01dfd4722a88165(arg0) {
     const ret = arg0.versions;
     return ret;
@@ -9112,6 +9761,16 @@ export function __wbg_wbindgenjsvallooseeq_9dd7bb4b95ac195c(arg0, arg1) {
     return ret;
 };
 
+export function __wbg_wbindgenlt_ab7deb4a53ea1252(arg0, arg1) {
+    const ret = arg0 < arg1;
+    return ret;
+};
+
+export function __wbg_wbindgenneg_32dfec7df2a39998(arg0) {
+    const ret = -arg0;
+    return ret;
+};
+
 export function __wbg_wbindgennumberget_d855f947247a3fbc(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -9137,7 +9796,7 @@ export function __wbg_wbindgentypeof_7219206940ac0898(arg0) {
     return ret;
 };
 
-export function __wbg_writable_4f9d2cae62a7c0cb(arg0) {
+export function __wbg_writable_64e3474e78cea2a6(arg0) {
     const ret = arg0.writable;
     return ret;
 };
@@ -9147,6 +9806,12 @@ export function __wbg_write_39d7c51f917777a5(arg0, arg1) {
     return ret;
 };
 
+export function __wbindgen_cast_104c8ef10f0d551e(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1891, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1892, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1891, __wbg_adapter_9);
+    return ret;
+};
+
 export function __wbindgen_cast_13f728beb3308701(arg0, arg1) {
     var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 4, 4);
@@ -9155,51 +9820,51 @@ 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);
-    return ret;
-};
-
 export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(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);
+export function __wbindgen_cast_2def26224b93ce84(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 307, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 311, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+    const ret = makeClosure(arg0, arg1, 307, __wbg_adapter_28);
     return ret;
 };
 
-export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
-    // Cast intrinsic for `U64 -> Externref`.
-    const ret = BigInt.asUintN(64, arg0);
+export function __wbindgen_cast_3ed92e68b5dc4732(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2957, function: Function { arguments: [Externref], shim_idx: 2958, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2957, __wbg_adapter_14);
+    return ret;
+};
+
+export function __wbindgen_cast_41034090fdd410c2(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 307, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 313, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 307, __wbg_adapter_6);
     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_4625c577ab2ec9ee(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
     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_4cd69de52ef2f041(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1891, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1892, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1891, __wbg_adapter_9);
     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_569c038971c23e28(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 307, function: Function { arguments: [Externref], shim_idx: 308, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 307, __wbg_adapter_31);
     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_6411431e1279b11e(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 3065, function: Function { arguments: [NamedExternref("Event")], shim_idx: 3066, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 3065, __wbg_adapter_34);
     return ret;
 };
 
@@ -9211,9 +9876,15 @@ 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_82126c3d553ff7c6(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 307, function: Function { arguments: [], shim_idx: 315, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 307, __wbg_adapter_47);
+    return ret;
+};
+
+export function __wbindgen_cast_82adbf85e8d83012(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1891, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1892, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1891, __wbg_adapter_9);
     return ret;
 };
 
@@ -9231,15 +9902,15 @@ export function __wbindgen_cast_9ae0607507abb057(arg0) {
     return ret;
 };
 
-export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-    const ret = getArrayU8FromWasm0(arg0, arg1);
+export function __wbindgen_cast_c2988c7e5684370a(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2969, function: Function { arguments: [], shim_idx: 2970, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2969, __wbg_adapter_23);
     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_cb9088102bce6b30(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
     return ret;
 };
 
@@ -9249,12 +9920,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,9 +9928,9 @@ 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);
+export function __wbindgen_cast_f3fc3c7dffa96b4b(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 2441, function: Function { arguments: [], shim_idx: 2442, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 2441, __wbg_adapter_52);
     return ret;
 };