lumina-node-wasm 0.6.1 → 0.8.0

package/lumina_node_wasm.d.ts

@@ -1,34 +1,170 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
-* Set up a logging layer that direct logs to the browser's console.
-*/
+ * Set up a logging layer that direct logs to the browser's console.
+ */
 export function setup_logging(): void;
 /**
-* Supported Celestia networks.
-*/
-export enum Network {
+ * A helper to encode the SignDoc with protobuf to get bytes to sign directly.
+ */
+export function protoEncodeSignDoc(sign_doc: SignDoc): Uint8Array;
 /**
-* Celestia mainnet.
-*/
+ * Supported Celestia networks.
+ */
+export enum Network {
+  /**
+   * Celestia mainnet.
+   */
   Mainnet = 0,
-/**
-* Arabica testnet.
-*/
+  /**
+   * Arabica testnet.
+   */
   Arabica = 1,
-/**
-* Mocha testnet.
-*/
+  /**
+   * Mocha testnet.
+   */
   Mocha = 2,
-/**
-* Private local network.
-*/
+  /**
+   * Private local network.
+   */
   Private = 3,
 }
 /**
-* A range of blocks between `start` and `end` height, inclusive
-*/
-export class BlockRange {
+ * Sampling status for a block.
+ */
+export enum SamplingStatus {
+  /**
+   * Sampling is not done.
+   */
+  Unknown = 0,
+  /**
+   * Sampling is done and block is accepted.
+   */
+  Accepted = 1,
+  /**
+   * Sampling is done and block is rejected.
+   */
+  Rejected = 2,
+}
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+type ReadableStreamType = "bytes";
+
+    /**
+     * Public key
+     */
+    export interface PublicKey {
+      type: "ed25519" | "secp256k1",
+      value: Uint8Array
+    }
+
+    /**
+     * Common data of all account types
+     */
+    export interface BaseAccount {
+      address: string,
+      pubkey?: PublicKey,
+      accountNumber: bigint,
+      sequence: bigint
+    }
+
+    /**
+     * Auth module parameters
+     */
+    export interface AuthParams {
+      maxMemoCharacters: bigint,
+      txSigLimit: bigint,
+      txSizeCostPerByte: bigint,
+      sigVerifyCostEd25519: bigint,
+      sigVerifyCostSecp256k1: bigint
+    }
+    
+
+
+    /**
+     * Coin
+     */
+    export interface Coin {
+      denom: string,
+      amount: bigint
+    }
+    
+
+
+    /**
+     * Transaction info
+     */
+    export interface TxInfo {
+      hash: string;
+      height: bigint;
+    }
+
+    /**
+     * Transaction config.
+     */
+    export interface TxConfig {
+      gasLimit?: bigint; // utia
+      gasPrice?: number;
+    }
+    
+
+
+/**
+ * A payload to be signed
+ */
+export interface SignDoc {
+  bodyBytes: Uint8Array;
+  authInfoBytes: Uint8Array;
+  chainId: string;
+  accountNumber: bigint;
+}
+
+/**
+ * A function that produces a signature of a payload
+ */
+export type SignerFn = ((arg: SignDoc) => Uint8Array) | ((arg: SignDoc) => Promise<Uint8Array>);
+
+
+
+/**
+ * Protobuf Any type
+ */
+export interface ProtoAny {
+  typeUrl: string;
+  value: Uint8Array;
+}
+
+
+/**
+ * Version of the App
+ */
+export class AppVersion {
+  private constructor();
+  free(): void;
+  /**
+   * Latest App version variant.
+   */
+  static latest(): AppVersion;
+  /**
+   * App v1
+   */
+  static readonly V1: AppVersion;
+  /**
+   * App v2
+   */
+  static readonly V2: AppVersion;
+  /**
+   * App v3
+   */
+  static readonly V3: AppVersion;
+}
+/**
+ * Arbitrary data that can be stored in the network within certain [`Namespace`].
+ */
+export class Blob {
 /**
 ** Return copy of self without private attributes.
 */
@@ -38,18 +174,104 @@ export class BlockRange {
 */
   toString(): string;
   free(): void;
+  /**
+   * Create a new blob with the given data within the [`Namespace`].
+   */
+  constructor(namespace: Namespace, data: Uint8Array, app_version: AppVersion);
+  /**
+   * Clone a blob creating a new deep copy of it.
+   */
+  clone(): Blob;
+  /**
+   * A [`Namespace`] the [`Blob`] belongs to.
+   */
+  namespace: Namespace;
+  /**
+   * Data stored within the [`Blob`].
+   */
+  data: Uint8Array;
+  /**
+   * Version indicating the format in which [`Share`]s should be created from this [`Blob`].
+   *
+   * [`Share`]: crate::share::Share
+   */
+  share_version: number;
+  /**
+   * A [`Commitment`] computed from the [`Blob`]s data.
+   */
+  commitment: Commitment;
+  /**
+   * Index of the blob's first share in the EDS. Only set for blobs retrieved from chain.
+   */
+  get index(): bigint | undefined;
+  /**
+   * Index of the blob's first share in the EDS. Only set for blobs retrieved from chain.
+   */
+  set index(value: bigint | null | undefined);
+}
 /**
-* Last block height in range
+ * A range of blocks between `start` and `end` height, inclusive
+ */
+export class BlockRange {
+  private constructor();
+/**
+** Return copy of self without private attributes.
 */
-  end: bigint;
+  toJSON(): Object;
 /**
-* First block height in range
+* Return stringified version of self.
 */
+  toString(): string;
+  free(): void;
+  /**
+   * First block height in range
+   */
   start: bigint;
+  /**
+   * Last block height in range
+   */
+  end: bigint;
 }
 /**
-*/
-export class ConnectionCountersSnapshot {
+ * A merkle hash used to identify the [`Blob`]s data.
+ *
+ * In Celestia network, the transaction which pays for the blob's inclusion
+ * is separated from the data itself. The reason for that is to allow verifying
+ * the blockchain's state without the need to pull the actual data which got stored.
+ * To achieve that, the [`MsgPayForBlobs`] transaction only includes the [`Commitment`]s
+ * of the blobs it is paying for, not the data itself.
+ *
+ * The algorithm of computing the [`Commitment`] of the [`Blob`]'s [`Share`]s is
+ * designed in a way to allow easy and cheap proving of the [`Share`]s inclusion in the
+ * block. It is computed as a [`merkle hash`] of all the [`Nmt`] subtree roots created from
+ * the blob shares included in the [`ExtendedDataSquare`] rows. Assuming the `s1` and `s2`
+ * are the only shares of some blob posted to the celestia, they'll result in a single subtree
+ * root as shown below:
+ *
+ * ```text
+ * NMT:           row root
+ *                /     \
+ *              o   subtree root
+ *             / \      / \
+ *           _________________
+ * EDS row: | s | s | s1 | s2 |
+ * ```
+ *
+ * Using subtree roots as a base for [`Commitment`] computation allows for much smaller
+ * inclusion proofs than when the [`Share`]s would be used directly, but it imposes some
+ * constraints on how the [`Blob`]s can be placed in the [`ExtendedDataSquare`]. You can
+ * read more about that in the [`share commitment rules`].
+ *
+ * [`Blob`]: crate::Blob
+ * [`Share`]: crate::share::Share
+ * [`MsgPayForBlobs`]: celestia_proto::celestia::blob::v1::MsgPayForBlobs
+ * [`merkle hash`]: tendermint::merkle::simple_hash_from_byte_vectors
+ * [`Nmt`]: crate::nmt::Nmt
+ * [`ExtendedDataSquare`]: crate::ExtendedDataSquare
+ * [`share commitment rules`]: https://github.com/celestiaorg/celestia-app/blob/main/specs/src/specs/data_square_layout.md#blob-share-commitment-rules
+ */
+export class Commitment {
+  private constructor();
 /**
 ** Return copy of self without private attributes.
 */
@@ -59,39 +281,305 @@ export class ConnectionCountersSnapshot {
 */
   toString(): string;
   free(): void;
+  /**
+   * Hash of the commitment
+   */
+  hash(): Uint8Array;
+}
+export class ConnectionCountersSnapshot {
+  private constructor();
 /**
-* The total number of connections, both pending and established.
+** Return copy of self without private attributes.
 */
-  num_connections: number;
+  toJSON(): Object;
 /**
-* The number of outgoing connections being established.
+* Return stringified version of self.
 */
+  toString(): string;
+  free(): void;
+  /**
+   * The total number of connections, both pending and established.
+   */
+  num_connections: number;
+  /**
+   * The total number of pending connections, both incoming and outgoing.
+   */
+  num_pending: number;
+  /**
+   * The total number of pending connections, both incoming and outgoing.
+   */
+  num_pending_incoming: number;
+  /**
+   * The number of outgoing connections being established.
+   */
+  num_pending_outgoing: number;
+  /**
+   * The number of outgoing connections being established.
+   */
   num_established: number;
-/**
-* The number of established incoming connections.
-*/
+  /**
+   * The number of established incoming connections.
+   */
   num_established_incoming: number;
+  /**
+   * The number of established outgoing connections.
+   */
+  num_established_outgoing: number;
+}
+/**
+ * Header with commitments of the data availability.
+ *
+ * It consists of the root hashes of the merkle trees created from each
+ * row and column of the [`ExtendedDataSquare`]. Those are used to prove
+ * the inclusion of the data in a block.
+ *
+ * The hash of this header is a hash of all rows and columns and thus a
+ * data commitment of the block.
+ *
+ * # Example
+ *
+ * ```no_run
+ * # use celestia_types::{ExtendedHeader, Height, Share};
+ * # use celestia_types::nmt::{Namespace, NamespaceProof};
+ * # fn extended_header() -> ExtendedHeader {
+ * #     unimplemented!();
+ * # }
+ * # fn shares_with_proof(_: Height, _: &Namespace) -> (Vec<Share>, NamespaceProof) {
+ * #     unimplemented!();
+ * # }
+ * // fetch the block header and data for your namespace
+ * let namespace = Namespace::new_v0(&[1, 2, 3, 4]).unwrap();
+ * let eh = extended_header();
+ * let (shares, proof) = shares_with_proof(eh.height(), &namespace);
+ *
+ * // get the data commitment for a given row
+ * let dah = eh.dah;
+ * let root = dah.row_root(0).unwrap();
+ *
+ * // verify a proof of the inclusion of the shares
+ * assert!(proof.verify_complete_namespace(&root, &shares, *namespace).is_ok());
+ * ```
+ *
+ * [`ExtendedDataSquare`]: crate::eds::ExtendedDataSquare
+ */
+export class DataAvailabilityHeader {
+  private constructor();
 /**
-* The number of established outgoing connections.
+** Return copy of self without private attributes.
 */
-  num_established_outgoing: number;
+  toJSON(): Object;
 /**
-* The total number of pending connections, both incoming and outgoing.
+* Return stringified version of self.
 */
-  num_pending: number;
+  toString(): string;
+  free(): void;
+  /**
+   * Merkle roots of the [`ExtendedDataSquare`] rows.
+   */
+  rowRoots(): Array<any>;
+  /**
+   * Merkle roots of the [`ExtendedDataSquare`] columns.
+   */
+  columnRoots(): Array<any>;
+  /**
+   * Get a root of the row with the given index.
+   */
+  rowRoot(row: number): any;
+  /**
+   * Get the a root of the column with the given index.
+   */
+  columnRoot(column: number): any;
+  /**
+   * Compute the combined hash of all rows and columns.
+   *
+   * This is the data commitment for the block.
+   */
+  hash(): any;
+  /**
+   * Get the size of the [`ExtendedDataSquare`] for which this header was built.
+   */
+  squareWidth(): number;
+}
 /**
-* The total number of pending connections, both incoming and outgoing.
+ * Block header together with the relevant Data Availability metadata.
+ *
+ * [`ExtendedHeader`]s are used to announce and describe the blocks
+ * in the Celestia network.
+ *
+ * Before being used, each header should be validated and verified with a header you trust.
+ *
+ * # Example
+ *
+ * ```
+ * # use celestia_types::ExtendedHeader;
+ * # fn trusted_genesis_header() -> ExtendedHeader {
+ * #     let s = include_str!("../test_data/chain1/extended_header_block_1.json");
+ * #     serde_json::from_str(s).unwrap()
+ * # }
+ * # fn some_untrusted_header() -> ExtendedHeader {
+ * #     let s = include_str!("../test_data/chain1/extended_header_block_27.json");
+ * #     serde_json::from_str(s).unwrap()
+ * # }
+ * let genesis_header = trusted_genesis_header();
+ *
+ * // fetch new header
+ * let fetched_header = some_untrusted_header();
+ *
+ * fetched_header.validate().expect("Invalid block header");
+ * genesis_header.verify(&fetched_header).expect("Malicious header received");
+ * ```
+ */
+export class ExtendedHeader {
+  private constructor();
+/**
+** Return copy of self without private attributes.
 */
-  num_pending_incoming: number;
+  toJSON(): Object;
 /**
-* The number of outgoing connections being established.
+* Return stringified version of self.
 */
-  num_pending_outgoing: number;
+  toString(): string;
+  free(): void;
+  /**
+   * Clone a header producing a deep copy of it.
+   */
+  clone(): ExtendedHeader;
+  /**
+   * Get the block height.
+   */
+  height(): bigint;
+  /**
+   * Get the block time.
+   */
+  time(): number;
+  /**
+   * Get the block hash.
+   */
+  hash(): string;
+  /**
+   * Get the hash of the previous header.
+   */
+  previousHeaderHash(): string;
+  /**
+   * Decode protobuf encoded header and then validate it.
+   */
+  validate(): void;
+  /**
+   * Verify a chain of adjacent untrusted headers and make sure
+   * they are adjacent to `self`.
+   *
+   * # 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
+   */
+  verify(untrusted: ExtendedHeader): void;
+  /**
+   * 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.
+   */
+  verifyRange(untrusted: ExtendedHeader[]): void;
+  /**
+   * 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
+   */
+  verifyAdjacentRange(untrusted: ExtendedHeader[]): void;
+  /**
+   * Header of the block data availability.
+   */
+  dah: DataAvailabilityHeader;
+  /**
+   * Tendermint block header.
+   */
+  readonly header: any;
+  /**
+   * Commit metadata and signatures from validators committing the block.
+   */
+  readonly commit: any;
+  /**
+   * Information about the set of validators commiting the block.
+   */
+  readonly validatorSet: any;
+}
+export class IntoUnderlyingByteSource {
+  private constructor();
+  free(): void;
+  start(controller: ReadableByteStreamController): void;
+  pull(controller: ReadableByteStreamController): Promise<any>;
+  cancel(): void;
+  readonly type: ReadableStreamType;
+  readonly autoAllocateChunkSize: number;
+}
+export class IntoUnderlyingSink {
+  private constructor();
+  free(): void;
+  write(chunk: any): Promise<any>;
+  close(): Promise<any>;
+  abort(reason: any): Promise<any>;
+}
+export class IntoUnderlyingSource {
+  private constructor();
+  free(): void;
+  pull(controller: ReadableStreamDefaultController): Promise<any>;
+  cancel(): void;
 }
 /**
-* Information about the connections
-*/
-export class NetworkInfoSnapshot {
+ * Namespace of the data published to the celestia network.
+ *
+ * The [`Namespace`] is a single byte defining the version
+ * followed by 28 bytes specifying concrete ID of the namespace.
+ *
+ * Currently there are two versions of namespaces:
+ *
+ *  - version `0` - the one allowing for the custom namespace ids. It requires an id to start
+ *    with 18 `0x00` bytes followed by a user specified suffix (except reserved ones, see below).
+ *  - version `255` - for secondary reserved namespaces. It requires an id to start with 27
+ *    `0xff` bytes followed by a single byte indicating the id.
+ *
+ * Some namespaces are reserved for the block creation purposes and cannot be used
+ * when submitting the blobs to celestia. Those fall into one of the two categories:
+ *
+ *  - primary reserved namespaces - those use version `0` and have id lower or equal to `0xff`
+ *    so they are always placed in blocks before user-submitted data.
+ *  - secondary reserved namespaces - those use version `0xff` so they are always placed after
+ *    user-submitted data.
+ */
+export class Namespace {
+  private constructor();
 /**
 ** Return copy of self without private attributes.
 */
@@ -101,206 +589,233 @@ export class NetworkInfoSnapshot {
 */
   toString(): string;
   free(): void;
+  /**
+   * 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
+   */
+  static newV0(id: Uint8Array): Namespace;
+  /**
+   * 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`].
+   */
+  static fromRaw(raw: Uint8Array): Namespace;
+  /**
+   * Converts the [`Namespace`] to a byte slice.
+   */
+  asBytes(): Uint8Array;
+  /**
+   * Namespace size in bytes.
+   */
+  static readonly NS_SIZE: number;
+  /**
+   * Primary reserved [`Namespace`] for the compact `Share`s with `cosmos SDK` transactions.
+   */
+  static readonly TRANSACTION: Namespace;
+  /**
+   * Primary reserved [`Namespace`] for the compact Shares with MsgPayForBlobs transactions.
+   */
+  static readonly PAY_FOR_BLOB: Namespace;
+  /**
+   * 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`
+   */
+  static readonly PRIMARY_RESERVED_PADDING: Namespace;
+  /**
+   * Maximal primary reserved [`Namespace`].
+   *
+   * Used to indicate the end of the primary reserved group.
+   */
+  static readonly MAX_PRIMARY_RESERVED: Namespace;
+  /**
+   * Minimal secondary reserved [`Namespace`].
+   *
+   * Used to indicate the beginning of the secondary reserved group.
+   */
+  static readonly MIN_SECONDARY_RESERVED: Namespace;
+  /**
+   * Secondary reserved [`Namespace`] used for padding after the blobs.
+   *
+   * It is used to fill up the `original data square` after all user-submitted
+   * blobs before the parity data is generated for the `ExtendedDataSquare`.
+   */
+  static readonly TAIL_PADDING: Namespace;
+  /**
+   * The [`Namespace`] for `parity shares`.
+   *
+   * It is the namespace with which all the `parity shares` from
+   * `ExtendedDataSquare` are inserted to the `Nmt` when computing
+   * merkle roots.
+   */
+  static readonly PARITY_SHARE: Namespace;
+  /**
+   * Returns the first byte indicating the version of the [`Namespace`].
+   */
+  readonly version: number;
+  /**
+   * Returns the trailing 28 bytes indicating the id of the [`Namespace`].
+   */
+  readonly id: Uint8Array;
+}
 /**
-* Gets counters for ongoing network connections.
+ * Information about the connections
+ */
+export class NetworkInfoSnapshot {
+  private constructor();
+/**
+** Return copy of self without private attributes.
 */
-  connection_counters: ConnectionCountersSnapshot;
+  toJSON(): Object;
 /**
-* The number of connected peers, i.e. peers with whom at least one established connection exists.
+* Return stringified version of self.
 */
+  toString(): string;
+  free(): void;
+  /**
+   * The number of connected peers, i.e. peers with whom at least one established connection exists.
+   */
   num_peers: number;
+  /**
+   * Gets counters for ongoing network connections.
+   */
+  connection_counters: ConnectionCountersSnapshot;
 }
 /**
-* `NodeClient` is responsible for steering [`NodeWorker`] by sending it commands and receiving
-* responses over the provided port.
-*
-* [`NodeWorker`]: crate::worker::NodeWorker
-*/
+ * `NodeClient` is responsible for steering [`NodeWorker`] by sending it commands and receiving
+ * responses over the provided port.
+ *
+ * [`NodeWorker`]: crate::worker::NodeWorker
+ */
 export class NodeClient {
   free(): void;
-/**
-* 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
-*/
+  /**
+   * 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.
+   */
   constructor(port: any);
-/**
-* Establish a new connection to the existing worker over provided port
-* @param {any} port
-* @returns {Promise<void>}
-*/
+  /**
+   * Establish a new connection to the existing worker over provided port
+   */
   addConnectionToWorker(port: any): Promise<void>;
-/**
-* Check whether Lumina is currently running
-* @returns {Promise<boolean>}
-*/
+  /**
+   * Check whether Lumina is currently running
+   */
   isRunning(): Promise<boolean>;
-/**
-* Start a node with the provided config, if it's not running
-* @param {NodeConfig} config
-* @returns {Promise<void>}
-*/
+  /**
+   * Start a node with the provided config, if it's not running
+   */
   start(config: NodeConfig): Promise<void>;
-/**
-* @returns {Promise<void>}
-*/
   stop(): Promise<void>;
-/**
-* Get node's local peer ID.
-* @returns {Promise<string>}
-*/
+  /**
+   * Get node's local peer ID.
+   */
   localPeerId(): Promise<string>;
-/**
-* Get current [`PeerTracker`] info.
-* @returns {Promise<PeerTrackerInfoSnapshot>}
-*/
+  /**
+   * Get current [`PeerTracker`] info.
+   */
   peerTrackerInfo(): Promise<PeerTrackerInfoSnapshot>;
-/**
-* Wait until the node is connected to at least 1 peer.
-* @returns {Promise<void>}
-*/
+  /**
+   * Wait until the node is connected to at least 1 peer.
+   */
   waitConnected(): Promise<void>;
-/**
-* Wait until the node is connected to at least 1 trusted peer.
-* @returns {Promise<void>}
-*/
+  /**
+   * Wait until the node is connected to at least 1 trusted peer.
+   */
   waitConnectedTrusted(): Promise<void>;
-/**
-* Get current network info.
-* @returns {Promise<NetworkInfoSnapshot>}
-*/
+  /**
+   * Get current network info.
+   */
   networkInfo(): Promise<NetworkInfoSnapshot>;
-/**
-* Get all the multiaddresses on which the node listens.
-* @returns {Promise<Array<any>>}
-*/
+  /**
+   * Get all the multiaddresses on which the node listens.
+   */
   listeners(): Promise<Array<any>>;
-/**
-* Get all the peers that node is connected to.
-* @returns {Promise<Array<any>>}
-*/
+  /**
+   * Get all the peers that node is connected to.
+   */
   connectedPeers(): Promise<Array<any>>;
-/**
-* Trust or untrust the peer with a given ID.
-* @param {string} peer_id
-* @param {boolean} is_trusted
-* @returns {Promise<void>}
-*/
+  /**
+   * Trust or untrust the peer with a given ID.
+   */
   setPeerTrust(peer_id: string, is_trusted: boolean): Promise<void>;
-/**
-* Request the head header from the network.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @returns {Promise<any>}
-*/
-  requestHeadHeader(): Promise<any>;
-/**
-* Request a header for the block with a given hash from the network.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {string} hash
-* @returns {Promise<any>}
-*/
-  requestHeaderByHash(hash: string): Promise<any>;
-/**
-* Request a header for the block with a given height from the network.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {bigint} height
-* @returns {Promise<any>}
-*/
-  requestHeaderByHeight(height: bigint): Promise<any>;
-/**
-* Request headers in range (from, from + amount] from the network.
-*
-* The headers will be verified with the `from` header.
-*
-* Returns an array of javascript objects with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {any} from_header
-* @param {bigint} amount
-* @returns {Promise<Array<any>>}
-*/
-  requestVerifiedHeaders(from_header: any, amount: bigint): Promise<Array<any>>;
-/**
-* Get current header syncing info.
-* @returns {Promise<SyncingInfoSnapshot>}
-*/
+  /**
+   * Request the head header from the network.
+   */
+  requestHeadHeader(): Promise<ExtendedHeader>;
+  /**
+   * Request a header for the block with a given hash from the network.
+   */
+  requestHeaderByHash(hash: string): Promise<ExtendedHeader>;
+  /**
+   * Request a header for the block with a given height from the network.
+   */
+  requestHeaderByHeight(height: bigint): Promise<ExtendedHeader>;
+  /**
+   * Request headers in range (from, from + amount] from the network.
+   *
+   * The headers will be verified with the `from` header.
+   */
+  requestVerifiedHeaders(from: ExtendedHeader, amount: bigint): Promise<ExtendedHeader[]>;
+  /**
+   * Request all blobs with provided namespace in the block corresponding to this header
+   * using bitswap protocol.
+   */
+  requestAllBlobs(header: ExtendedHeader, namespace: Namespace, timeout_secs?: number | null): Promise<Blob[]>;
+  /**
+   * Get current header syncing info.
+   */
   syncerInfo(): Promise<SyncingInfoSnapshot>;
-/**
-* Get the latest header announced in the network.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @returns {Promise<any>}
-*/
-  getNetworkHeadHeader(): Promise<any>;
-/**
-* Get the latest locally synced header.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @returns {Promise<any>}
-*/
-  getLocalHeadHeader(): Promise<any>;
-/**
-* Get a synced header for the block with a given hash.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {string} hash
-* @returns {Promise<any>}
-*/
-  getHeaderByHash(hash: string): Promise<any>;
-/**
-* Get a synced header for the block with a given height.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {bigint} height
-* @returns {Promise<any>}
-*/
-  getHeaderByHeight(height: bigint): Promise<any>;
-/**
-* 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.
-*
-* Returns an array of javascript objects with given structure:
-* https://docs.rs/celestia-types/latest/celestia_types/struct.ExtendedHeader.html
-* @param {bigint | undefined} [start_height]
-* @param {bigint | undefined} [end_height]
-* @returns {Promise<Array<any>>}
-*/
-  getHeaders(start_height?: bigint, end_height?: bigint): Promise<Array<any>>;
-/**
-* Get data sampling metadata of an already sampled height.
-*
-* Returns a javascript object with given structure:
-* https://docs.rs/lumina-node/latest/lumina_node/store/struct.SamplingMetadata.html
-* @param {bigint} height
-* @returns {Promise<any>}
-*/
-  getSamplingMetadata(height: bigint): Promise<any>;
-/**
-* Returns a [`BroadcastChannel`] for events generated by [`Node`].
-* @returns {Promise<BroadcastChannel>}
-*/
+  /**
+   * Get the latest header announced in the network.
+   */
+  getNetworkHeadHeader(): Promise<ExtendedHeader | undefined>;
+  /**
+   * Get the latest locally synced header.
+   */
+  getLocalHeadHeader(): Promise<ExtendedHeader>;
+  /**
+   * Get a synced header for the block with a given hash.
+   */
+  getHeaderByHash(hash: string): Promise<ExtendedHeader>;
+  /**
+   * Get a synced header for the block with a given height.
+   */
+  getHeaderByHeight(height: bigint): Promise<ExtendedHeader>;
+  /**
+   * 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.
+   */
+  getHeaders(start_height?: bigint | null, end_height?: bigint | null): Promise<ExtendedHeader[]>;
+  /**
+   * Get data sampling metadata of an already sampled height.
+   */
+  getSamplingMetadata(height: bigint): Promise<SamplingMetadata | undefined>;
+  /**
+   * Returns a [`BroadcastChannel`] for events generated by [`Node`].
+   */
   eventsChannel(): Promise<BroadcastChannel>;
 }
 /**
-* Config for the lumina wasm node.
-*/
+ * Config for the lumina wasm node.
+ */
 export class NodeConfig {
+  private constructor();
 /**
 ** Return copy of self without private attributes.
 */
@@ -310,43 +825,87 @@ export class NodeConfig {
 */
   toString(): string;
   free(): void;
-/**
-* Get the configuration with default bootnodes for provided network
-* @param {Network} network
-* @returns {NodeConfig}
-*/
+  /**
+   * Get the configuration with default bootnodes for provided network
+   */
   static default(network: Network): NodeConfig;
-/**
-* A list of bootstrap peers to connect to.
-*/
-  bootnodes: (string)[];
-/**
-* Syncing window size, defines maximum age of headers considered for syncing and sampling.
-* Headers older than syncing window by more than an hour are eligible for pruning.
-*/
-  custom_syncing_window_secs?: number;
-/**
-* A network to connect to.
-*/
+  /**
+   * A network to connect to.
+   */
   network: Network;
+  /**
+   * A list of bootstrap peers to connect to.
+   */
+  bootnodes: string[];
+  /**
+   * Whether to store data in persistent memory or not.
+   *
+   * **Default value:** true
+   */
+  usePersistentMemory: boolean;
+  /**
+   * Sampling window defines maximum age of a block considered for syncing and sampling.
+   *
+   * If this is not set, then default value will apply:
+   *
+   * * If `use_persistent_memory == true`, default value is 30 days.
+   * * If `use_persistent_memory == false`, default value is 60 seconds.
+   *
+   * The minimum value that can be set is 60 seconds.
+   */
+  get customSamplingWindowSecs(): number | undefined;
+  /**
+   * Sampling window defines maximum age of a block considered for syncing and sampling.
+   *
+   * If this is not set, then default value will apply:
+   *
+   * * If `use_persistent_memory == true`, default value is 30 days.
+   * * If `use_persistent_memory == false`, default value is 60 seconds.
+   *
+   * The minimum value that can be set is 60 seconds.
+   */
+  set customSamplingWindowSecs(value: number | null | undefined);
+  /**
+   * Pruning delay defines how much time the pruner should wait after sampling window in
+   * order to prune the block.
+   *
+   * If this is not set, then default value will apply:
+   *
+   * * If `use_persistent_memory == true`, default value is 1 hour.
+   * * If `use_persistent_memory == false`, default value is 60 seconds.
+   *
+   * The minimum value that can be set is 60 seconds.
+   */
+  get customPruningDelaySecs(): number | undefined;
+  /**
+   * Pruning delay defines how much time the pruner should wait after sampling window in
+   * order to prune the block.
+   *
+   * If this is not set, then default value will apply:
+   *
+   * * If `use_persistent_memory == true`, default value is 1 hour.
+   * * If `use_persistent_memory == false`, default value is 60 seconds.
+   *
+   * The minimum value that can be set is 60 seconds.
+   */
+  set customPruningDelaySecs(value: number | null | undefined);
 }
 /**
-*/
+ * `NodeWorker` is responsible for receiving commands from connected [`NodeClient`]s, executing
+ * them and sending a response back, as well as accepting new `NodeClient` connections.
+ *
+ * [`NodeClient`]: crate::client::NodeClient
+ */
 export class NodeWorker {
   free(): void;
-/**
-* @param {any} port_like_object
-*/
   constructor(port_like_object: any);
-/**
-* @returns {Promise<void>}
-*/
   run(): Promise<void>;
 }
 /**
-* Statistics of the connected peers
-*/
+ * Statistics of the connected peers
+ */
 export class PeerTrackerInfoSnapshot {
+  private constructor();
 /**
 ** Return copy of self without private attributes.
 */
@@ -356,19 +915,37 @@ export class PeerTrackerInfoSnapshot {
 */
   toString(): string;
   free(): void;
-/**
-* Number of the connected peers.
-*/
+  /**
+   * Number of the connected peers.
+   */
   num_connected_peers: bigint;
-/**
-* Number of the connected trusted peers.
-*/
+  /**
+   * Number of the connected trusted peers.
+   */
   num_connected_trusted_peers: bigint;
 }
 /**
-* Status of the synchronization.
-*/
+ * Sampling metadata for a block.
+ *
+ * This struct persists DAS-ing information in a header store for future reference.
+ */
+export class SamplingMetadata {
+  private constructor();
+  free(): void;
+  /**
+   * Indicates whether this node was able to successfuly sample the block
+   */
+  status: SamplingStatus;
+  /**
+   * Return Array of cids
+   */
+  readonly cids: Uint8Array[];
+}
+/**
+ * Status of the synchronization.
+ */
 export class SyncingInfoSnapshot {
+  private constructor();
 /**
 ** Return copy of self without private attributes.
 */
@@ -378,12 +955,149 @@ export class SyncingInfoSnapshot {
 */
   toString(): string;
   free(): void;
-/**
-* Ranges of headers that are already synchronised
-*/
-  stored_headers: (BlockRange)[];
-/**
-* Syncing target. The latest height seen in the network that was successfully verified.
-*/
+  /**
+   * Ranges of headers that are already synchronised
+   */
+  stored_headers: BlockRange[];
+  /**
+   * Syncing target. The latest height seen in the network that was successfully verified.
+   */
   subjective_head: bigint;
 }
+/**
+ * Celestia grpc transaction client.
+ */
+export class TxClient {
+  free(): void;
+  /**
+   * Create a new transaction client with the specified account.
+   *
+   * Url must point to a [grpc-web proxy](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md).
+   *
+   * # Example with noble/curves
+   * ```js
+   * import { secp256k1 } from "@noble/curves/secp256k1";
+   *
+   * const address = "celestia169s50psyj2f4la9a2235329xz7rk6c53zhw9mm";
+   * const privKey = "fdc8ac75dfa1c142dbcba77938a14dd03078052ce0b49a529dcf72a9885a3abb";
+   * const pubKey = secp256k1.getPublicKey(privKey);
+   *
+   * const signer = (signDoc) => {
+   *   const bytes = protoEncodeSignDoc(signDoc);
+   *   const sig = secp256k1.sign(bytes, privKey, { prehash: true });
+   *   return sig.toCompactRawBytes();
+   * };
+   *
+   * const txClient = await new TxClient("http://127.0.0.1:18080", address, pubKey, signer);
+   * ```
+   *
+   * # Example with leap wallet
+   * ```js
+   * await window.leap.enable("mocha-4")
+   * const keys = await window.leap.getKey("mocha-4")
+   *
+   * const signer = (signDoc) => {
+   *   return window.leap.signDirect("mocha-4", keys.bech32Address, signDoc, { preferNoSetFee: true })
+   *     .then(sig => Uint8Array.from(atob(sig.signature.signature), c => c.charCodeAt(0)))
+   * }
+   *
+   * const tx_client = await new TxClient("http://127.0.0.1:18080", keys.bech32Address, keys.pubKey, signer)
+   * ```
+   */
+  constructor(url: string, bech32_address: string, pubkey: Uint8Array, signer_fn: SignerFn);
+  /**
+   * Last gas price fetched by the client
+   */
+  lastSeenGasPrice(): number;
+  /**
+   * Submit blobs to the celestia network.
+   *
+   * When no `TxConfig` is provided, client will automatically calculate needed
+   * gas and update the `gasPrice`, if network agreed on a new minimal value.
+   * To enforce specific values use a `TxConfig`.
+   *
+   * # Example
+   * ```js
+   * const ns = Namespace.newV0(new Uint8Array([97, 98, 99]));
+   * const data = new Uint8Array([100, 97, 116, 97]);
+   * const blob = new Blob(ns, data, AppVersion.latest());
+   *
+   * const txInfo = await txClient.submitBlobs([blob]);
+   * await txClient.submitBlobs([blob], { gasLimit: 100000n, gasPrice: 0.02 });
+   * ```
+   *
+   * # 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()));
+   * ```
+   */
+  submitBlobs(blobs: Blob[], tx_config?: TxConfig | null): Promise<TxInfo>;
+  /**
+   * Submit message to the celestia network.
+   *
+   * When no `TxConfig` is provided, client will automatically calculate needed
+   * gas and update the `gasPrice`, if network agreed on a new minimal value.
+   * To enforce specific values use a `TxConfig`.
+   *
+   * # Example
+   * ```js
+   * import { Registry } from "@cosmjs/proto-signing";
+   *
+   * const registry = new Registry();
+   * const sendMsg = {
+   *   typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+   *   value: {
+   *     fromAddress: "celestia169s50psyj2f4la9a2235329xz7rk6c53zhw9mm",
+   *     toAddress: "celestia1t52q7uqgnjfzdh3wx5m5phvma3umrq8k6tq2p9",
+   *     amount: [{ denom: "utia", amount: "10000" }],
+   *   },
+   * };
+   * const sendMsgAny = registry.encodeAsAny(sendMsg);
+   *
+   * const txInfo = await txClient.submitMessage(sendMsgAny);
+   * ```
+   */
+  submitMessage(message: ProtoAny, tx_config?: TxConfig | null): Promise<TxInfo>;
+  /**
+   * Get auth params
+   */
+  getAuthParams(): Promise<AuthParams>;
+  /**
+   * Get account
+   */
+  getAccount(account: string): Promise<BaseAccount>;
+  /**
+   * Get accounts
+   */
+  getAccounts(): Promise<BaseAccount[]>;
+  /**
+   * Get balance of coins with given denom
+   */
+  getBalance(address: string, denom: string): Promise<Coin>;
+  /**
+   * Get balance of all coins
+   */
+  getAllBalances(address: string): Promise<Coin[]>;
+  /**
+   * Get balance of all spendable coins
+   */
+  getSpendableBalances(address: string): Promise<Coin[]>;
+  /**
+   * Get total supply
+   */
+  getTotalSupply(): Promise<Coin[]>;
+  /**
+   * Chain id of the client
+   */
+  readonly chainId: string;
+  /**
+   * AppVersion of the client
+   */
+  readonly appVersion: AppVersion;
+}