@injectivelabs/sdk-ts 1.16.36 → 1.16.38-alpha.0

package/dist/cjs/index-sYYxCC0v.d.cts

@@ -0,0 +1,2516 @@
+import { i as SignDoc } from "./tx_pb-DsbtXDuW.cjs";
+import { Account, AminoTypes, DeliverTxResponse, GasPrice, StargateClient, StargateClientOptions } from "@cosmjs/stargate";
+import { AccountData, Algo, DirectSignResponse, EncodeObject, OfflineDirectSigner, OfflineSigner, Registry } from "@cosmjs/proto-signing";
+import { AccountData as AccountData$1, Algo as Algo$1, AminoSignResponse, OfflineAminoSigner, StdFee, StdSignDoc } from "@cosmjs/amino";
+
+//#region ../../node_modules/.pnpm/cosmjs-types@0.9.0/node_modules/cosmjs-types/binary.d.ts
+/**
+ * This file and any referenced files were automatically generated by @cosmology/telescope@1.0.7
+ * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+ * and run the transpile command or yarn proto command to regenerate this bundle.
+ */
+declare enum WireType {
+  Varint = 0,
+  Fixed64 = 1,
+  Bytes = 2,
+  Fixed32 = 5,
+}
+interface IBinaryReader {
+  buf: Uint8Array;
+  pos: number;
+  type: number;
+  len: number;
+  tag(): [number, WireType, number];
+  skip(length?: number): this;
+  skipType(wireType: number): this;
+  uint32(): number;
+  int32(): number;
+  sint32(): number;
+  fixed32(): number;
+  sfixed32(): number;
+  int64(): bigint;
+  uint64(): bigint;
+  sint64(): bigint;
+  fixed64(): bigint;
+  sfixed64(): bigint;
+  float(): number;
+  double(): number;
+  bool(): boolean;
+  bytes(): Uint8Array;
+  string(): string;
+}
+declare class BinaryReader implements IBinaryReader {
+  buf: Uint8Array;
+  pos: number;
+  type: number;
+  len: number;
+  assertBounds(): void;
+  constructor(buf?: ArrayLike<number>);
+  tag(): [number, WireType, number];
+  skip(length?: number): this;
+  skipType(wireType: number): this;
+  uint32(): number;
+  int32(): number;
+  sint32(): number;
+  fixed32(): number;
+  sfixed32(): number;
+  int64(): bigint;
+  uint64(): bigint;
+  sint64(): bigint;
+  fixed64(): bigint;
+  sfixed64(): bigint;
+  float(): number;
+  double(): number;
+  bool(): boolean;
+  bytes(): Uint8Array;
+  string(): string;
+}
+interface IBinaryWriter {
+  len: number;
+  head: IOp;
+  tail: IOp;
+  states: State | null;
+  finish(): Uint8Array;
+  fork(): IBinaryWriter;
+  reset(): IBinaryWriter;
+  ldelim(): IBinaryWriter;
+  tag(fieldNo: number, type: WireType): IBinaryWriter;
+  uint32(value: number): IBinaryWriter;
+  int32(value: number): IBinaryWriter;
+  sint32(value: number): IBinaryWriter;
+  int64(value: string | number | bigint): IBinaryWriter;
+  uint64: (value: string | number | bigint) => IBinaryWriter;
+  sint64(value: string | number | bigint): IBinaryWriter;
+  fixed64(value: string | number | bigint): IBinaryWriter;
+  sfixed64: (value: string | number | bigint) => IBinaryWriter;
+  bool(value: boolean): IBinaryWriter;
+  fixed32(value: number): IBinaryWriter;
+  sfixed32: (value: number) => IBinaryWriter;
+  float(value: number): IBinaryWriter;
+  double(value: number): IBinaryWriter;
+  bytes(value: Uint8Array): IBinaryWriter;
+  string(value: string): IBinaryWriter;
+}
+interface IOp {
+  len: number;
+  next?: IOp;
+  proceed(buf: Uint8Array | number[], pos: number): void;
+}
+declare class State {
+  head: IOp;
+  tail: IOp;
+  len: number;
+  next: State | null;
+  constructor(writer: BinaryWriter);
+}
+declare class BinaryWriter implements IBinaryWriter {
+  len: number;
+  head: IOp;
+  tail: IOp;
+  states: State | null;
+  constructor();
+  static create(): BinaryWriter;
+  static alloc(size: number): Uint8Array | number[];
+  private _push;
+  finish(): Uint8Array;
+  fork(): BinaryWriter;
+  reset(): BinaryWriter;
+  ldelim(): BinaryWriter;
+  tag(fieldNo: number, type: WireType): BinaryWriter;
+  uint32(value: number): BinaryWriter;
+  int32(value: number): BinaryWriter;
+  sint32(value: number): BinaryWriter;
+  int64(value: string | number | bigint): BinaryWriter;
+  uint64: (value: string | number | bigint) => BinaryWriter;
+  sint64(value: string | number | bigint): BinaryWriter;
+  fixed64(value: string | number | bigint): BinaryWriter;
+  sfixed64: (value: string | number | bigint) => BinaryWriter;
+  bool(value: boolean): BinaryWriter;
+  fixed32(value: number): BinaryWriter;
+  sfixed32: (value: number) => BinaryWriter;
+  float(value: number): BinaryWriter;
+  double(value: number): BinaryWriter;
+  bytes(value: Uint8Array): BinaryWriter;
+  string(value: string): BinaryWriter;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cosmjs-types@0.9.0/node_modules/cosmjs-types/cosmos/base/v1beta1/coin.d.ts
+/**
+ * Coin defines a token with a denomination and an amount.
+ *
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+interface Coin {
+  denom: string;
+  amount: string;
+}
+declare const Coin: {
+  typeUrl: string;
+  encode(message: Coin, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): Coin;
+  fromJSON(object: any): Coin;
+  toJSON(message: Coin): unknown;
+  fromPartial<I extends {
+    denom?: string | undefined;
+    amount?: string | undefined;
+  } & {
+    denom?: string | undefined;
+    amount?: string | undefined;
+  } & Record<Exclude<keyof I, keyof Coin>, never>>(object: I): Coin;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/cosmjs-types@0.9.0/node_modules/cosmjs-types/ibc/core/client/v1/client.d.ts
+/**
+ * Height is a monotonically increasing data type
+ * that can be compared against another Height for the purposes of updating and
+ * freezing clients
+ *
+ * Normally the RevisionHeight is incremented at each height while keeping
+ * RevisionNumber the same. However some consensus algorithms may choose to
+ * reset the height in certain conditions e.g. hard forks, state-machine
+ * breaking changes In these cases, the RevisionNumber is incremented so that
+ * height continues to be monitonically increasing even as the RevisionHeight
+ * gets reset
+ */
+interface Height {
+  /** the revision that the client is currently on */
+  revisionNumber: bigint;
+  /** the height within the given revision */
+  revisionHeight: bigint;
+}
+declare const Height: {
+  typeUrl: string;
+  encode(message: Height, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): Height;
+  fromJSON(object: any): Height;
+  toJSON(message: Height): unknown;
+  fromPartial<I extends {
+    revisionNumber?: bigint | undefined;
+    revisionHeight?: bigint | undefined;
+  } & {
+    revisionNumber?: bigint | undefined;
+    revisionHeight?: bigint | undefined;
+  } & Record<Exclude<keyof I, keyof Height>, never>>(object: I): Height;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/cosmjs-types@0.9.0/node_modules/cosmjs-types/ibc/applications/transfer/v1/tx.d.ts
+/**
+ * MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
+ * ICS20 enabled chains. See ICS Spec here:
+ * https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
+ */
+interface MsgTransfer {
+  /** the port on which the packet will be sent */
+  sourcePort: string;
+  /** the channel by which the packet will be sent */
+  sourceChannel: string;
+  /** the tokens to be transferred */
+  token: Coin;
+  /** the sender address */
+  sender: string;
+  /** the recipient address on the destination chain */
+  receiver: string;
+  /**
+   * Timeout height relative to the current block height.
+   * The timeout is disabled when set to 0.
+   */
+  timeoutHeight: Height;
+  /**
+   * Timeout timestamp in absolute nanoseconds since unix epoch.
+   * The timeout is disabled when set to 0.
+   */
+  timeoutTimestamp: bigint;
+  /** optional memo */
+  memo: string;
+}
+declare const MsgTransfer: {
+  typeUrl: string;
+  encode(message: MsgTransfer, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgTransfer;
+  fromJSON(object: any): MsgTransfer;
+  toJSON(message: MsgTransfer): unknown;
+  fromPartial<I extends {
+    sourcePort?: string | undefined;
+    sourceChannel?: string | undefined;
+    token?: {
+      denom?: string | undefined;
+      amount?: string | undefined;
+    } | undefined;
+    sender?: string | undefined;
+    receiver?: string | undefined;
+    timeoutHeight?: {
+      revisionNumber?: bigint | undefined;
+      revisionHeight?: bigint | undefined;
+    } | undefined;
+    timeoutTimestamp?: bigint | undefined;
+    memo?: string | undefined;
+  } & {
+    sourcePort?: string | undefined;
+    sourceChannel?: string | undefined;
+    token?: ({
+      denom?: string | undefined;
+      amount?: string | undefined;
+    } & {
+      denom?: string | undefined;
+      amount?: string | undefined;
+    } & Record<Exclude<keyof I["token"], keyof Coin>, never>) | undefined;
+    sender?: string | undefined;
+    receiver?: string | undefined;
+    timeoutHeight?: ({
+      revisionNumber?: bigint | undefined;
+      revisionHeight?: bigint | undefined;
+    } & {
+      revisionNumber?: bigint | undefined;
+      revisionHeight?: bigint | undefined;
+    } & Record<Exclude<keyof I["timeoutHeight"], keyof Height>, never>) | undefined;
+    timeoutTimestamp?: bigint | undefined;
+    memo?: string | undefined;
+  } & Record<Exclude<keyof I, keyof MsgTransfer>, never>>(object: I): MsgTransfer;
+};
+//#endregion
+//#region src/core/modules/ibc/msgs/MsgTransferCosmjs.d.ts
+declare namespace MsgTransferCosmjs {
+  interface Params {
+    amount: {
+      denom: string;
+      amount: string;
+    };
+    sender: string;
+    port: string;
+    receiver: string;
+    channelId: string;
+    timeout?: number;
+    height?: {
+      revisionHeight: number;
+      revisionNumber: number;
+    };
+  }
+  type Proto = MsgTransfer;
+}
+/**
+ * @category Messages
+ *
+ * @deprecated use MsgTransfer with SIGN_DIRECT and a Cosmos wallet
+ */
+declare class MsgTransferCosmjs {
+  params: MsgTransferCosmjs.Params;
+  constructor(params: MsgTransferCosmjs.Params);
+  static fromJSON(params: MsgTransferCosmjs.Params): MsgTransferCosmjs;
+  toProto(): MsgTransfer;
+  toData(): void;
+  toAmino(): {
+    type: string;
+    value: {
+      timeoutHeight: {
+        revisionHeight: string;
+        revisionNumber: string;
+      } | undefined;
+      timeoutTimestamp: string | undefined;
+      sourcePort: string;
+      sourceChannel: string;
+      token: Coin;
+      sender: string;
+      receiver: string;
+      memo: string;
+    };
+  };
+  toWeb3Gw(): {
+    timeoutHeight: {
+      revisionHeight: string;
+      revisionNumber: string;
+    } | undefined;
+    timeoutTimestamp: string | undefined;
+    sourcePort: string;
+    sourceChannel: string;
+    token: Coin;
+    sender: string;
+    receiver: string;
+    memo: string;
+    '@type': string;
+  };
+  toDirectSign(): {
+    type: string;
+    message: MsgTransfer;
+  };
+  toBinary(): Uint8Array;
+}
+//#endregion
+//#region src/core/accounts/AccountParser.d.ts
+declare const accountParser: (ethAccount: any) => Account;
+//#endregion
+//#region src/core/stargate/StargateClient.d.ts
+declare class StargateClient$1 extends StargateClient {
+  getAccount(searchAddress: string): Promise<Account | null>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/cosmjs-types@0.9.0/node_modules/cosmjs-types/cosmos/tx/v1beta1/tx.d.ts
+/**
+ * TxRaw is a variant of Tx that pins the signer's exact binary representation
+ * of body and auth_info. This is used for signing, broadcasting and
+ * verification. The binary `serialize(tx: TxRaw)` is stored in Tendermint and
+ * the hash `sha256(serialize(tx: TxRaw))` becomes the "txhash", commonly used
+ * as the transaction ID.
+ */
+interface TxRaw {
+  /**
+   * body_bytes is a protobuf serialization of a TxBody that matches the
+   * representation in SignDoc.
+   */
+  bodyBytes: Uint8Array;
+  /**
+   * auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
+   * representation in SignDoc.
+   */
+  authInfoBytes: Uint8Array;
+  /**
+   * signatures is a list of signatures that matches the length and order of
+   * AuthInfo's signer_infos to allow connecting signature meta information like
+   * public key and signing mode by position.
+   */
+  signatures: Uint8Array[];
+}
+declare const TxRaw: {
+  typeUrl: string;
+  encode(message: TxRaw, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): TxRaw;
+  fromJSON(object: any): TxRaw;
+  toJSON(message: TxRaw): unknown;
+  fromPartial<I extends {
+    bodyBytes?: Uint8Array | undefined;
+    authInfoBytes?: Uint8Array | undefined;
+    signatures?: Uint8Array[] | undefined;
+  } & {
+    bodyBytes?: Uint8Array | undefined;
+    authInfoBytes?: Uint8Array | undefined;
+    signatures?: (Uint8Array[] & Uint8Array[] & Record<Exclude<keyof I["signatures"], keyof Uint8Array[]>, never>) | undefined;
+  } & Record<Exclude<keyof I, keyof TxRaw>, never>>(object: I): TxRaw;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/readonly-date@1.0.0/node_modules/readonly-date/index.d.ts
+/**
+ * An object like JavaScript's Date, but immutable.
+ *
+ * Immutability is enforced at compile time by removing
+ * all mutable methods in the type definition.
+ */
+interface ReadonlyDate {
+  toString(): string;
+  toDateString(): string;
+  toTimeString(): string;
+  toLocaleString(): string;
+  toLocaleDateString(): string;
+  toLocaleTimeString(): string;
+  valueOf(): number;
+  getTime(): number;
+  getFullYear(): number;
+  getUTCFullYear(): number;
+  getMonth(): number;
+  getUTCMonth(): number;
+  getDate(): number;
+  getUTCDate(): number;
+  getDay(): number;
+  getUTCDay(): number;
+  getHours(): number;
+  getUTCHours(): number;
+  getMinutes(): number;
+  getUTCMinutes(): number;
+  getSeconds(): number;
+  getUTCSeconds(): number;
+  getMilliseconds(): number;
+  getUTCMilliseconds(): number;
+  getTimezoneOffset(): number;
+  toUTCString(): string;
+  toISOString(): string;
+  toJSON(key?: any): string;
+  toLocaleString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+  toLocaleDateString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+  toLocaleTimeString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+  [Symbol.toPrimitive](hint: "default"): string;
+  [Symbol.toPrimitive](hint: "string"): string;
+  [Symbol.toPrimitive](hint: "number"): number;
+  [Symbol.toPrimitive](hint: string): string | number;
+}
+interface ReadonlyDateConstructor {
+  new (): ReadonlyDate;
+  new (value: number | string): ReadonlyDate;
+  new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): ReadonlyDate;
+  (): string;
+  readonly prototype: Date;
+  parse(s: string): number;
+  UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+  now(): number;
+}
+declare const ReadonlyDate: ReadonlyDateConstructor;
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/dates.d.ts
+interface ReadonlyDateWithNanoseconds extends ReadonlyDate {
+  readonly nanoseconds?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/xstream@11.14.0/node_modules/xstream/index.d.ts
+interface InternalListener<T> {
+  _n: (v: T) => void;
+  _e: (err: any) => void;
+  _c: () => void;
+}
+interface InternalProducer<T> {
+  _start(listener: InternalListener<T>): void;
+  _stop: () => void;
+}
+interface Producer<T> {
+  start: (listener: Listener<T>) => void;
+  stop: () => void;
+}
+interface Listener<T> {
+  next: (x: T) => void;
+  error: (err: any) => void;
+  complete: () => void;
+}
+interface Subscription {
+  unsubscribe(): void;
+}
+interface Observable<T> {
+  subscribe(listener: Listener<T>): Subscription;
+}
+interface MergeSignature {
+  (): Stream<any>;
+  <T1>(s1: Stream<T1>): Stream<T1>;
+  <T1, T2>(s1: Stream<T1>, s2: Stream<T2>): Stream<T1 | T2>;
+  <T1, T2, T3>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>): Stream<T1 | T2 | T3>;
+  <T1, T2, T3, T4>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>): Stream<T1 | T2 | T3 | T4>;
+  <T1, T2, T3, T4, T5>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>): Stream<T1 | T2 | T3 | T4 | T5>;
+  <T1, T2, T3, T4, T5, T6>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>): Stream<T1 | T2 | T3 | T4 | T5 | T6>;
+  <T1, T2, T3, T4, T5, T6, T7>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>): Stream<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+  <T1, T2, T3, T4, T5, T6, T7, T8>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>): Stream<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+  <T1, T2, T3, T4, T5, T6, T7, T8, T9>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>, s9: Stream<T9>): Stream<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+  <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>, s9: Stream<T9>, s10: Stream<T10>): Stream<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+  <T>(...stream: Array<Stream<T>>): Stream<T>;
+}
+interface CombineSignature {
+  (): Stream<Array<any>>;
+  <T1>(s1: Stream<T1>): Stream<[T1]>;
+  <T1, T2>(s1: Stream<T1>, s2: Stream<T2>): Stream<[T1, T2]>;
+  <T1, T2, T3>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>): Stream<[T1, T2, T3]>;
+  <T1, T2, T3, T4>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>): Stream<[T1, T2, T3, T4]>;
+  <T1, T2, T3, T4, T5>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>): Stream<[T1, T2, T3, T4, T5]>;
+  <T1, T2, T3, T4, T5, T6>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>): Stream<[T1, T2, T3, T4, T5, T6]>;
+  <T1, T2, T3, T4, T5, T6, T7>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>): Stream<[T1, T2, T3, T4, T5, T6, T7]>;
+  <T1, T2, T3, T4, T5, T6, T7, T8>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>): Stream<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+  <T1, T2, T3, T4, T5, T6, T7, T8, T9>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>, s9: Stream<T9>): Stream<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+  <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(s1: Stream<T1>, s2: Stream<T2>, s3: Stream<T3>, s4: Stream<T4>, s5: Stream<T5>, s6: Stream<T6>, s7: Stream<T7>, s8: Stream<T8>, s9: Stream<T9>, s10: Stream<T10>): Stream<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+  <T>(...stream: Array<Stream<T>>): Stream<Array<T>>;
+  (...stream: Array<Stream<any>>): Stream<Array<any>>;
+}
+declare class Stream<T> implements InternalListener<T> {
+  _prod: InternalProducer<T>;
+  protected _ils: Array<InternalListener<T>>;
+  protected _stopID: any;
+  protected _dl: InternalListener<T>;
+  protected _d: boolean;
+  protected _target: Stream<T> | null;
+  protected _err: any;
+  constructor(producer?: InternalProducer<T>);
+  _n(t: T): void;
+  _e(err: any): void;
+  _c(): void;
+  _x(): void;
+  _stopNow(): void;
+  _add(il: InternalListener<T>): void;
+  _remove(il: InternalListener<T>): void;
+  _pruneCycles(): void;
+  _hasNoSinks(x: InternalListener<any>, trace: Array<any>): boolean;
+  private ctor;
+  /**
+   * Adds a Listener to the Stream.
+   *
+   * @param {Listener} listener
+   */
+  addListener(listener: Partial<Listener<T>>): void;
+  /**
+   * Removes a Listener from the Stream, assuming the Listener was added to it.
+   *
+   * @param {Listener<T>} listener
+   */
+  removeListener(listener: Partial<Listener<T>>): void;
+  /**
+   * Adds a Listener to the Stream returning a Subscription to remove that
+   * listener.
+   *
+   * @param {Listener} listener
+   * @returns {Subscription}
+   */
+  subscribe(listener: Partial<Listener<T>>): Subscription;
+  /**
+   * Creates a new Stream given a Producer.
+   *
+   * @factory true
+   * @param {Producer} producer An optional Producer that dictates how to
+   * start, generate events, and stop the Stream.
+   * @return {Stream}
+   */
+  static create<T>(producer?: Producer<T>): Stream<T>;
+  /**
+   * Creates a new MemoryStream given a Producer.
+   *
+   * @factory true
+   * @param {Producer} producer An optional Producer that dictates how to
+   * start, generate events, and stop the Stream.
+   * @return {MemoryStream}
+   */
+  static createWithMemory<T>(producer?: Producer<T>): MemoryStream<T>;
+  /**
+   * Creates a Stream that does nothing when started. It never emits any event.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   *          never
+   * -----------------------
+   * ```
+   *
+   * @factory true
+   * @return {Stream}
+   */
+  static never<T = any>(): Stream<T>;
+  /**
+   * Creates a Stream that immediately emits the "complete" notification when
+   * started, and that's it.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * empty
+   * -|
+   * ```
+   *
+   * @factory true
+   * @return {Stream}
+   */
+  static empty<T = any>(): Stream<T>;
+  /**
+   * Creates a Stream that immediately emits an "error" notification with the
+   * value you passed as the `error` argument when the stream starts, and that's
+   * it.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * throw(X)
+   * -X
+   * ```
+   *
+   * @factory true
+   * @param error The error event to emit on the created stream.
+   * @return {Stream}
+   */
+  static throw(error: any): Stream<any>;
+  /**
+   * Creates a stream from an Array, Promise, or an Observable.
+   *
+   * @factory true
+   * @param {Array|PromiseLike|Observable} input The input to make a stream from.
+   * @return {Stream}
+   */
+  static from<T>(input: PromiseLike<T> | Stream<T> | Array<T> | Observable<T>): Stream<T>;
+  /**
+   * Creates a Stream that immediately emits the arguments that you give to
+   * *of*, then completes.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * of(1,2,3)
+   * 123|
+   * ```
+   *
+   * @factory true
+   * @param a The first value you want to emit as an event on the stream.
+   * @param b The second value you want to emit as an event on the stream. One
+   * or more of these values may be given as arguments.
+   * @return {Stream}
+   */
+  static of<T>(...items: Array<T>): Stream<T>;
+  /**
+   * Converts an array to a stream. The returned stream will emit synchronously
+   * all the items in the array, and then complete.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * fromArray([1,2,3])
+   * 123|
+   * ```
+   *
+   * @factory true
+   * @param {Array} array The array to be converted as a stream.
+   * @return {Stream}
+   */
+  static fromArray<T>(array: Array<T>): Stream<T>;
+  /**
+   * Converts a promise to a stream. The returned stream will emit the resolved
+   * value of the promise, and then complete. However, if the promise is
+   * rejected, the stream will emit the corresponding error.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * fromPromise( ----42 )
+   * -----------------42|
+   * ```
+   *
+   * @factory true
+   * @param {PromiseLike} promise The promise to be converted as a stream.
+   * @return {Stream}
+   */
+  static fromPromise<T>(promise: PromiseLike<T>): Stream<T>;
+  /**
+   * Converts an Observable into a Stream.
+   *
+   * @factory true
+   * @param {any} observable The observable to be converted as a stream.
+   * @return {Stream}
+   */
+  static fromObservable<T>(obs: {
+    subscribe: any;
+  }): Stream<T>;
+  /**
+   * Creates a stream that periodically emits incremental numbers, every
+   * `period` milliseconds.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   *     periodic(1000)
+   * ---0---1---2---3---4---...
+   * ```
+   *
+   * @factory true
+   * @param {number} period The interval in milliseconds to use as a rate of
+   * emission.
+   * @return {Stream}
+   */
+  static periodic(period: number): Stream<number>;
+  /**
+   * Blends multiple streams together, emitting events from all of them
+   * concurrently.
+   *
+   * *merge* takes multiple streams as arguments, and creates a stream that
+   * behaves like each of the argument streams, in parallel.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --1----2-----3--------4---
+   * ----a-----b----c---d------
+   *            merge
+   * --1-a--2--b--3-c---d--4---
+   * ```
+   *
+   * @factory true
+   * @param {Stream} stream1 A stream to merge together with other streams.
+   * @param {Stream} stream2 A stream to merge together with other streams. Two
+   * or more streams may be given as arguments.
+   * @return {Stream}
+   */
+  static merge: MergeSignature;
+  /**
+   * Combines multiple input streams together to return a stream whose events
+   * are arrays that collect the latest events from each input stream.
+   *
+   * *combine* internally remembers the most recent event from each of the input
+   * streams. When any of the input streams emits an event, that event together
+   * with all the other saved events are combined into an array. That array will
+   * be emitted on the output stream. It's essentially a way of joining together
+   * the events from multiple streams.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --1----2-----3--------4---
+   * ----a-----b-----c--d------
+   *          combine
+   * ----1a-2a-2b-3b-3c-3d-4d--
+   * ```
+   *
+   * @factory true
+   * @param {Stream} stream1 A stream to combine together with other streams.
+   * @param {Stream} stream2 A stream to combine together with other streams.
+   * Multiple streams, not just two, may be given as arguments.
+   * @return {Stream}
+   */
+  static combine: CombineSignature;
+  protected _map<U>(project: (t: T) => U): Stream<U> | MemoryStream<U>;
+  /**
+   * Transforms each event from the input Stream through a `project` function,
+   * to get a Stream that emits those transformed events.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --1---3--5-----7------
+   *    map(i => i * 10)
+   * --10--30-50----70-----
+   * ```
+   *
+   * @param {Function} project A function of type `(t: T) => U` that takes event
+   * `t` of type `T` from the input Stream and produces an event of type `U`, to
+   * be emitted on the output Stream.
+   * @return {Stream}
+   */
+  map<U>(project: (t: T) => U): Stream<U>;
+  /**
+   * It's like `map`, but transforms each input event to always the same
+   * constant value on the output Stream.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --1---3--5-----7-----
+   *       mapTo(10)
+   * --10--10-10----10----
+   * ```
+   *
+   * @param projectedValue A value to emit on the output Stream whenever the
+   * input Stream emits any value.
+   * @return {Stream}
+   */
+  mapTo<U>(projectedValue: U): Stream<U>;
+  filter<S extends T>(passes: (t: T) => t is S): Stream<S>;
+  filter(passes: (t: T) => boolean): Stream<T>;
+  /**
+   * Lets the first `amount` many events from the input stream pass to the
+   * output stream, then makes the output stream complete.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --a---b--c----d---e--
+   *    take(3)
+   * --a---b--c|
+   * ```
+   *
+   * @param {number} amount How many events to allow from the input stream
+   * before completing the output stream.
+   * @return {Stream}
+   */
+  take(amount: number): Stream<T>;
+  /**
+   * Ignores the first `amount` many events from the input stream, and then
+   * after that starts forwarding events from the input stream to the output
+   * stream.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --a---b--c----d---e--
+   *       drop(3)
+   * --------------d---e--
+   * ```
+   *
+   * @param {number} amount How many events to ignore from the input stream
+   * before forwarding all events from the input stream to the output stream.
+   * @return {Stream}
+   */
+  drop(amount: number): Stream<T>;
+  /**
+   * When the input stream completes, the output stream will emit the last event
+   * emitted by the input stream, and then will also complete.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --a---b--c--d----|
+   *       last()
+   * -----------------d|
+   * ```
+   *
+   * @return {Stream}
+   */
+  last(): Stream<T>;
+  /**
+   * Prepends the given `initial` value to the sequence of events emitted by the
+   * input stream. The returned stream is a MemoryStream, which means it is
+   * already `remember()`'d.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * ---1---2-----3---
+   *   startWith(0)
+   * 0--1---2-----3---
+   * ```
+   *
+   * @param initial The value or event to prepend.
+   * @return {MemoryStream}
+   */
+  startWith(initial: T): MemoryStream<T>;
+  /**
+   * Uses another stream to determine when to complete the current stream.
+   *
+   * When the given `other` stream emits an event or completes, the output
+   * stream will complete. Before that happens, the output stream will behaves
+   * like the input stream.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * ---1---2-----3--4----5----6---
+   *   endWhen( --------a--b--| )
+   * ---1---2-----3--4--|
+   * ```
+   *
+   * @param other Some other stream that is used to know when should the output
+   * stream of this operator complete.
+   * @return {Stream}
+   */
+  endWhen(other: Stream<any>): Stream<T>;
+  /**
+   * "Folds" the stream onto itself.
+   *
+   * Combines events from the past throughout
+   * the entire execution of the input stream, allowing you to accumulate them
+   * together. It's essentially like `Array.prototype.reduce`. The returned
+   * stream is a MemoryStream, which means it is already `remember()`'d.
+   *
+   * The output stream starts by emitting the `seed` which you give as argument.
+   * Then, when an event happens on the input stream, it is combined with that
+   * seed value through the `accumulate` function, and the output value is
+   * emitted on the output stream. `fold` remembers that output value as `acc`
+   * ("accumulator"), and then when a new input event `t` happens, `acc` will be
+   * combined with that to produce the new `acc` and so forth.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * ------1-----1--2----1----1------
+   *   fold((acc, x) => acc + x, 3)
+   * 3-----4-----5--7----8----9------
+   * ```
+   *
+   * @param {Function} accumulate A function of type `(acc: R, t: T) => R` that
+   * takes the previous accumulated value `acc` and the incoming event from the
+   * input stream and produces the new accumulated value.
+   * @param seed The initial accumulated value, of type `R`.
+   * @return {MemoryStream}
+   */
+  fold<R>(accumulate: (acc: R, t: T) => R, seed: R): MemoryStream<R>;
+  /**
+   * Replaces an error with another stream.
+   *
+   * When (and if) an error happens on the input stream, instead of forwarding
+   * that error to the output stream, *replaceError* will call the `replace`
+   * function which returns the stream that the output stream will replicate.
+   * And, in case that new stream also emits an error, `replace` will be called
+   * again to get another stream to start replicating.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --1---2-----3--4-----X
+   *   replaceError( () => --10--| )
+   * --1---2-----3--4--------10--|
+   * ```
+   *
+   * @param {Function} replace A function of type `(err) => Stream` that takes
+   * the error that occurred on the input stream or on the previous replacement
+   * stream and returns a new stream. The output stream will behave like the
+   * stream that this function returns.
+   * @return {Stream}
+   */
+  replaceError(replace: (err: any) => Stream<T>): Stream<T>;
+  /**
+   * Flattens a "stream of streams", handling only one nested stream at a time
+   * (no concurrency).
+   *
+   * If the input stream is a stream that emits streams, then this operator will
+   * return an output stream which is a flat stream: emits regular events. The
+   * flattening happens without concurrency. It works like this: when the input
+   * stream emits a nested stream, *flatten* will start imitating that nested
+   * one. However, as soon as the next nested stream is emitted on the input
+   * stream, *flatten* will forget the previous nested one it was imitating, and
+   * will start imitating the new nested one.
+   *
+   * Marble diagram:
+   *
+   * ```text
+   * --+--------+---------------
+   *   \        \
+   *    \       ----1----2---3--
+   *    --a--b----c----d--------
+   *           flatten
+   * -----a--b------1----2---3--
+   * ```
+   *
+   * @return {Stream}
+   */
+  flatten<R>(this: Stream<Stream<R> | MemoryStream<R>>): Stream<R>;
+  /**
+   * Passes the input stream to a custom operator, to produce an output stream.
+   *
+   * *compose* is a handy way of using an existing function in a chained style.
+   * Instead of writing `outStream = f(inStream)` you can write
+   * `outStream = inStream.compose(f)`.
+   *
+   * @param {function} operator A function that takes a stream as input and
+   * returns a stream as well.
+   * @return {Stream}
+   */
+  compose<U>(operator: (stream: Stream<T>) => U): U;
+  /**
+   * Returns an output stream that behaves like the input stream, but also
+   * remembers the most recent event that happens on the input stream, so that a
+   * newly added listener will immediately receive that memorised event.
+   *
+   * @return {MemoryStream}
+   */
+  remember(): MemoryStream<T>;
+  debug(): Stream<T>;
+  debug(labelOrSpy: string): Stream<T>;
+  debug(labelOrSpy: (t: T) => any): Stream<T>;
+  /**
+   * *imitate* changes this current Stream to emit the same events that the
+   * `other` given Stream does. This method returns nothing.
+   *
+   * This method exists to allow one thing: **circular dependency of streams**.
+   * For instance, let's imagine that for some reason you need to create a
+   * circular dependency where stream `first$` depends on stream `second$`
+   * which in turn depends on `first$`:
+   *
+   * <!-- skip-example -->
+   * ```js
+   * import delay from 'xstream/extra/delay'
+   *
+   * var first$ = second$.map(x => x * 10).take(3);
+   * var second$ = first$.map(x => x + 1).startWith(1).compose(delay(100));
+   * ```
+   *
+   * However, that is invalid JavaScript, because `second$` is undefined
+   * on the first line. This is how *imitate* can help solve it:
+   *
+   * ```js
+   * import delay from 'xstream/extra/delay'
+   *
+   * var secondProxy$ = xs.create();
+   * var first$ = secondProxy$.map(x => x * 10).take(3);
+   * var second$ = first$.map(x => x + 1).startWith(1).compose(delay(100));
+   * secondProxy$.imitate(second$);
+   * ```
+   *
+   * We create `secondProxy$` before the others, so it can be used in the
+   * declaration of `first$`. Then, after both `first$` and `second$` are
+   * defined, we hook `secondProxy$` with `second$` with `imitate()` to tell
+   * that they are "the same". `imitate` will not trigger the start of any
+   * stream, it just binds `secondProxy$` and `second$` together.
+   *
+   * The following is an example where `imitate()` is important in Cycle.js
+   * applications. A parent component contains some child components. A child
+   * has an action stream which is given to the parent to define its state:
+   *
+   * <!-- skip-example -->
+   * ```js
+   * const childActionProxy$ = xs.create();
+   * const parent = Parent({...sources, childAction$: childActionProxy$});
+   * const childAction$ = parent.state$.map(s => s.child.action$).flatten();
+   * childActionProxy$.imitate(childAction$);
+   * ```
+   *
+   * Note, though, that **`imitate()` does not support MemoryStreams**. If we
+   * would attempt to imitate a MemoryStream in a circular dependency, we would
+   * either get a race condition (where the symptom would be "nothing happens")
+   * or an infinite cyclic emission of values. It's useful to think about
+   * MemoryStreams as cells in a spreadsheet. It doesn't make any sense to
+   * define a spreadsheet cell `A1` with a formula that depends on `B1` and
+   * cell `B1` defined with a formula that depends on `A1`.
+   *
+   * If you find yourself wanting to use `imitate()` with a
+   * MemoryStream, you should rework your code around `imitate()` to use a
+   * Stream instead. Look for the stream in the circular dependency that
+   * represents an event stream, and that would be a candidate for creating a
+   * proxy Stream which then imitates the target Stream.
+   *
+   * @param {Stream} target The other stream to imitate on the current one. Must
+   * not be a MemoryStream.
+   */
+  imitate(target: Stream<T>): void;
+  /**
+   * Forces the Stream to emit the given value to its listeners.
+   *
+   * As the name indicates, if you use this, you are most likely doing something
+   * The Wrong Way. Please try to understand the reactive way before using this
+   * method. Use it only when you know what you are doing.
+   *
+   * @param value The "next" value you want to broadcast to all listeners of
+   * this Stream.
+   */
+  shamefullySendNext(value: T): void;
+  /**
+   * Forces the Stream to emit the given error to its listeners.
+   *
+   * As the name indicates, if you use this, you are most likely doing something
+   * The Wrong Way. Please try to understand the reactive way before using this
+   * method. Use it only when you know what you are doing.
+   *
+   * @param {any} error The error you want to broadcast to all the listeners of
+   * this Stream.
+   */
+  shamefullySendError(error: any): void;
+  /**
+   * Forces the Stream to emit the "completed" event to its listeners.
+   *
+   * As the name indicates, if you use this, you are most likely doing something
+   * The Wrong Way. Please try to understand the reactive way before using this
+   * method. Use it only when you know what you are doing.
+   */
+  shamefullySendComplete(): void;
+  /**
+   * Adds a "debug" listener to the stream. There can only be one debug
+   * listener, that's why this is 'setDebugListener'. To remove the debug
+   * listener, just call setDebugListener(null).
+   *
+   * A debug listener is like any other listener. The only difference is that a
+   * debug listener is "stealthy": its presence/absence does not trigger the
+   * start/stop of the stream (or the producer inside the stream). This is
+   * useful so you can inspect what is going on without changing the behavior
+   * of the program. If you have an idle stream and you add a normal listener to
+   * it, the stream will start executing. But if you set a debug listener on an
+   * idle stream, it won't start executing (not until the first normal listener
+   * is added).
+   *
+   * As the name indicates, we don't recommend using this method to build app
+   * logic. In fact, in most cases the debug operator works just fine. Only use
+   * this one if you know what you're doing.
+   *
+   * @param {Listener<T>} listener
+   */
+  setDebugListener(listener: Partial<Listener<T>> | null | undefined): void;
+}
+declare class MemoryStream<T> extends Stream<T> {
+  private _v?;
+  private _has?;
+  constructor(producer: InternalProducer<T>);
+  _n(x: T): void;
+  _add(il: InternalListener<T>): void;
+  _stopNow(): void;
+  _x(): void;
+  map<U>(project: (t: T) => U): MemoryStream<U>;
+  mapTo<U>(projectedValue: U): MemoryStream<U>;
+  take(amount: number): MemoryStream<T>;
+  endWhen(other: Stream<any>): MemoryStream<T>;
+  replaceError(replace: (err: any) => Stream<T>): MemoryStream<T>;
+  remember(): MemoryStream<T>;
+  debug(): MemoryStream<T>;
+  debug(labelOrSpy: string): MemoryStream<T>;
+  debug(labelOrSpy: (t: T) => any): MemoryStream<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+json-rpc@0.33.0/node_modules/@cosmjs/json-rpc/build/compatibility.d.ts
+/**
+ * A single JSON value. This is the missing return type of JSON.parse().
+ */
+type JsonCompatibleValue = JsonCompatibleDictionary | JsonCompatibleArray | string | number | boolean | null;
+/**
+ * An array of JsonCompatibleValue
+ */
+interface JsonCompatibleArray extends ReadonlyArray<JsonCompatibleValue> {}
+/**
+ * A string to json value dictionary.
+ */
+interface JsonCompatibleDictionary {
+  readonly [key: string]: JsonCompatibleValue | readonly JsonCompatibleValue[];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+json-rpc@0.33.0/node_modules/@cosmjs/json-rpc/build/types.d.ts
+type JsonRpcId = number | string;
+interface JsonRpcRequest {
+  readonly jsonrpc: "2.0";
+  readonly id: JsonRpcId;
+  readonly method: string;
+  readonly params: JsonCompatibleArray | JsonCompatibleDictionary;
+}
+interface JsonRpcSuccessResponse {
+  readonly jsonrpc: "2.0";
+  readonly id: JsonRpcId;
+  readonly result: any;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/rpcclients/rpcclient.d.ts
+interface RpcClient {
+  readonly execute: (request: JsonRpcRequest) => Promise<JsonRpcSuccessResponse>;
+  readonly disconnect: () => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/rpcclients/httpclient.d.ts
+interface HttpEndpoint {
+  /**
+   * The URL of the HTTP endpoint.
+   *
+   * For POST APIs like Tendermint RPC in CosmJS,
+   * this is without the method specific paths (e.g. https://cosmoshub-4--rpc--full.datahub.figment.io/)
+   */
+  readonly url: string;
+  /**
+   * HTTP headers that are sent with every request, such as authorization information.
+   */
+  readonly headers: Record<string, string>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/comet38/requests.d.ts
+interface AbciQueryParams$2 {
+  readonly path: string;
+  readonly data: Uint8Array;
+  readonly height?: number;
+  /**
+   * A flag that defines if proofs are included in the response or not.
+   *
+   * Internally this is mapped to the old inverse name `trusted` for Tendermint < 0.26.
+   * Starting with Tendermint 0.26, the default value changed from true to false.
+   */
+  readonly prove?: boolean;
+}
+interface BlockSearchParams$2 {
+  readonly query: string;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface BroadcastTxParams$2 {
+  readonly tx: Uint8Array;
+}
+interface TxParams$2 {
+  readonly hash: Uint8Array;
+  readonly prove?: boolean;
+}
+interface TxSearchParams$2 {
+  readonly query: string;
+  readonly prove?: boolean;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface ValidatorsParams$2 {
+  readonly height?: number;
+  readonly page?: number;
+  readonly per_page?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/types.d.ts
+interface ValidatorEd25519Pubkey {
+  readonly algorithm: "ed25519";
+  readonly data: Uint8Array;
+}
+interface ValidatorSecp256k1Pubkey {
+  readonly algorithm: "secp256k1";
+  readonly data: Uint8Array;
+}
+/**
+ * Union type for different possible pubkeys.
+ */
+type ValidatorPubkey = ValidatorEd25519Pubkey | ValidatorSecp256k1Pubkey;
+declare enum BlockIdFlag {
+  Unknown = 0,
+  Absent = 1,
+  Commit = 2,
+  Nil = 3,
+  Unrecognized = -1,
+}
+interface CommitSignature {
+  /** If this is BlockIdFlag.Absent, all other fields are expected to be unset */
+  blockIdFlag: BlockIdFlag;
+  validatorAddress: Uint8Array | undefined;
+  timestamp: ReadonlyDateWithNanoseconds | undefined;
+  signature: Uint8Array | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/comet38/responses.d.ts
+interface AbciInfoResponse$2 {
+  readonly data?: string;
+  readonly lastBlockHeight?: number;
+  readonly lastBlockAppHash?: Uint8Array;
+}
+interface ProofOp$2 {
+  readonly type: string;
+  readonly key: Uint8Array;
+  readonly data: Uint8Array;
+}
+interface QueryProof$2 {
+  readonly ops: readonly ProofOp$2[];
+}
+interface AbciQueryResponse$2 {
+  readonly key: Uint8Array;
+  readonly value: Uint8Array;
+  readonly proof?: QueryProof$2;
+  readonly height?: number;
+  readonly index?: number;
+  readonly code?: number;
+  readonly codespace: string;
+  readonly log?: string;
+  readonly info: string;
+}
+interface BlockResponse$2 {
+  readonly blockId: BlockId$2;
+  readonly block: Block$2;
+}
+interface BlockResultsResponse$2 {
+  readonly height: number;
+  readonly results: readonly TxData$2[];
+  readonly validatorUpdates: readonly ValidatorUpdate$2[];
+  readonly consensusUpdates?: ConsensusParams$2;
+  readonly beginBlockEvents: readonly Event$2[];
+  readonly endBlockEvents: readonly Event$2[];
+}
+interface BlockSearchResponse$2 {
+  readonly blocks: readonly BlockResponse$2[];
+  readonly totalCount: number;
+}
+interface BlockchainResponse$2 {
+  readonly lastHeight: number;
+  readonly blockMetas: readonly BlockMeta$2[];
+}
+/**
+ * No transaction data in here because RPC method BroadcastTxAsync "returns right away, with no response"
+ */
+interface BroadcastTxAsyncResponse$2 {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxSyncResponse$2 extends TxData$2 {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxCommitResponse$2 {
+  readonly height: number;
+  readonly hash: Uint8Array;
+  readonly checkTx: TxData$2;
+  /** @deprecated use txResult. Containes the same data as txResult for now */
+  readonly deliverTx?: TxData$2;
+  readonly txResult?: TxData$2;
+}
+interface CommitResponse$2 {
+  readonly header: Header$2;
+  readonly commit: Commit$2;
+  readonly canonical: boolean;
+}
+interface GenesisResponse$2 {
+  readonly genesisTime: ReadonlyDate;
+  readonly chainId: string;
+  readonly consensusParams: ConsensusParams$2;
+  readonly validators: readonly Validator$2[];
+  readonly appHash: Uint8Array;
+  readonly appState: Record<string, unknown> | undefined;
+}
+type HealthResponse$2 = null;
+interface NumUnconfirmedTxsResponse$2 {
+  readonly total: number;
+  readonly totalBytes: number;
+}
+interface StatusResponse$2 {
+  readonly nodeInfo: NodeInfo$2;
+  readonly syncInfo: SyncInfo$2;
+  readonly validatorInfo: Validator$2;
+}
+/**
+ * A transaction from RPC calls like search.
+ *
+ * Try to keep this compatible to TxEvent
+ */
+interface TxResponse$2 {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly index: number;
+  readonly result: TxData$2;
+  readonly proof?: TxProof$2;
+}
+interface TxSearchResponse$2 {
+  readonly txs: readonly TxResponse$2[];
+  readonly totalCount: number;
+}
+interface ValidatorsResponse$2 {
+  readonly blockHeight: number;
+  readonly validators: readonly Validator$2[];
+  readonly count: number;
+  readonly total: number;
+}
+interface NewBlockEvent$2 extends Block$2 {}
+interface NewBlockHeaderEvent$2 extends Header$2 {}
+interface TxEvent$2 {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly result: TxData$2;
+}
+/**
+ * An event attribute.
+ *
+ * In 0.35 the type of key and value was changed
+ * from bytes to string, such that no base64 encoding is used anymore.
+ */
+interface EventAttribute$1 {
+  readonly key: string;
+  readonly value: string;
+}
+interface Event$2 {
+  readonly type: string;
+  readonly attributes: readonly EventAttribute$1[];
+}
+interface TxData$2 {
+  readonly code: number;
+  readonly codespace?: string;
+  readonly log?: string;
+  readonly data?: Uint8Array;
+  readonly events: readonly Event$2[];
+  readonly gasWanted: bigint;
+  readonly gasUsed: bigint;
+}
+interface TxProof$2 {
+  readonly data: Uint8Array;
+  readonly rootHash: Uint8Array;
+  readonly proof: {
+    readonly total: number;
+    readonly index: number;
+    readonly leafHash: Uint8Array;
+    readonly aunts: readonly Uint8Array[];
+  };
+}
+interface BlockMeta$2 {
+  readonly blockId: BlockId$2;
+  readonly blockSize: number;
+  readonly header: Header$2;
+  readonly numTxs: number;
+}
+interface BlockId$2 {
+  readonly hash: Uint8Array;
+  readonly parts: {
+    readonly total: number;
+    readonly hash: Uint8Array;
+  };
+}
+interface Block$2 {
+  readonly header: Header$2;
+  /**
+   * For the block at height 1, last commit is not set.
+   */
+  readonly lastCommit: Commit$2 | null;
+  readonly txs: readonly Uint8Array[];
+  readonly evidence: readonly Evidence$2[];
+}
+/**
+ * We lost track on how the evidence structure actually looks like.
+ * This is any now and passed to the caller untouched.
+ *
+ * See also https://github.com/cosmos/cosmjs/issues/980.
+ */
+type Evidence$2 = any;
+interface Commit$2 {
+  readonly blockId: BlockId$2;
+  readonly height: number;
+  readonly round: number;
+  readonly signatures: readonly CommitSignature[];
+}
+interface Version$2 {
+  readonly block: number;
+  readonly app: number;
+}
+interface Header$2 {
+  readonly version: Version$2;
+  readonly chainId: string;
+  readonly height: number;
+  readonly time: ReadonlyDateWithNanoseconds;
+  /**
+   * Block ID of the previous block. This can be `null` when the currect block is height 1.
+   */
+  readonly lastBlockId: BlockId$2 | null;
+  /**
+   * Hashes of block data.
+   *
+   * This is `sha256("")` for height 1 🤷‍
+   */
+  readonly lastCommitHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly dataHash: Uint8Array;
+  readonly validatorsHash: Uint8Array;
+  readonly nextValidatorsHash: Uint8Array;
+  readonly consensusHash: Uint8Array;
+  /**
+   * This can be an empty string for height 1 and turn into "0000000000000000" later on 🤷‍
+   */
+  readonly appHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly lastResultsHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly evidenceHash: Uint8Array;
+  readonly proposerAddress: Uint8Array;
+}
+interface NodeInfo$2 {
+  readonly id: Uint8Array;
+  /** IP and port */
+  readonly listenAddr: string;
+  readonly network: string;
+  /**
+   * The Tendermint version. Can be empty (see https://github.com/cosmos/cosmos-sdk/issues/7963).
+   */
+  readonly version: string;
+  readonly channels: string;
+  readonly moniker: string;
+  readonly other: Map<string, string>;
+  readonly protocolVersion: {
+    readonly p2p: number;
+    readonly block: number;
+    readonly app: number;
+  };
+}
+interface SyncInfo$2 {
+  readonly earliestAppHash?: Uint8Array;
+  readonly earliestBlockHash?: Uint8Array;
+  readonly earliestBlockHeight?: number;
+  readonly earliestBlockTime?: ReadonlyDate;
+  readonly latestBlockHash: Uint8Array;
+  readonly latestAppHash: Uint8Array;
+  readonly latestBlockHeight: number;
+  readonly latestBlockTime: ReadonlyDate;
+  readonly catchingUp: boolean;
+}
+interface Validator$2 {
+  readonly address: Uint8Array;
+  readonly pubkey?: ValidatorPubkey;
+  readonly votingPower: bigint;
+  readonly proposerPriority?: number;
+}
+interface ValidatorUpdate$2 {
+  readonly pubkey: ValidatorPubkey;
+  readonly votingPower: bigint;
+}
+interface ConsensusParams$2 {
+  readonly block: BlockParams$2;
+  readonly evidence: EvidenceParams$2;
+}
+interface BlockParams$2 {
+  readonly maxBytes: number;
+  readonly maxGas: number;
+}
+interface EvidenceParams$2 {
+  readonly maxAgeNumBlocks: number;
+  readonly maxAgeDuration: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/comet38/comet38client.d.ts
+declare class Comet38Client {
+  /**
+   * Creates a new Tendermint client for the given endpoint.
+   *
+   * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+   */
+  static connect(endpoint: string | HttpEndpoint): Promise<Comet38Client>;
+  /**
+   * Creates a new Tendermint client given an RPC client.
+   */
+  static create(rpcClient: RpcClient): Promise<Comet38Client>;
+  private static detectVersion;
+  private readonly client;
+  /**
+   * Use `Tendermint37Client.connect` or `Tendermint37Client.create` to create an instance.
+   */
+  private constructor();
+  disconnect(): void;
+  abciInfo(): Promise<AbciInfoResponse$2>;
+  abciQuery(params: AbciQueryParams$2): Promise<AbciQueryResponse$2>;
+  block(height?: number): Promise<BlockResponse$2>;
+  blockResults(height?: number): Promise<BlockResultsResponse$2>;
+  /**
+   * Search for events that are in a block.
+   *
+   * NOTE
+   * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+   */
+  blockSearch(params: BlockSearchParams$2): Promise<BlockSearchResponse$2>;
+  blockSearchAll(params: BlockSearchParams$2): Promise<BlockSearchResponse$2>;
+  /**
+   * Queries block headers filtered by minHeight <= height <= maxHeight.
+   *
+   * @param minHeight The minimum height to be included in the result. Defaults to 0.
+   * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+   */
+  blockchain(minHeight?: number, maxHeight?: number): Promise<BlockchainResponse$2>;
+  /**
+   * Broadcast transaction to mempool and wait for response
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+   */
+  broadcastTxSync(params: BroadcastTxParams$2): Promise<BroadcastTxSyncResponse$2>;
+  /**
+   * Broadcast transaction to mempool and do not wait for result
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+   */
+  broadcastTxAsync(params: BroadcastTxParams$2): Promise<BroadcastTxAsyncResponse$2>;
+  /**
+   * Broadcast transaction to mempool and wait for block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+   */
+  broadcastTxCommit(params: BroadcastTxParams$2): Promise<BroadcastTxCommitResponse$2>;
+  commit(height?: number): Promise<CommitResponse$2>;
+  genesis(): Promise<GenesisResponse$2>;
+  health(): Promise<HealthResponse$2>;
+  numUnconfirmedTxs(): Promise<NumUnconfirmedTxsResponse$2>;
+  status(): Promise<StatusResponse$2>;
+  subscribeNewBlock(): Stream<NewBlockEvent$2>;
+  subscribeNewBlockHeader(): Stream<NewBlockHeaderEvent$2>;
+  subscribeTx(query?: string): Stream<TxEvent$2>;
+  /**
+   * Get a single transaction by hash
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+   */
+  tx(params: TxParams$2): Promise<TxResponse$2>;
+  /**
+   * Search for transactions that are in a block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+   */
+  txSearch(params: TxSearchParams$2): Promise<TxSearchResponse$2>;
+  txSearchAll(params: TxSearchParams$2): Promise<TxSearchResponse$2>;
+  validators(params: ValidatorsParams$2): Promise<ValidatorsResponse$2>;
+  validatorsAll(height?: number): Promise<ValidatorsResponse$2>;
+  private doCall;
+  private subscribe;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint34/requests.d.ts
+interface AbciQueryParams$1 {
+  readonly path: string;
+  readonly data: Uint8Array;
+  readonly height?: number;
+  /**
+   * A flag that defines if proofs are included in the response or not.
+   *
+   * Internally this is mapped to the old inverse name `trusted` for Tendermint < 0.26.
+   * Starting with Tendermint 0.26, the default value changed from true to false.
+   */
+  readonly prove?: boolean;
+}
+interface BlockSearchParams$1 {
+  readonly query: string;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface BroadcastTxParams$1 {
+  readonly tx: Uint8Array;
+}
+interface TxParams$1 {
+  readonly hash: Uint8Array;
+  readonly prove?: boolean;
+}
+interface TxSearchParams$1 {
+  readonly query: string;
+  readonly prove?: boolean;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface ValidatorsParams$1 {
+  readonly height?: number;
+  readonly page?: number;
+  readonly per_page?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint34/responses.d.ts
+interface AbciInfoResponse$1 {
+  readonly data?: string;
+  readonly lastBlockHeight?: number;
+  readonly lastBlockAppHash?: Uint8Array;
+}
+interface ProofOp$1 {
+  readonly type: string;
+  readonly key: Uint8Array;
+  readonly data: Uint8Array;
+}
+interface QueryProof$1 {
+  readonly ops: readonly ProofOp$1[];
+}
+interface AbciQueryResponse$1 {
+  readonly key: Uint8Array;
+  readonly value: Uint8Array;
+  readonly proof?: QueryProof$1;
+  readonly height?: number;
+  readonly index?: number;
+  readonly code?: number;
+  readonly codespace: string;
+  readonly log?: string;
+  readonly info: string;
+}
+interface BlockResponse$1 {
+  readonly blockId: BlockId$1;
+  readonly block: Block$1;
+}
+interface BlockResultsResponse$1 {
+  readonly height: number;
+  readonly results: readonly TxData$1[];
+  readonly validatorUpdates: readonly ValidatorUpdate$1[];
+  readonly consensusUpdates?: ConsensusParams$1;
+  readonly beginBlockEvents: readonly Event$1[];
+  readonly endBlockEvents: readonly Event$1[];
+}
+interface BlockSearchResponse$1 {
+  readonly blocks: readonly BlockResponse$1[];
+  readonly totalCount: number;
+}
+interface BlockchainResponse$1 {
+  readonly lastHeight: number;
+  readonly blockMetas: readonly BlockMeta$1[];
+}
+/**
+ * No transaction data in here because RPC method BroadcastTxAsync "returns right away, with no response"
+ */
+interface BroadcastTxAsyncResponse$1 {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxSyncResponse$1 extends TxData$1 {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxCommitResponse$1 {
+  readonly height: number;
+  readonly hash: Uint8Array;
+  readonly checkTx: TxData$1;
+  readonly deliverTx?: TxData$1;
+}
+interface CommitResponse$1 {
+  readonly header: Header$1;
+  readonly commit: Commit$1;
+  readonly canonical: boolean;
+}
+interface GenesisResponse$1 {
+  readonly genesisTime: ReadonlyDate;
+  readonly chainId: string;
+  readonly consensusParams: ConsensusParams$1;
+  readonly validators: readonly Validator$1[];
+  readonly appHash: Uint8Array;
+  readonly appState: Record<string, unknown> | undefined;
+}
+type HealthResponse$1 = null;
+interface NumUnconfirmedTxsResponse$1 {
+  readonly total: number;
+  readonly totalBytes: number;
+}
+interface StatusResponse$1 {
+  readonly nodeInfo: NodeInfo$1;
+  readonly syncInfo: SyncInfo$1;
+  readonly validatorInfo: Validator$1;
+}
+/**
+ * A transaction from RPC calls like search.
+ *
+ * Try to keep this compatible to TxEvent
+ */
+interface TxResponse$1 {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly index: number;
+  readonly result: TxData$1;
+  readonly proof?: TxProof$1;
+}
+interface TxSearchResponse$1 {
+  readonly txs: readonly TxResponse$1[];
+  readonly totalCount: number;
+}
+interface ValidatorsResponse$1 {
+  readonly blockHeight: number;
+  readonly validators: readonly Validator$1[];
+  readonly count: number;
+  readonly total: number;
+}
+interface NewBlockEvent$1 extends Block$1 {}
+interface NewBlockHeaderEvent$1 extends Header$1 {}
+interface TxEvent$1 {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly result: TxData$1;
+}
+/** An event attribute */
+interface Attribute {
+  readonly key: Uint8Array;
+  readonly value: Uint8Array;
+}
+interface Event$1 {
+  readonly type: string;
+  readonly attributes: readonly Attribute[];
+}
+interface TxData$1 {
+  readonly code: number;
+  readonly codespace?: string;
+  readonly log?: string;
+  readonly data?: Uint8Array;
+  readonly events: readonly Event$1[];
+  readonly gasWanted: bigint;
+  readonly gasUsed: bigint;
+}
+interface TxProof$1 {
+  readonly data: Uint8Array;
+  readonly rootHash: Uint8Array;
+  readonly proof: {
+    readonly total: number;
+    readonly index: number;
+    readonly leafHash: Uint8Array;
+    readonly aunts: readonly Uint8Array[];
+  };
+}
+interface BlockMeta$1 {
+  readonly blockId: BlockId$1;
+  readonly blockSize: number;
+  readonly header: Header$1;
+  readonly numTxs: number;
+}
+interface BlockId$1 {
+  readonly hash: Uint8Array;
+  readonly parts: {
+    readonly total: number;
+    readonly hash: Uint8Array;
+  };
+}
+interface Block$1 {
+  readonly header: Header$1;
+  /**
+   * For the block at height 1, last commit is not set.
+   */
+  readonly lastCommit: Commit$1 | null;
+  readonly txs: readonly Uint8Array[];
+  readonly evidence: readonly Evidence$1[];
+}
+/**
+ * We lost track on how the evidence structure actually looks like.
+ * This is any now and passed to the caller untouched.
+ *
+ * See also https://github.com/cosmos/cosmjs/issues/980.
+ */
+type Evidence$1 = any;
+interface Commit$1 {
+  readonly blockId: BlockId$1;
+  readonly height: number;
+  readonly round: number;
+  readonly signatures: readonly CommitSignature[];
+}
+interface Version$1 {
+  readonly block: number;
+  readonly app: number;
+}
+interface Header$1 {
+  readonly version: Version$1;
+  readonly chainId: string;
+  readonly height: number;
+  readonly time: ReadonlyDateWithNanoseconds;
+  /**
+   * Block ID of the previous block. This can be `null` when the currect block is height 1.
+   */
+  readonly lastBlockId: BlockId$1 | null;
+  /**
+   * Hashes of block data.
+   *
+   * This is `sha256("")` for height 1 🤷‍
+   */
+  readonly lastCommitHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly dataHash: Uint8Array;
+  readonly validatorsHash: Uint8Array;
+  readonly nextValidatorsHash: Uint8Array;
+  readonly consensusHash: Uint8Array;
+  /**
+   * This can be an empty string for height 1 and turn into "0000000000000000" later on 🤷‍
+   */
+  readonly appHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly lastResultsHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly evidenceHash: Uint8Array;
+  readonly proposerAddress: Uint8Array;
+}
+interface NodeInfo$1 {
+  readonly id: Uint8Array;
+  /** IP and port */
+  readonly listenAddr: string;
+  readonly network: string;
+  /**
+   * The Tendermint version. Can be empty (see https://github.com/cosmos/cosmos-sdk/issues/7963).
+   */
+  readonly version: string;
+  readonly channels: string;
+  readonly moniker: string;
+  readonly other: Map<string, string>;
+  readonly protocolVersion: {
+    readonly p2p: number;
+    readonly block: number;
+    readonly app: number;
+  };
+}
+interface SyncInfo$1 {
+  readonly earliestAppHash?: Uint8Array;
+  readonly earliestBlockHash?: Uint8Array;
+  readonly earliestBlockHeight?: number;
+  readonly earliestBlockTime?: ReadonlyDate;
+  readonly latestBlockHash: Uint8Array;
+  readonly latestAppHash: Uint8Array;
+  readonly latestBlockHeight: number;
+  readonly latestBlockTime: ReadonlyDate;
+  readonly catchingUp: boolean;
+}
+interface Validator$1 {
+  readonly address: Uint8Array;
+  readonly pubkey?: ValidatorPubkey;
+  readonly votingPower: bigint;
+  readonly proposerPriority?: number;
+}
+interface ValidatorUpdate$1 {
+  readonly pubkey: ValidatorPubkey;
+  readonly votingPower: bigint;
+}
+interface ConsensusParams$1 {
+  readonly block: BlockParams$1;
+  readonly evidence: EvidenceParams$1;
+}
+interface BlockParams$1 {
+  readonly maxBytes: number;
+  readonly maxGas: number;
+}
+interface EvidenceParams$1 {
+  readonly maxAgeNumBlocks: number;
+  readonly maxAgeDuration: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint34/tendermint34client.d.ts
+declare class Tendermint34Client {
+  /**
+   * Creates a new Tendermint client for the given endpoint.
+   *
+   * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+   */
+  static connect(endpoint: string | HttpEndpoint): Promise<Tendermint34Client>;
+  /**
+   * Creates a new Tendermint client given an RPC client.
+   */
+  static create(rpcClient: RpcClient): Promise<Tendermint34Client>;
+  private static detectVersion;
+  private readonly client;
+  /**
+   * Use `Tendermint34Client.connect` or `Tendermint34Client.create` to create an instance.
+   */
+  private constructor();
+  disconnect(): void;
+  abciInfo(): Promise<AbciInfoResponse$1>;
+  abciQuery(params: AbciQueryParams$1): Promise<AbciQueryResponse$1>;
+  block(height?: number): Promise<BlockResponse$1>;
+  blockResults(height?: number): Promise<BlockResultsResponse$1>;
+  /**
+   * Search for events that are in a block.
+   *
+   * NOTE
+   * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+   */
+  blockSearch(params: BlockSearchParams$1): Promise<BlockSearchResponse$1>;
+  blockSearchAll(params: BlockSearchParams$1): Promise<BlockSearchResponse$1>;
+  /**
+   * Queries block headers filtered by minHeight <= height <= maxHeight.
+   *
+   * @param minHeight The minimum height to be included in the result. Defaults to 0.
+   * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+   */
+  blockchain(minHeight?: number, maxHeight?: number): Promise<BlockchainResponse$1>;
+  /**
+   * Broadcast transaction to mempool and wait for response
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+   */
+  broadcastTxSync(params: BroadcastTxParams$1): Promise<BroadcastTxSyncResponse$1>;
+  /**
+   * Broadcast transaction to mempool and do not wait for result
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+   */
+  broadcastTxAsync(params: BroadcastTxParams$1): Promise<BroadcastTxAsyncResponse$1>;
+  /**
+   * Broadcast transaction to mempool and wait for block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+   */
+  broadcastTxCommit(params: BroadcastTxParams$1): Promise<BroadcastTxCommitResponse$1>;
+  commit(height?: number): Promise<CommitResponse$1>;
+  genesis(): Promise<GenesisResponse$1>;
+  health(): Promise<HealthResponse$1>;
+  numUnconfirmedTxs(): Promise<NumUnconfirmedTxsResponse$1>;
+  status(): Promise<StatusResponse$1>;
+  subscribeNewBlock(): Stream<NewBlockEvent$1>;
+  subscribeNewBlockHeader(): Stream<NewBlockHeaderEvent$1>;
+  subscribeTx(query?: string): Stream<TxEvent$1>;
+  /**
+   * Get a single transaction by hash
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+   */
+  tx(params: TxParams$1): Promise<TxResponse$1>;
+  /**
+   * Search for transactions that are in a block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+   */
+  txSearch(params: TxSearchParams$1): Promise<TxSearchResponse$1>;
+  txSearchAll(params: TxSearchParams$1): Promise<TxSearchResponse$1>;
+  validators(params: ValidatorsParams$1): Promise<ValidatorsResponse$1>;
+  validatorsAll(height?: number): Promise<ValidatorsResponse$1>;
+  private doCall;
+  private subscribe;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint37/requests.d.ts
+interface AbciQueryParams {
+  readonly path: string;
+  readonly data: Uint8Array;
+  readonly height?: number;
+  /**
+   * A flag that defines if proofs are included in the response or not.
+   *
+   * Internally this is mapped to the old inverse name `trusted` for Tendermint < 0.26.
+   * Starting with Tendermint 0.26, the default value changed from true to false.
+   */
+  readonly prove?: boolean;
+}
+interface BlockSearchParams {
+  readonly query: string;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface BroadcastTxParams {
+  readonly tx: Uint8Array;
+}
+interface TxParams {
+  readonly hash: Uint8Array;
+  readonly prove?: boolean;
+}
+interface TxSearchParams {
+  readonly query: string;
+  readonly prove?: boolean;
+  readonly page?: number;
+  readonly per_page?: number;
+  readonly order_by?: string;
+}
+interface ValidatorsParams {
+  readonly height?: number;
+  readonly page?: number;
+  readonly per_page?: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint37/responses.d.ts
+interface AbciInfoResponse {
+  readonly data?: string;
+  readonly lastBlockHeight?: number;
+  readonly lastBlockAppHash?: Uint8Array;
+}
+interface ProofOp {
+  readonly type: string;
+  readonly key: Uint8Array;
+  readonly data: Uint8Array;
+}
+interface QueryProof {
+  readonly ops: readonly ProofOp[];
+}
+interface AbciQueryResponse {
+  readonly key: Uint8Array;
+  readonly value: Uint8Array;
+  readonly proof?: QueryProof;
+  readonly height?: number;
+  readonly index?: number;
+  readonly code?: number;
+  readonly codespace: string;
+  readonly log?: string;
+  readonly info: string;
+}
+interface BlockResponse {
+  readonly blockId: BlockId;
+  readonly block: Block;
+}
+interface BlockResultsResponse {
+  readonly height: number;
+  readonly results: readonly TxData[];
+  readonly validatorUpdates: readonly ValidatorUpdate[];
+  readonly consensusUpdates?: ConsensusParams;
+  readonly beginBlockEvents: readonly Event[];
+  readonly endBlockEvents: readonly Event[];
+}
+interface BlockSearchResponse {
+  readonly blocks: readonly BlockResponse[];
+  readonly totalCount: number;
+}
+interface BlockchainResponse {
+  readonly lastHeight: number;
+  readonly blockMetas: readonly BlockMeta[];
+}
+/**
+ * No transaction data in here because RPC method BroadcastTxAsync "returns right away, with no response"
+ */
+interface BroadcastTxAsyncResponse {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxSyncResponse extends TxData {
+  readonly hash: Uint8Array;
+}
+interface BroadcastTxCommitResponse {
+  readonly height: number;
+  readonly hash: Uint8Array;
+  readonly checkTx: TxData;
+  readonly deliverTx?: TxData;
+}
+interface CommitResponse {
+  readonly header: Header;
+  readonly commit: Commit;
+  readonly canonical: boolean;
+}
+interface GenesisResponse {
+  readonly genesisTime: ReadonlyDate;
+  readonly chainId: string;
+  readonly consensusParams: ConsensusParams;
+  readonly validators: readonly Validator[];
+  readonly appHash: Uint8Array;
+  readonly appState: Record<string, unknown> | undefined;
+}
+type HealthResponse = null;
+interface NumUnconfirmedTxsResponse {
+  readonly total: number;
+  readonly totalBytes: number;
+}
+interface StatusResponse {
+  readonly nodeInfo: NodeInfo;
+  readonly syncInfo: SyncInfo;
+  readonly validatorInfo: Validator;
+}
+/**
+ * A transaction from RPC calls like search.
+ *
+ * Try to keep this compatible to TxEvent
+ */
+interface TxResponse {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly index: number;
+  readonly result: TxData;
+  readonly proof?: TxProof;
+}
+interface TxSearchResponse {
+  readonly txs: readonly TxResponse[];
+  readonly totalCount: number;
+}
+interface ValidatorsResponse {
+  readonly blockHeight: number;
+  readonly validators: readonly Validator[];
+  readonly count: number;
+  readonly total: number;
+}
+interface NewBlockEvent extends Block {}
+interface NewBlockHeaderEvent extends Header {}
+interface TxEvent {
+  readonly tx: Uint8Array;
+  readonly hash: Uint8Array;
+  readonly height: number;
+  readonly result: TxData;
+}
+/**
+ * An event attribute.
+ *
+ * In 0.35 the type of key and value was changed
+ * from bytes to string, such that no base64 encoding is used anymore.
+ */
+interface EventAttribute {
+  readonly key: string;
+  readonly value: string;
+}
+interface Event {
+  readonly type: string;
+  readonly attributes: readonly EventAttribute[];
+}
+interface TxData {
+  readonly code: number;
+  readonly codespace?: string;
+  readonly log?: string;
+  readonly data?: Uint8Array;
+  readonly events: readonly Event[];
+  readonly gasWanted: bigint;
+  readonly gasUsed: bigint;
+}
+interface TxProof {
+  readonly data: Uint8Array;
+  readonly rootHash: Uint8Array;
+  readonly proof: {
+    readonly total: number;
+    readonly index: number;
+    readonly leafHash: Uint8Array;
+    readonly aunts: readonly Uint8Array[];
+  };
+}
+interface BlockMeta {
+  readonly blockId: BlockId;
+  readonly blockSize: number;
+  readonly header: Header;
+  readonly numTxs: number;
+}
+interface BlockId {
+  readonly hash: Uint8Array;
+  readonly parts: {
+    readonly total: number;
+    readonly hash: Uint8Array;
+  };
+}
+interface Block {
+  readonly header: Header;
+  /**
+   * For the block at height 1, last commit is not set.
+   */
+  readonly lastCommit: Commit | null;
+  readonly txs: readonly Uint8Array[];
+  readonly evidence: readonly Evidence[];
+}
+/**
+ * We lost track on how the evidence structure actually looks like.
+ * This is any now and passed to the caller untouched.
+ *
+ * See also https://github.com/cosmos/cosmjs/issues/980.
+ */
+type Evidence = any;
+interface Commit {
+  readonly blockId: BlockId;
+  readonly height: number;
+  readonly round: number;
+  readonly signatures: readonly CommitSignature[];
+}
+interface Version {
+  readonly block: number;
+  readonly app: number;
+}
+interface Header {
+  readonly version: Version;
+  readonly chainId: string;
+  readonly height: number;
+  readonly time: ReadonlyDateWithNanoseconds;
+  /**
+   * Block ID of the previous block. This can be `null` when the currect block is height 1.
+   */
+  readonly lastBlockId: BlockId | null;
+  /**
+   * Hashes of block data.
+   *
+   * This is `sha256("")` for height 1 🤷‍
+   */
+  readonly lastCommitHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly dataHash: Uint8Array;
+  readonly validatorsHash: Uint8Array;
+  readonly nextValidatorsHash: Uint8Array;
+  readonly consensusHash: Uint8Array;
+  /**
+   * This can be an empty string for height 1 and turn into "0000000000000000" later on 🤷‍
+   */
+  readonly appHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly lastResultsHash: Uint8Array;
+  /**
+   * This is `sha256("")` as long as there is no data 🤷‍
+   */
+  readonly evidenceHash: Uint8Array;
+  readonly proposerAddress: Uint8Array;
+}
+interface NodeInfo {
+  readonly id: Uint8Array;
+  /** IP and port */
+  readonly listenAddr: string;
+  readonly network: string;
+  /**
+   * The Tendermint version. Can be empty (see https://github.com/cosmos/cosmos-sdk/issues/7963).
+   */
+  readonly version: string;
+  readonly channels: string;
+  readonly moniker: string;
+  readonly other: Map<string, string>;
+  readonly protocolVersion: {
+    readonly p2p: number;
+    readonly block: number;
+    readonly app: number;
+  };
+}
+interface SyncInfo {
+  readonly earliestAppHash?: Uint8Array;
+  readonly earliestBlockHash?: Uint8Array;
+  readonly earliestBlockHeight?: number;
+  readonly earliestBlockTime?: ReadonlyDate;
+  readonly latestBlockHash: Uint8Array;
+  readonly latestAppHash: Uint8Array;
+  readonly latestBlockHeight: number;
+  readonly latestBlockTime: ReadonlyDate;
+  readonly catchingUp: boolean;
+}
+interface Validator {
+  readonly address: Uint8Array;
+  readonly pubkey?: ValidatorPubkey;
+  readonly votingPower: bigint;
+  readonly proposerPriority?: number;
+}
+interface ValidatorUpdate {
+  readonly pubkey: ValidatorPubkey;
+  readonly votingPower: bigint;
+}
+interface ConsensusParams {
+  readonly block: BlockParams;
+  readonly evidence: EvidenceParams;
+}
+interface BlockParams {
+  readonly maxBytes: number;
+  readonly maxGas: number;
+}
+interface EvidenceParams {
+  readonly maxAgeNumBlocks: number;
+  readonly maxAgeDuration: number;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermint37/tendermint37client.d.ts
+declare class Tendermint37Client {
+  /**
+   * Creates a new Tendermint client for the given endpoint.
+   *
+   * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+   */
+  static connect(endpoint: string | HttpEndpoint): Promise<Tendermint37Client>;
+  /**
+   * Creates a new Tendermint client given an RPC client.
+   */
+  static create(rpcClient: RpcClient): Promise<Tendermint37Client>;
+  private static detectVersion;
+  private readonly client;
+  /**
+   * Use `Tendermint37Client.connect` or `Tendermint37Client.create` to create an instance.
+   */
+  private constructor();
+  disconnect(): void;
+  abciInfo(): Promise<AbciInfoResponse>;
+  abciQuery(params: AbciQueryParams): Promise<AbciQueryResponse>;
+  block(height?: number): Promise<BlockResponse>;
+  blockResults(height?: number): Promise<BlockResultsResponse>;
+  /**
+   * Search for events that are in a block.
+   *
+   * NOTE
+   * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+   */
+  blockSearch(params: BlockSearchParams): Promise<BlockSearchResponse>;
+  blockSearchAll(params: BlockSearchParams): Promise<BlockSearchResponse>;
+  /**
+   * Queries block headers filtered by minHeight <= height <= maxHeight.
+   *
+   * @param minHeight The minimum height to be included in the result. Defaults to 0.
+   * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+   */
+  blockchain(minHeight?: number, maxHeight?: number): Promise<BlockchainResponse>;
+  /**
+   * Broadcast transaction to mempool and wait for response
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+   */
+  broadcastTxSync(params: BroadcastTxParams): Promise<BroadcastTxSyncResponse>;
+  /**
+   * Broadcast transaction to mempool and do not wait for result
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+   */
+  broadcastTxAsync(params: BroadcastTxParams): Promise<BroadcastTxAsyncResponse>;
+  /**
+   * Broadcast transaction to mempool and wait for block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+   */
+  broadcastTxCommit(params: BroadcastTxParams): Promise<BroadcastTxCommitResponse>;
+  commit(height?: number): Promise<CommitResponse>;
+  genesis(): Promise<GenesisResponse>;
+  health(): Promise<HealthResponse>;
+  numUnconfirmedTxs(): Promise<NumUnconfirmedTxsResponse>;
+  status(): Promise<StatusResponse>;
+  subscribeNewBlock(): Stream<NewBlockEvent>;
+  subscribeNewBlockHeader(): Stream<NewBlockHeaderEvent>;
+  subscribeTx(query?: string): Stream<TxEvent>;
+  /**
+   * Get a single transaction by hash
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+   */
+  tx(params: TxParams): Promise<TxResponse>;
+  /**
+   * Search for transactions that are in a block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+   */
+  txSearch(params: TxSearchParams): Promise<TxSearchResponse>;
+  txSearchAll(params: TxSearchParams): Promise<TxSearchResponse>;
+  validators(params: ValidatorsParams): Promise<ValidatorsResponse>;
+  validatorsAll(height?: number): Promise<ValidatorsResponse>;
+  private doCall;
+  private subscribe;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@cosmjs+tendermint-rpc@0.33.0_bufferutil@4.0.7_utf-8-validate@5.0.10/node_modules/@cosmjs/tendermint-rpc/build/tendermintclient.d.ts
+/** A CometClient is either a Tendermint34Client, Tendermint37Client or a Comet38Client */
+type CometClient = Tendermint34Client | Tendermint37Client | Comet38Client;
+//#endregion
+//#region src/core/stargate/SigningStargateClient.d.ts
+/**
+ * Signing information for a single signer that is not included in the transaction.
+ *
+ * @see https://github.com/cosmos/cosmos-sdk/blob/v0.42.2/x/auth/signing/sign_mode_handler.go#L23-L37
+ */
+interface SignerData {
+  readonly accountNumber: number;
+  readonly sequence: number;
+  readonly chainId: string;
+}
+interface SigningStargateClientOptions extends StargateClientOptions {
+  readonly registry?: Registry;
+  readonly aminoTypes?: AminoTypes;
+  readonly broadcastTimeoutMs?: number;
+  readonly broadcastPollIntervalMs?: number;
+  readonly gasPrice?: GasPrice;
+}
+declare class SigningStargateClient extends StargateClient$1 {
+  readonly registry: Registry;
+  readonly broadcastTimeoutMs: number | undefined;
+  readonly broadcastPollIntervalMs: number | undefined;
+  protected readonly signer: OfflineSigner;
+  protected readonly aminoTypes: AminoTypes;
+  protected readonly gasPrice: GasPrice | undefined;
+  /**
+   * Creates an instance by connecting to the given Tendermint RPC endpoint.
+   *
+   * For now this uses the Tendermint 0.34 client. If you need Tendermint 0.37
+   * support, see `createWithSigner`.
+   */
+  static connectWithSigner(endpoint: string | HttpEndpoint, signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+  /**
+   * Creates an instance from a manually created Tendermint client.
+   * Use this to use `Tendermint37Client` instead of `Tendermint37Client`.
+   */
+  static createWithSigner(tmClient: CometClient, signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+  /**
+   * Creates a client in offline mode.
+   *
+   * This should only be used in niche cases where you know exactly what you're doing,
+   * e.g. when building an offline signing application.
+   *
+   * When you try to use online functionality with such a signer, an
+   * exception will be raised.
+   */
+  static offline(signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
+  protected constructor(tmClient: CometClient | undefined, signer: OfflineSigner, options: SigningStargateClientOptions);
+  simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
+  sendTokens(senderAddress: string, recipientAddress: string, amount: readonly Coin[], fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  delegateTokens(delegatorAddress: string, validatorAddress: string, amount: Coin, fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  undelegateTokens(delegatorAddress: string, validatorAddress: string, amount: Coin, fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  withdrawRewards(delegatorAddress: string, validatorAddress: string, fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  sendIbcTokens(senderAddress: string, recipientAddress: string, transferAmount: Coin, sourcePort: string, sourceChannel: string, timeoutHeight: Height | undefined, /** timeout in seconds */
+  timeoutTimestamp: number | undefined, fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee | 'auto' | number, memo?: string): Promise<DeliverTxResponse>;
+  /**
+   * Gets account number and sequence from the API, creates a sign doc,
+   * creates a single signature and assembles the signed transaction.
+   *
+   * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+   *
+   * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+   * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+   * (See the SigningStargateClient.offline constructor).
+   */
+  sign(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, explicitSignerData?: SignerData): Promise<TxRaw>;
+  protected signAmino(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, {
+    accountNumber,
+    sequence,
+    chainId
+  }: SignerData): Promise<TxRaw>;
+  protected signDirect(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo: string, {
+    accountNumber,
+    sequence,
+    chainId
+  }: SignerData): Promise<TxRaw>;
+}
+//#endregion
+//#region src/core/accounts/signers/types/amino-signer.d.ts
+type Algo$3 = Algo$1 | 'eth_secp256k1';
+interface AccountData$3 extends Omit<AccountData$1, 'algo'> {
+  algo: Algo$3;
+}
+interface OfflineAminoSigner$1 extends Omit<OfflineAminoSigner, 'getAccounts'> {
+  readonly getAccounts: () => Promise<readonly AccountData$3[]>;
+}
+//#endregion
+//#region src/core/accounts/signers/EthSecp256k1Wallet.d.ts
+declare class EthSecp256k1Wallet implements OfflineAminoSigner$1 {
+  /**
+   * Creates a EthSecp256k1Wallet from the given private key
+   *
+   * @param privKey The private key.
+   * @param prefix The bech32 address prefix (human readable part). Defaults to "inj".
+   */
+  static fromKey(privKey: Uint8Array, prefix?: string): Promise<EthSecp256k1Wallet>;
+  private readonly privateKey;
+  private readonly publicKey;
+  private readonly prefix;
+  private constructor();
+  private get address();
+  getAccounts(): Promise<readonly AccountData$3[]>;
+  signAmino(signerAddress: string, signDoc: StdSignDoc): Promise<AminoSignResponse>;
+}
+//#endregion
+//#region src/core/accounts/signers/types/proto-signer.d.ts
+type Algo$2 = Algo | 'eth_secp256k1';
+interface AccountData$2 extends Omit<AccountData, 'algo'> {
+  algo: Algo$2;
+}
+interface OfflineDirectSigner$1 extends Omit<OfflineDirectSigner, 'getAccounts'> {
+  readonly getAccounts: () => Promise<readonly AccountData$2[]>;
+}
+//#endregion
+//#region src/core/accounts/signers/DirectEthSecp256k1Wallet.d.ts
+declare class DirectEthSecp256k1Wallet implements OfflineDirectSigner$1 {
+  /**
+   * Creates a DirectEthSecp256k1Wallet from the given private key
+   *
+   * @param privKey The private key.
+   * @param prefix The bech32 address prefix (human readable part). Defaults to "inj".
+   */
+  static fromKey(privKey: Uint8Array, prefix?: string): Promise<DirectEthSecp256k1Wallet>;
+  private readonly privateKey;
+  private readonly publicKey;
+  private readonly prefix;
+  private constructor();
+  private get address();
+  getAccounts(): Promise<readonly AccountData$2[]>;
+  signDirect(address: string, signDoc: Omit<SignDoc, 'accountNumber'> & {
+    accountNumber: bigint;
+  }): Promise<DirectSignResponse>;
+}
+//#endregion
+export { accountParser as a, StargateClient$1 as i, EthSecp256k1Wallet as n, MsgTransferCosmjs as o, SigningStargateClient as r, DirectEthSecp256k1Wallet as t };