@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.11

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

@@ -0,0 +1,201 @@
+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;
+    registerTypeUrl(): void;
+};
+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;
+    registerTypeUrl(): void;
+};
+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;
+    registerTypeUrl(): void;
+};
+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;
+    registerTypeUrl(): void;
+};
+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;
+    registerTypeUrl(): void;
+};
+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;
+    registerTypeUrl(): void;
+};

package/ethermint/feemarket/v1/query.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBlockGasResponse = exports.QueryBlockGasRequest = exports.QueryBaseFeeResponse = exports.QueryBaseFeeRequest = exports.QueryParamsResponse = exports.QueryParamsRequest = void 0;
+const feemarket_1 = require("./feemarket");
+const binary_1 = require("../../../binary");
+function createBaseQueryParamsRequest() {
+    return {};
+}
+exports.QueryParamsRequest = {
+    typeUrl: "/ethermint.feemarket.v1.QueryParamsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryParamsRequest",
+            value: exports.QueryParamsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: feemarket_1.Params.fromPartial({})
+    };
+}
+exports.QueryParamsResponse = {
+    typeUrl: "/ethermint.feemarket.v1.QueryParamsResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryParamsResponse.typeUrl || feemarket_1.Params.is(o.params));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryParamsResponse.typeUrl || feemarket_1.Params.isAmino(o.params));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            feemarket_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = feemarket_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? feemarket_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = feemarket_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? feemarket_1.Params.toAmino(message.params) : feemarket_1.Params.toAmino(feemarket_1.Params.fromPartial({}));
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryParamsResponse",
+            value: exports.QueryParamsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        feemarket_1.Params.registerTypeUrl();
+    }
+};
+function createBaseQueryBaseFeeRequest() {
+    return {};
+}
+exports.QueryBaseFeeRequest = {
+    typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryBaseFeeRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryBaseFeeRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseQueryBaseFeeRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryBaseFeeRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryBaseFeeRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryBaseFeeRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryBaseFeeRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryBaseFeeRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeRequest",
+            value: exports.QueryBaseFeeRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryBaseFeeResponse() {
+    return {
+        baseFee: ""
+    };
+}
+exports.QueryBaseFeeResponse = {
+    typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryBaseFeeResponse.typeUrl || typeof o.baseFee === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryBaseFeeResponse.typeUrl || typeof o.base_fee === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.baseFee !== "") {
+            writer.uint32(10).string(message.baseFee);
+        }
+        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 = createBaseQueryBaseFeeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.baseFee = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryBaseFeeResponse();
+        message.baseFee = object.baseFee ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryBaseFeeResponse();
+        if (object.base_fee !== undefined && object.base_fee !== null) {
+            message.baseFee = object.base_fee;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.base_fee = message.baseFee === "" ? undefined : message.baseFee;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryBaseFeeResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryBaseFeeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryBaseFeeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeResponse",
+            value: exports.QueryBaseFeeResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryBlockGasRequest() {
+    return {};
+}
+exports.QueryBlockGasRequest = {
+    typeUrl: "/ethermint.feemarket.v1.QueryBlockGasRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryBlockGasRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryBlockGasRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        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 = createBaseQueryBlockGasRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryBlockGasRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryBlockGasRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryBlockGasRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryBlockGasRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryBlockGasRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryBlockGasRequest",
+            value: exports.QueryBlockGasRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryBlockGasResponse() {
+    return {
+        gas: BigInt(0)
+    };
+}
+exports.QueryBlockGasResponse = {
+    typeUrl: "/ethermint.feemarket.v1.QueryBlockGasResponse",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryBlockGasResponse.typeUrl || typeof o.gas === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryBlockGasResponse.typeUrl || typeof o.gas === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.gas !== BigInt(0)) {
+            writer.uint32(8).int64(message.gas);
+        }
+        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 = createBaseQueryBlockGasResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.gas = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryBlockGasResponse();
+        message.gas = object.gas !== undefined && object.gas !== null ? BigInt(object.gas.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryBlockGasResponse();
+        if (object.gas !== undefined && object.gas !== null) {
+            message.gas = BigInt(object.gas);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.gas = message.gas !== BigInt(0) ? message.gas?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryBlockGasResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.QueryBlockGasResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryBlockGasResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ethermint.feemarket.v1.QueryBlockGasResponse",
+            value: exports.QueryBlockGasResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/ethermint/feemarket/v1/query.rpc.func.d.ts

@@ -0,0 +1,5 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { QueryParamsRequest, QueryParamsResponse, QueryBaseFeeRequest, QueryBaseFeeResponse, QueryBlockGasRequest, QueryBlockGasResponse } from "./query";
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;
+export declare const createGetBaseFee: (clientResolver?: RpcResolver) => (request: QueryBaseFeeRequest) => Promise<QueryBaseFeeResponse>;
+export declare const createGetBlockGas: (clientResolver?: RpcResolver) => (request: QueryBlockGasRequest) => Promise<QueryBlockGasResponse>;

package/ethermint/feemarket/v1/query.rpc.func.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetBlockGas = exports.createGetBaseFee = exports.createGetParams = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryParamsRequest.encode,
+    decode: query_1.QueryParamsResponse.decode,
+    service: "ethermint.feemarket.v1.Query",
+    method: "Params",
+    clientResolver,
+    deps: [query_1.QueryParamsRequest, query_1.QueryParamsResponse]
+});
+exports.createGetParams = createGetParams;
+const createGetBaseFee = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryBaseFeeRequest.encode,
+    decode: query_1.QueryBaseFeeResponse.decode,
+    service: "ethermint.feemarket.v1.Query",
+    method: "BaseFee",
+    clientResolver,
+    deps: [query_1.QueryBaseFeeRequest, query_1.QueryBaseFeeResponse]
+});
+exports.createGetBaseFee = createGetBaseFee;
+const createGetBlockGas = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryBlockGasRequest.encode,
+    decode: query_1.QueryBlockGasResponse.decode,
+    service: "ethermint.feemarket.v1.Query",
+    method: "BlockGas",
+    clientResolver,
+    deps: [query_1.QueryBlockGasRequest, query_1.QueryBlockGasResponse]
+});
+exports.createGetBlockGas = createGetBlockGas;

package/ethermint/feemarket/v1/query.rpc.react.d.ts

@@ -0,0 +1,4 @@
+import { QueryParamsRequest, QueryParamsResponse, QueryBaseFeeRequest, QueryBaseFeeResponse, QueryBlockGasRequest, QueryBlockGasResponse } from "./query";
+export declare const useGetParams: <TData = QueryParamsResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryParamsRequest, QueryParamsResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const useGetBaseFee: <TData = QueryBaseFeeResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryBaseFeeRequest, QueryBaseFeeResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const useGetBlockGas: <TData = QueryBlockGasResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryBlockGasRequest, QueryBlockGasResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;

package/ethermint/feemarket/v1/query.rpc.react.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetBlockGas = exports.useGetBaseFee = exports.useGetParams = void 0;
+const react_query_1 = require("../../../react-query");
+const query_rpc_func_1 = require("./query.rpc.func");
+exports.useGetParams = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: query_rpc_func_1.createGetParams,
+    queryKeyPrefix: "ParamsQuery"
+});
+exports.useGetBaseFee = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: query_rpc_func_1.createGetBaseFee,
+    queryKeyPrefix: "BaseFeeQuery"
+});
+exports.useGetBlockGas = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: query_rpc_func_1.createGetBlockGas,
+    queryKeyPrefix: "BlockGasQuery"
+});