@xpla/xpla-react 1.7.0-beta.0

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

@@ -0,0 +1,487 @@
+import { Params, ParamsAmino } from "./feemarket";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** 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;
+}
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+export const QueryParamsRequest = {
+  typeUrl: "/ethermint.feemarket.v1.QueryParamsRequest",
+  is(o: any): o is QueryParamsRequest {
+    return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryParamsRequestAmino {
+    return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+  },
+  encode(_: QueryParamsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof BinaryReader ? input : new 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(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  },
+  toAmino(_: QueryParamsRequest): QueryParamsRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest {
+    return QueryParamsRequest.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest {
+    return QueryParamsRequest.decode(message.value);
+  },
+  toProto(message: QueryParamsRequest): Uint8Array {
+    return QueryParamsRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryParamsRequest",
+      value: QueryParamsRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: Params.fromPartial({})
+  };
+}
+export const QueryParamsResponse = {
+  typeUrl: "/ethermint.feemarket.v1.QueryParamsResponse",
+  is(o: any): o is QueryParamsResponse {
+    return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.is(o.params));
+  },
+  isAmino(o: any): o is QueryParamsResponseAmino {
+    return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.isAmino(o.params));
+  },
+  encode(message: QueryParamsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new 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 = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: QueryParamsResponse): QueryParamsResponseAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse {
+    return QueryParamsResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse {
+    return QueryParamsResponse.decode(message.value);
+  },
+  toProto(message: QueryParamsResponse): Uint8Array {
+    return QueryParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryParamsResponse",
+      value: QueryParamsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
+function createBaseQueryBaseFeeRequest(): QueryBaseFeeRequest {
+  return {};
+}
+export const QueryBaseFeeRequest = {
+  typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeRequest",
+  is(o: any): o is QueryBaseFeeRequest {
+    return o && o.$typeUrl === QueryBaseFeeRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryBaseFeeRequestAmino {
+    return o && o.$typeUrl === QueryBaseFeeRequest.typeUrl;
+  },
+  encode(_: QueryBaseFeeRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeRequest {
+    const reader = input instanceof BinaryReader ? input : new 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(_: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest {
+    const message = createBaseQueryBaseFeeRequest();
+    return message;
+  },
+  fromAmino(_: QueryBaseFeeRequestAmino): QueryBaseFeeRequest {
+    const message = createBaseQueryBaseFeeRequest();
+    return message;
+  },
+  toAmino(_: QueryBaseFeeRequest): QueryBaseFeeRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryBaseFeeRequestAminoMsg): QueryBaseFeeRequest {
+    return QueryBaseFeeRequest.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryBaseFeeRequestProtoMsg): QueryBaseFeeRequest {
+    return QueryBaseFeeRequest.decode(message.value);
+  },
+  toProto(message: QueryBaseFeeRequest): Uint8Array {
+    return QueryBaseFeeRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryBaseFeeRequest): QueryBaseFeeRequestProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeRequest",
+      value: QueryBaseFeeRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryBaseFeeRequest.typeUrl, QueryBaseFeeRequest);
+function createBaseQueryBaseFeeResponse(): QueryBaseFeeResponse {
+  return {
+    baseFee: ""
+  };
+}
+export const QueryBaseFeeResponse = {
+  typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeResponse",
+  is(o: any): o is QueryBaseFeeResponse {
+    return o && (o.$typeUrl === QueryBaseFeeResponse.typeUrl || typeof o.baseFee === "string");
+  },
+  isAmino(o: any): o is QueryBaseFeeResponseAmino {
+    return o && (o.$typeUrl === QueryBaseFeeResponse.typeUrl || typeof o.base_fee === "string");
+  },
+  encode(message: QueryBaseFeeResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.baseFee !== "") {
+      writer.uint32(10).string(message.baseFee);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeResponse {
+    const reader = input instanceof BinaryReader ? input : new 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: DeepPartial<QueryBaseFeeResponse>): QueryBaseFeeResponse {
+    const message = createBaseQueryBaseFeeResponse();
+    message.baseFee = object.baseFee ?? "";
+    return message;
+  },
+  fromAmino(object: QueryBaseFeeResponseAmino): QueryBaseFeeResponse {
+    const message = createBaseQueryBaseFeeResponse();
+    if (object.base_fee !== undefined && object.base_fee !== null) {
+      message.baseFee = object.base_fee;
+    }
+    return message;
+  },
+  toAmino(message: QueryBaseFeeResponse): QueryBaseFeeResponseAmino {
+    const obj: any = {};
+    obj.base_fee = message.baseFee === "" ? undefined : message.baseFee;
+    return obj;
+  },
+  fromAminoMsg(object: QueryBaseFeeResponseAminoMsg): QueryBaseFeeResponse {
+    return QueryBaseFeeResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryBaseFeeResponseProtoMsg): QueryBaseFeeResponse {
+    return QueryBaseFeeResponse.decode(message.value);
+  },
+  toProto(message: QueryBaseFeeResponse): Uint8Array {
+    return QueryBaseFeeResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryBaseFeeResponse): QueryBaseFeeResponseProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryBaseFeeResponse",
+      value: QueryBaseFeeResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryBaseFeeResponse.typeUrl, QueryBaseFeeResponse);
+function createBaseQueryBlockGasRequest(): QueryBlockGasRequest {
+  return {};
+}
+export const QueryBlockGasRequest = {
+  typeUrl: "/ethermint.feemarket.v1.QueryBlockGasRequest",
+  is(o: any): o is QueryBlockGasRequest {
+    return o && o.$typeUrl === QueryBlockGasRequest.typeUrl;
+  },
+  isAmino(o: any): o is QueryBlockGasRequestAmino {
+    return o && o.$typeUrl === QueryBlockGasRequest.typeUrl;
+  },
+  encode(_: QueryBlockGasRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryBlockGasRequest {
+    const reader = input instanceof BinaryReader ? input : new 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(_: DeepPartial<QueryBlockGasRequest>): QueryBlockGasRequest {
+    const message = createBaseQueryBlockGasRequest();
+    return message;
+  },
+  fromAmino(_: QueryBlockGasRequestAmino): QueryBlockGasRequest {
+    const message = createBaseQueryBlockGasRequest();
+    return message;
+  },
+  toAmino(_: QueryBlockGasRequest): QueryBlockGasRequestAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: QueryBlockGasRequestAminoMsg): QueryBlockGasRequest {
+    return QueryBlockGasRequest.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryBlockGasRequestProtoMsg): QueryBlockGasRequest {
+    return QueryBlockGasRequest.decode(message.value);
+  },
+  toProto(message: QueryBlockGasRequest): Uint8Array {
+    return QueryBlockGasRequest.encode(message).finish();
+  },
+  toProtoMsg(message: QueryBlockGasRequest): QueryBlockGasRequestProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryBlockGasRequest",
+      value: QueryBlockGasRequest.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryBlockGasRequest.typeUrl, QueryBlockGasRequest);
+function createBaseQueryBlockGasResponse(): QueryBlockGasResponse {
+  return {
+    gas: BigInt(0)
+  };
+}
+export const QueryBlockGasResponse = {
+  typeUrl: "/ethermint.feemarket.v1.QueryBlockGasResponse",
+  is(o: any): o is QueryBlockGasResponse {
+    return o && (o.$typeUrl === QueryBlockGasResponse.typeUrl || typeof o.gas === "bigint");
+  },
+  isAmino(o: any): o is QueryBlockGasResponseAmino {
+    return o && (o.$typeUrl === QueryBlockGasResponse.typeUrl || typeof o.gas === "bigint");
+  },
+  encode(message: QueryBlockGasResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.gas !== BigInt(0)) {
+      writer.uint32(8).int64(message.gas);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryBlockGasResponse {
+    const reader = input instanceof BinaryReader ? input : new 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: DeepPartial<QueryBlockGasResponse>): QueryBlockGasResponse {
+    const message = createBaseQueryBlockGasResponse();
+    message.gas = object.gas !== undefined && object.gas !== null ? BigInt(object.gas.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: QueryBlockGasResponseAmino): QueryBlockGasResponse {
+    const message = createBaseQueryBlockGasResponse();
+    if (object.gas !== undefined && object.gas !== null) {
+      message.gas = BigInt(object.gas);
+    }
+    return message;
+  },
+  toAmino(message: QueryBlockGasResponse): QueryBlockGasResponseAmino {
+    const obj: any = {};
+    obj.gas = message.gas !== BigInt(0) ? message.gas?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: QueryBlockGasResponseAminoMsg): QueryBlockGasResponse {
+    return QueryBlockGasResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: QueryBlockGasResponseProtoMsg): QueryBlockGasResponse {
+    return QueryBlockGasResponse.decode(message.value);
+  },
+  toProto(message: QueryBlockGasResponse): Uint8Array {
+    return QueryBlockGasResponse.encode(message).finish();
+  },
+  toProtoMsg(message: QueryBlockGasResponse): QueryBlockGasResponseProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.QueryBlockGasResponse",
+      value: QueryBlockGasResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(QueryBlockGasResponse.typeUrl, QueryBlockGasResponse);

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

@@ -0,0 +1,29 @@
+import { TelescopeGeneratedType } from "../../../types";
+import { MsgUpdateParams } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/ethermint.feemarket.v1.MsgUpdateParams", MsgUpdateParams]];
+export const MessageComposer = {
+  encoded: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams",
+        value: MsgUpdateParams.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams",
+        value: MsgUpdateParams.fromPartial(value)
+      };
+    }
+  }
+};

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

@@ -0,0 +1,13 @@
+import { buildTx, SigningClientResolver } from "../../../helper-func-types";
+import { buildUseMutation } from "../../../react-query";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgUpdateParams } from "./tx";
+export const createUpdateParams = (clientResolver?: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
+  typeUrl: MsgUpdateParams.typeUrl,
+  encoders: toEncoders(MsgUpdateParams),
+  converters: toConverters(MsgUpdateParams)
+});
+export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
+  builderMutationFn: createUpdateParams
+});