@xpla/xplajs 1.7.0-beta.0

package/src/ethermint/feemarket/v1/feemarket.ts

@@ -0,0 +1,213 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** Params defines the EVM module parameters */
+export interface Params {
+  /** no_base_fee forces the EIP-1559 base fee to 0 (needed for 0 price calls) */
+  noBaseFee: boolean;
+  /**
+   * base_fee_change_denominator bounds the amount the base fee can change
+   * between blocks.
+   */
+  baseFeeChangeDenominator: number;
+  /**
+   * elasticity_multiplier bounds the maximum gas limit an EIP-1559 block may
+   * have.
+   */
+  elasticityMultiplier: number;
+  /** enable_height defines at which block height the base fee calculation is enabled. */
+  enableHeight: bigint;
+  /** base_fee for EIP-1559 blocks. */
+  baseFee: string;
+  /** min_gas_price defines the minimum gas price value for cosmos and eth transactions */
+  minGasPrice: string;
+  /**
+   * min_gas_multiplier bounds the minimum gas used to be charged
+   * to senders based on gas limit
+   */
+  minGasMultiplier: string;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/ethermint.feemarket.v1.Params";
+  value: Uint8Array;
+}
+/** Params defines the EVM module parameters */
+export interface ParamsAmino {
+  /** no_base_fee forces the EIP-1559 base fee to 0 (needed for 0 price calls) */
+  no_base_fee: boolean;
+  /**
+   * base_fee_change_denominator bounds the amount the base fee can change
+   * between blocks.
+   */
+  base_fee_change_denominator: number;
+  /**
+   * elasticity_multiplier bounds the maximum gas limit an EIP-1559 block may
+   * have.
+   */
+  elasticity_multiplier: number;
+  /** enable_height defines at which block height the base fee calculation is enabled. */
+  enable_height: string;
+  /** base_fee for EIP-1559 blocks. */
+  base_fee: string;
+  /** min_gas_price defines the minimum gas price value for cosmos and eth transactions */
+  min_gas_price: string;
+  /**
+   * min_gas_multiplier bounds the minimum gas used to be charged
+   * to senders based on gas limit
+   */
+  min_gas_multiplier: string;
+}
+export interface ParamsAminoMsg {
+  type: "ethermint/x/feemarket/Params";
+  value: ParamsAmino;
+}
+function createBaseParams(): Params {
+  return {
+    noBaseFee: false,
+    baseFeeChangeDenominator: 0,
+    elasticityMultiplier: 0,
+    enableHeight: BigInt(0),
+    baseFee: "",
+    minGasPrice: "",
+    minGasMultiplier: ""
+  };
+}
+export const Params = {
+  typeUrl: "/ethermint.feemarket.v1.Params",
+  aminoType: "ethermint/x/feemarket/Params",
+  is(o: any): o is Params {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.noBaseFee === "boolean" && typeof o.baseFeeChangeDenominator === "number" && typeof o.elasticityMultiplier === "number" && typeof o.enableHeight === "bigint" && typeof o.baseFee === "string" && typeof o.minGasPrice === "string" && typeof o.minGasMultiplier === "string");
+  },
+  isAmino(o: any): o is ParamsAmino {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.no_base_fee === "boolean" && typeof o.base_fee_change_denominator === "number" && typeof o.elasticity_multiplier === "number" && typeof o.enable_height === "bigint" && typeof o.base_fee === "string" && typeof o.min_gas_price === "string" && typeof o.min_gas_multiplier === "string");
+  },
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.noBaseFee === true) {
+      writer.uint32(8).bool(message.noBaseFee);
+    }
+    if (message.baseFeeChangeDenominator !== 0) {
+      writer.uint32(16).uint32(message.baseFeeChangeDenominator);
+    }
+    if (message.elasticityMultiplier !== 0) {
+      writer.uint32(24).uint32(message.elasticityMultiplier);
+    }
+    if (message.enableHeight !== BigInt(0)) {
+      writer.uint32(40).int64(message.enableHeight);
+    }
+    if (message.baseFee !== "") {
+      writer.uint32(50).string(message.baseFee);
+    }
+    if (message.minGasPrice !== "") {
+      writer.uint32(58).string(message.minGasPrice);
+    }
+    if (message.minGasMultiplier !== "") {
+      writer.uint32(66).string(message.minGasMultiplier);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParams();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.noBaseFee = reader.bool();
+          break;
+        case 2:
+          message.baseFeeChangeDenominator = reader.uint32();
+          break;
+        case 3:
+          message.elasticityMultiplier = reader.uint32();
+          break;
+        case 5:
+          message.enableHeight = reader.int64();
+          break;
+        case 6:
+          message.baseFee = reader.string();
+          break;
+        case 7:
+          message.minGasPrice = reader.string();
+          break;
+        case 8:
+          message.minGasMultiplier = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.noBaseFee = object.noBaseFee ?? false;
+    message.baseFeeChangeDenominator = object.baseFeeChangeDenominator ?? 0;
+    message.elasticityMultiplier = object.elasticityMultiplier ?? 0;
+    message.enableHeight = object.enableHeight !== undefined && object.enableHeight !== null ? BigInt(object.enableHeight.toString()) : BigInt(0);
+    message.baseFee = object.baseFee ?? "";
+    message.minGasPrice = object.minGasPrice ?? "";
+    message.minGasMultiplier = object.minGasMultiplier ?? "";
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (object.no_base_fee !== undefined && object.no_base_fee !== null) {
+      message.noBaseFee = object.no_base_fee;
+    }
+    if (object.base_fee_change_denominator !== undefined && object.base_fee_change_denominator !== null) {
+      message.baseFeeChangeDenominator = object.base_fee_change_denominator;
+    }
+    if (object.elasticity_multiplier !== undefined && object.elasticity_multiplier !== null) {
+      message.elasticityMultiplier = object.elasticity_multiplier;
+    }
+    if (object.enable_height !== undefined && object.enable_height !== null) {
+      message.enableHeight = BigInt(object.enable_height);
+    }
+    if (object.base_fee !== undefined && object.base_fee !== null) {
+      message.baseFee = object.base_fee;
+    }
+    if (object.min_gas_price !== undefined && object.min_gas_price !== null) {
+      message.minGasPrice = object.min_gas_price;
+    }
+    if (object.min_gas_multiplier !== undefined && object.min_gas_multiplier !== null) {
+      message.minGasMultiplier = object.min_gas_multiplier;
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.no_base_fee = message.noBaseFee === false ? undefined : message.noBaseFee;
+    obj.base_fee_change_denominator = message.baseFeeChangeDenominator === 0 ? undefined : message.baseFeeChangeDenominator;
+    obj.elasticity_multiplier = message.elasticityMultiplier === 0 ? undefined : message.elasticityMultiplier;
+    obj.enable_height = message.enableHeight !== BigInt(0) ? message.enableHeight?.toString() : undefined;
+    obj.base_fee = message.baseFee ?? "";
+    obj.min_gas_price = message.minGasPrice ?? "";
+    obj.min_gas_multiplier = message.minGasMultiplier ?? "";
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "ethermint/x/feemarket/Params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Params.typeUrl, Params);
+GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

package/src/ethermint/feemarket/v1/genesis.d.ts

@@ -0,0 +1,45 @@
+import { Params, ParamsAmino } from "./feemarket";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the feemarket module's genesis state. */
+export interface GenesisState {
+    /** params defines all the parameters of the feemarket module. */
+    params: Params;
+    /**
+     * block_gas is the amount of gas wanted on the last block before the upgrade.
+     * Zero by default.
+     */
+    blockGas: bigint;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the feemarket module's genesis state. */
+export interface GenesisStateAmino {
+    /** params defines all the parameters of the feemarket module. */
+    params: ParamsAmino;
+    /**
+     * block_gas is the amount of gas wanted on the last block before the upgrade.
+     * Zero by default.
+     */
+    block_gas: string;
+}
+export interface GenesisStateAminoMsg {
+    type: "/ethermint.feemarket.v1.GenesisState";
+    value: GenesisStateAmino;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/src/ethermint/feemarket/v1/genesis.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+const feemarket_1 = require("./feemarket");
+const binary_1 = require("../../../binary");
+const registry_1 = require("../../../registry");
+function createBaseGenesisState() {
+    return {
+        params: feemarket_1.Params.fromPartial({}),
+        blockGas: BigInt(0)
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/ethermint.feemarket.v1.GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || feemarket_1.Params.is(o.params) && typeof o.blockGas === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || feemarket_1.Params.isAmino(o.params) && typeof o.block_gas === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            feemarket_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.blockGas !== BigInt(0)) {
+            writer.uint32(24).uint64(message.blockGas);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = feemarket_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.blockGas = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? feemarket_1.Params.fromPartial(object.params) : undefined;
+        message.blockGas = object.blockGas !== undefined && object.blockGas !== null ? BigInt(object.blockGas.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = feemarket_1.Params.fromAmino(object.params);
+        }
+        if (object.block_gas !== undefined && object.block_gas !== null) {
+            message.blockGas = BigInt(object.block_gas);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? feemarket_1.Params.toAmino(message.params) : feemarket_1.Params.toAmino(feemarket_1.Params.fromPartial({}));
+        obj.block_gas = message.blockGas !== BigInt(0) ? message.blockGas?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);

package/src/ethermint/feemarket/v1/genesis.ts

@@ -0,0 +1,114 @@
+import { Params, ParamsAmino } from "./feemarket";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** GenesisState defines the feemarket module's genesis state. */
+export interface GenesisState {
+  /** params defines all the parameters of the feemarket module. */
+  params: Params;
+  /**
+   * block_gas is the amount of gas wanted on the last block before the upgrade.
+   * Zero by default.
+   */
+  blockGas: bigint;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/ethermint.feemarket.v1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the feemarket module's genesis state. */
+export interface GenesisStateAmino {
+  /** params defines all the parameters of the feemarket module. */
+  params: ParamsAmino;
+  /**
+   * block_gas is the amount of gas wanted on the last block before the upgrade.
+   * Zero by default.
+   */
+  block_gas: string;
+}
+export interface GenesisStateAminoMsg {
+  type: "/ethermint.feemarket.v1.GenesisState";
+  value: GenesisStateAmino;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: Params.fromPartial({}),
+    blockGas: BigInt(0)
+  };
+}
+export const GenesisState = {
+  typeUrl: "/ethermint.feemarket.v1.GenesisState",
+  is(o: any): o is GenesisState {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Params.is(o.params) && typeof o.blockGas === "bigint");
+  },
+  isAmino(o: any): o is GenesisStateAmino {
+    return o && (o.$typeUrl === GenesisState.typeUrl || Params.isAmino(o.params) && typeof o.block_gas === "bigint");
+  },
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.blockGas !== BigInt(0)) {
+      writer.uint32(24).uint64(message.blockGas);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.blockGas = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.blockGas = object.blockGas !== undefined && object.blockGas !== null ? BigInt(object.blockGas.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    if (object.block_gas !== undefined && object.block_gas !== null) {
+      message.blockGas = BigInt(object.block_gas);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    obj.block_gas = message.blockGas !== BigInt(0) ? message.blockGas?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(GenesisState.typeUrl, GenesisState);

package/src/ethermint/feemarket/v1/query.d.ts

@@ -0,0 +1,195 @@
+import { Params, ParamsAmino } from "./feemarket";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** QueryParamsRequest defines the request type for querying x/evm parameters. */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/** QueryParamsRequest defines the request type for querying x/evm parameters. */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/** QueryParamsResponse defines the response type for querying x/evm parameters. */
+export interface QueryParamsResponse {
+    /** params define the evm module parameters. */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/** QueryParamsResponse defines the response type for querying x/evm parameters. */
+export interface QueryParamsResponseAmino {
+    /** params define the evm module parameters. */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ */
+export interface QueryBaseFeeRequest {
+}
+export interface QueryBaseFeeRequestProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ */
+export interface QueryBaseFeeRequestAmino {
+}
+export interface QueryBaseFeeRequestAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryBaseFeeRequest";
+    value: QueryBaseFeeRequestAmino;
+}
+/** QueryBaseFeeResponse returns the EIP1559 base fee. */
+export interface QueryBaseFeeResponse {
+    /** base_fee is the EIP1559 base fee */
+    baseFee: string;
+}
+export interface QueryBaseFeeResponseProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeResponse";
+    value: Uint8Array;
+}
+/** QueryBaseFeeResponse returns the EIP1559 base fee. */
+export interface QueryBaseFeeResponseAmino {
+    /** base_fee is the EIP1559 base fee */
+    base_fee: string;
+}
+export interface QueryBaseFeeResponseAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryBaseFeeResponse";
+    value: QueryBaseFeeResponseAmino;
+}
+/**
+ * QueryBlockGasRequest defines the request type for querying the EIP1559 base
+ * fee.
+ */
+export interface QueryBlockGasRequest {
+}
+export interface QueryBlockGasRequestProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryBlockGasRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryBlockGasRequest defines the request type for querying the EIP1559 base
+ * fee.
+ */
+export interface QueryBlockGasRequestAmino {
+}
+export interface QueryBlockGasRequestAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryBlockGasRequest";
+    value: QueryBlockGasRequestAmino;
+}
+/** QueryBlockGasResponse returns block gas used for a given height. */
+export interface QueryBlockGasResponse {
+    /** gas is the returned block gas */
+    gas: bigint;
+}
+export interface QueryBlockGasResponseProtoMsg {
+    typeUrl: "/ethermint.feemarket.v1.QueryBlockGasResponse";
+    value: Uint8Array;
+}
+/** QueryBlockGasResponse returns block gas used for a given height. */
+export interface QueryBlockGasResponseAmino {
+    /** gas is the returned block gas */
+    gas: string;
+}
+export interface QueryBlockGasResponseAminoMsg {
+    type: "/ethermint.feemarket.v1.QueryBlockGasResponse";
+    value: QueryBlockGasResponseAmino;
+}
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryParamsRequest;
+    isAmino(o: any): o is QueryParamsRequestAmino;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryParamsResponse;
+    isAmino(o: any): o is QueryParamsResponseAmino;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};
+export declare const QueryBaseFeeRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryBaseFeeRequest;
+    isAmino(o: any): o is QueryBaseFeeRequestAmino;
+    encode(_: QueryBaseFeeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeRequest;
+    fromPartial(_: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest;
+    fromAmino(_: QueryBaseFeeRequestAmino): QueryBaseFeeRequest;
+    toAmino(_: QueryBaseFeeRequest): QueryBaseFeeRequestAmino;
+    fromAminoMsg(object: QueryBaseFeeRequestAminoMsg): QueryBaseFeeRequest;
+    fromProtoMsg(message: QueryBaseFeeRequestProtoMsg): QueryBaseFeeRequest;
+    toProto(message: QueryBaseFeeRequest): Uint8Array;
+    toProtoMsg(message: QueryBaseFeeRequest): QueryBaseFeeRequestProtoMsg;
+};
+export declare const QueryBaseFeeResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryBaseFeeResponse;
+    isAmino(o: any): o is QueryBaseFeeResponseAmino;
+    encode(message: QueryBaseFeeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeResponse;
+    fromPartial(object: DeepPartial<QueryBaseFeeResponse>): QueryBaseFeeResponse;
+    fromAmino(object: QueryBaseFeeResponseAmino): QueryBaseFeeResponse;
+    toAmino(message: QueryBaseFeeResponse): QueryBaseFeeResponseAmino;
+    fromAminoMsg(object: QueryBaseFeeResponseAminoMsg): QueryBaseFeeResponse;
+    fromProtoMsg(message: QueryBaseFeeResponseProtoMsg): QueryBaseFeeResponse;
+    toProto(message: QueryBaseFeeResponse): Uint8Array;
+    toProtoMsg(message: QueryBaseFeeResponse): QueryBaseFeeResponseProtoMsg;
+};
+export declare const QueryBlockGasRequest: {
+    typeUrl: string;
+    is(o: any): o is QueryBlockGasRequest;
+    isAmino(o: any): o is QueryBlockGasRequestAmino;
+    encode(_: QueryBlockGasRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBlockGasRequest;
+    fromPartial(_: DeepPartial<QueryBlockGasRequest>): QueryBlockGasRequest;
+    fromAmino(_: QueryBlockGasRequestAmino): QueryBlockGasRequest;
+    toAmino(_: QueryBlockGasRequest): QueryBlockGasRequestAmino;
+    fromAminoMsg(object: QueryBlockGasRequestAminoMsg): QueryBlockGasRequest;
+    fromProtoMsg(message: QueryBlockGasRequestProtoMsg): QueryBlockGasRequest;
+    toProto(message: QueryBlockGasRequest): Uint8Array;
+    toProtoMsg(message: QueryBlockGasRequest): QueryBlockGasRequestProtoMsg;
+};
+export declare const QueryBlockGasResponse: {
+    typeUrl: string;
+    is(o: any): o is QueryBlockGasResponse;
+    isAmino(o: any): o is QueryBlockGasResponseAmino;
+    encode(message: QueryBlockGasResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBlockGasResponse;
+    fromPartial(object: DeepPartial<QueryBlockGasResponse>): QueryBlockGasResponse;
+    fromAmino(object: QueryBlockGasResponseAmino): QueryBlockGasResponse;
+    toAmino(message: QueryBlockGasResponse): QueryBlockGasResponseAmino;
+    fromAminoMsg(object: QueryBlockGasResponseAminoMsg): QueryBlockGasResponse;
+    fromProtoMsg(message: QueryBlockGasResponseProtoMsg): QueryBlockGasResponse;
+    toProto(message: QueryBlockGasResponse): Uint8Array;
+    toProtoMsg(message: QueryBlockGasResponse): QueryBlockGasResponseProtoMsg;
+};