@xpla/xplajs 1.7.0-beta.0

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

@@ -0,0 +1,387 @@
+"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");
+const registry_1 = require("../../../registry");
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryParamsRequest.typeUrl, exports.QueryParamsRequest);
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryParamsResponse.typeUrl, exports.QueryParamsResponse);
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryBaseFeeRequest.typeUrl, exports.QueryBaseFeeRequest);
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryBaseFeeResponse.typeUrl, exports.QueryBaseFeeResponse);
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryBlockGasRequest.typeUrl, exports.QueryBlockGasRequest);
+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()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.QueryBlockGasResponse.typeUrl, exports.QueryBlockGasResponse);

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

@@ -0,0 +1,27 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryBaseFeeRequest, QueryBaseFeeResponse, QueryBlockGasRequest, QueryBlockGasResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* Params queries the parameters of x/feemarket module. */
+  params = async (_params: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const endpoint = `ethermint/feemarket/v1/params`;
+    return await this.req.get<QueryParamsResponse>(endpoint);
+  };
+  /* BaseFee queries the base fee of the parent block of the current block. */
+  baseFee = async (_params: QueryBaseFeeRequest = {}): Promise<QueryBaseFeeResponse> => {
+    const endpoint = `ethermint/feemarket/v1/base_fee`;
+    return await this.req.get<QueryBaseFeeResponse>(endpoint);
+  };
+  /* BlockGas queries the gas used at a given block height */
+  blockGas = async (_params: QueryBlockGasRequest = {}): Promise<QueryBlockGasResponse> => {
+    const endpoint = `ethermint/feemarket/v1/block_gas`;
+    return await this.req.get<QueryBlockGasResponse>(endpoint);
+  };
+}

package/src/ethermint/feemarket/v1/query.rpc.Query.ts

@@ -0,0 +1,52 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryBaseFeeRequest, QueryBaseFeeResponse, QueryBlockGasRequest, QueryBlockGasResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+  /** Params queries the parameters of x/feemarket module. */
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /** BaseFee queries the base fee of the parent block of the current block. */
+  baseFee(request?: QueryBaseFeeRequest): Promise<QueryBaseFeeResponse>;
+  /** BlockGas queries the gas used at a given block height */
+  blockGas(request?: QueryBlockGasRequest): Promise<QueryBlockGasResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* Params queries the parameters of x/feemarket module. */
+  params = async (request: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.feemarket.v1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  };
+  /* BaseFee queries the base fee of the parent block of the current block. */
+  baseFee = async (request: QueryBaseFeeRequest = {}): Promise<QueryBaseFeeResponse> => {
+    const data = QueryBaseFeeRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.feemarket.v1.Query", "BaseFee", data);
+    return promise.then(data => QueryBaseFeeResponse.decode(new BinaryReader(data)));
+  };
+  /* BlockGas queries the gas used at a given block height */
+  blockGas = async (request: QueryBlockGasRequest = {}): Promise<QueryBlockGasResponse> => {
+    const data = QueryBlockGasRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.feemarket.v1.Query", "BlockGas", data);
+    return promise.then(data => QueryBlockGasResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    baseFee(request?: QueryBaseFeeRequest): Promise<QueryBaseFeeResponse> {
+      return queryService.baseFee(request);
+    },
+    blockGas(request?: QueryBlockGasRequest): Promise<QueryBlockGasResponse> {
+      return queryService.blockGas(request);
+    }
+  };
+};

package/src/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/src/ethermint/feemarket/v1/query.rpc.func.js

@@ -0,0 +1,29 @@
+"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
+});
+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
+});
+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
+});
+exports.createGetBlockGas = createGetBlockGas;

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

@@ -0,0 +1,23 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { QueryParamsRequest, QueryParamsResponse, QueryBaseFeeRequest, QueryBaseFeeResponse, QueryBlockGasRequest, QueryBlockGasResponse } from "./query";
+export const createGetParams = (clientResolver?: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+  encode: QueryParamsRequest.encode,
+  decode: QueryParamsResponse.decode,
+  service: "ethermint.feemarket.v1.Query",
+  method: "Params",
+  clientResolver
+});
+export const createGetBaseFee = (clientResolver?: RpcResolver) => buildQuery<QueryBaseFeeRequest, QueryBaseFeeResponse>({
+  encode: QueryBaseFeeRequest.encode,
+  decode: QueryBaseFeeResponse.decode,
+  service: "ethermint.feemarket.v1.Query",
+  method: "BaseFee",
+  clientResolver
+});
+export const createGetBlockGas = (clientResolver?: RpcResolver) => buildQuery<QueryBlockGasRequest, QueryBlockGasResponse>({
+  encode: QueryBlockGasRequest.encode,
+  decode: QueryBlockGasResponse.decode,
+  service: "ethermint.feemarket.v1.Query",
+  method: "BlockGas",
+  clientResolver
+});