@xpla/xpla-react 1.7.0-beta.0

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

@@ -0,0 +1,197 @@
+import { Params, ParamsAmino } from "./feemarket";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** MsgUpdateParams defines a Msg for updating the x/feemarket module parameters. */
+export interface MsgUpdateParams {
+  /** authority is the address of the governance account. */
+  authority: string;
+  /**
+   * params defines the x/feemarket parameters to update.
+   * NOTE: All parameters must be supplied.
+   */
+  params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+  typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams";
+  value: Uint8Array;
+}
+/** MsgUpdateParams defines a Msg for updating the x/feemarket module parameters. */
+export interface MsgUpdateParamsAmino {
+  /** authority is the address of the governance account. */
+  authority: string;
+  /**
+   * params defines the x/feemarket parameters to update.
+   * NOTE: All parameters must be supplied.
+   */
+  params: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+  type: "ethermint/x/feemarket/MsgUpdateParams";
+  value: MsgUpdateParamsAmino;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponse {}
+export interface MsgUpdateParamsResponseProtoMsg {
+  typeUrl: "/ethermint.feemarket.v1.MsgUpdateParamsResponse";
+  value: Uint8Array;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponseAmino {}
+export interface MsgUpdateParamsResponseAminoMsg {
+  type: "/ethermint.feemarket.v1.MsgUpdateParamsResponse";
+  value: MsgUpdateParamsResponseAmino;
+}
+function createBaseMsgUpdateParams(): MsgUpdateParams {
+  return {
+    authority: "",
+    params: Params.fromPartial({})
+  };
+}
+export const MsgUpdateParams = {
+  typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams",
+  aminoType: "ethermint/x/feemarket/MsgUpdateParams",
+  is(o: any): o is MsgUpdateParams {
+    return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
+  },
+  isAmino(o: any): o is MsgUpdateParamsAmino {
+    return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isAmino(o.params));
+  },
+  encode(message: MsgUpdateParams, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParams();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        case 2:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  },
+  fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams {
+    const message = createBaseMsgUpdateParams();
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    return message;
+  },
+  toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino {
+    const obj: any = {};
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    return obj;
+  },
+  fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams {
+    return MsgUpdateParams.fromAmino(object.value);
+  },
+  toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg {
+    return {
+      type: "ethermint/x/feemarket/MsgUpdateParams",
+      value: MsgUpdateParams.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams {
+    return MsgUpdateParams.decode(message.value);
+  },
+  toProto(message: MsgUpdateParams): Uint8Array {
+    return MsgUpdateParams.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.MsgUpdateParams",
+      value: MsgUpdateParams.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse(): MsgUpdateParamsResponse {
+  return {};
+}
+export const MsgUpdateParamsResponse = {
+  typeUrl: "/ethermint.feemarket.v1.MsgUpdateParamsResponse",
+  is(o: any): o is MsgUpdateParamsResponse {
+    return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+  },
+  isAmino(o: any): o is MsgUpdateParamsResponseAmino {
+    return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+  },
+  encode(_: MsgUpdateParamsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgUpdateParamsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  },
+  fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse {
+    const message = createBaseMsgUpdateParamsResponse();
+    return message;
+  },
+  toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino {
+    const obj: any = {};
+    return obj;
+  },
+  fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse {
+    return MsgUpdateParamsResponse.fromAmino(object.value);
+  },
+  fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse {
+    return MsgUpdateParamsResponse.decode(message.value);
+  },
+  toProto(message: MsgUpdateParamsResponse): Uint8Array {
+    return MsgUpdateParamsResponse.encode(message).finish();
+  },
+  toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg {
+    return {
+      typeUrl: "/ethermint.feemarket.v1.MsgUpdateParamsResponse",
+      value: MsgUpdateParamsResponse.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);

package/src/ethermint/types/v1/account.ts

@@ -0,0 +1,114 @@
+import { BaseAccount, BaseAccountAmino } from "../../../cosmos/auth/v1beta1/auth";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * EthAccount implements the sdk.AccountI interface and embeds an
+ * authtypes.BaseAccount type. It is compatible with the auth AccountKeeper.
+ */
+export interface EthAccount {
+  /** base_account is an authtypes.BaseAccount */
+  baseAccount?: BaseAccount;
+  /** code_hash is the hash calculated from the code contents */
+  codeHash: string;
+}
+export interface EthAccountProtoMsg {
+  typeUrl: "/ethermint.types.v1.EthAccount";
+  value: Uint8Array;
+}
+/**
+ * EthAccount implements the sdk.AccountI interface and embeds an
+ * authtypes.BaseAccount type. It is compatible with the auth AccountKeeper.
+ */
+export interface EthAccountAmino {
+  /** base_account is an authtypes.BaseAccount */
+  base_account?: BaseAccountAmino;
+  /** code_hash is the hash calculated from the code contents */
+  code_hash: string;
+}
+export interface EthAccountAminoMsg {
+  type: "/ethermint.types.v1.EthAccount";
+  value: EthAccountAmino;
+}
+function createBaseEthAccount(): EthAccount {
+  return {
+    baseAccount: undefined,
+    codeHash: ""
+  };
+}
+export const EthAccount = {
+  typeUrl: "/ethermint.types.v1.EthAccount",
+  is(o: any): o is EthAccount {
+    return o && (o.$typeUrl === EthAccount.typeUrl || typeof o.codeHash === "string");
+  },
+  isAmino(o: any): o is EthAccountAmino {
+    return o && (o.$typeUrl === EthAccount.typeUrl || typeof o.code_hash === "string");
+  },
+  encode(message: EthAccount, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.baseAccount !== undefined) {
+      BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.codeHash !== "") {
+      writer.uint32(18).string(message.codeHash);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): EthAccount {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEthAccount();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.baseAccount = BaseAccount.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.codeHash = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<EthAccount>): EthAccount {
+    const message = createBaseEthAccount();
+    message.baseAccount = object.baseAccount !== undefined && object.baseAccount !== null ? BaseAccount.fromPartial(object.baseAccount) : undefined;
+    message.codeHash = object.codeHash ?? "";
+    return message;
+  },
+  fromAmino(object: EthAccountAmino): EthAccount {
+    const message = createBaseEthAccount();
+    if (object.base_account !== undefined && object.base_account !== null) {
+      message.baseAccount = BaseAccount.fromAmino(object.base_account);
+    }
+    if (object.code_hash !== undefined && object.code_hash !== null) {
+      message.codeHash = object.code_hash;
+    }
+    return message;
+  },
+  toAmino(message: EthAccount): EthAccountAmino {
+    const obj: any = {};
+    obj.base_account = message.baseAccount ? BaseAccount.toAmino(message.baseAccount) : undefined;
+    obj.code_hash = message.codeHash === "" ? undefined : message.codeHash;
+    return obj;
+  },
+  fromAminoMsg(object: EthAccountAminoMsg): EthAccount {
+    return EthAccount.fromAmino(object.value);
+  },
+  fromProtoMsg(message: EthAccountProtoMsg): EthAccount {
+    return EthAccount.decode(message.value);
+  },
+  toProto(message: EthAccount): Uint8Array {
+    return EthAccount.encode(message).finish();
+  },
+  toProtoMsg(message: EthAccount): EthAccountProtoMsg {
+    return {
+      typeUrl: "/ethermint.types.v1.EthAccount",
+      value: EthAccount.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(EthAccount.typeUrl, EthAccount);

package/src/ethermint/types/v1/dynamic_fee.ts

@@ -0,0 +1,91 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** ExtensionOptionDynamicFeeTx is an extension option that specifies the maxPrioPrice for cosmos tx */
+export interface ExtensionOptionDynamicFeeTx {
+  /** max_priority_price is the same as `max_priority_fee_per_gas` in eip-1559 spec */
+  maxPriorityPrice: string;
+}
+export interface ExtensionOptionDynamicFeeTxProtoMsg {
+  typeUrl: "/ethermint.types.v1.ExtensionOptionDynamicFeeTx";
+  value: Uint8Array;
+}
+/** ExtensionOptionDynamicFeeTx is an extension option that specifies the maxPrioPrice for cosmos tx */
+export interface ExtensionOptionDynamicFeeTxAmino {
+  /** max_priority_price is the same as `max_priority_fee_per_gas` in eip-1559 spec */
+  max_priority_price: string;
+}
+export interface ExtensionOptionDynamicFeeTxAminoMsg {
+  type: "/ethermint.types.v1.ExtensionOptionDynamicFeeTx";
+  value: ExtensionOptionDynamicFeeTxAmino;
+}
+function createBaseExtensionOptionDynamicFeeTx(): ExtensionOptionDynamicFeeTx {
+  return {
+    maxPriorityPrice: ""
+  };
+}
+export const ExtensionOptionDynamicFeeTx = {
+  typeUrl: "/ethermint.types.v1.ExtensionOptionDynamicFeeTx",
+  is(o: any): o is ExtensionOptionDynamicFeeTx {
+    return o && (o.$typeUrl === ExtensionOptionDynamicFeeTx.typeUrl || typeof o.maxPriorityPrice === "string");
+  },
+  isAmino(o: any): o is ExtensionOptionDynamicFeeTxAmino {
+    return o && (o.$typeUrl === ExtensionOptionDynamicFeeTx.typeUrl || typeof o.max_priority_price === "string");
+  },
+  encode(message: ExtensionOptionDynamicFeeTx, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.maxPriorityPrice !== "") {
+      writer.uint32(10).string(message.maxPriorityPrice);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): ExtensionOptionDynamicFeeTx {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExtensionOptionDynamicFeeTx();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.maxPriorityPrice = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<ExtensionOptionDynamicFeeTx>): ExtensionOptionDynamicFeeTx {
+    const message = createBaseExtensionOptionDynamicFeeTx();
+    message.maxPriorityPrice = object.maxPriorityPrice ?? "";
+    return message;
+  },
+  fromAmino(object: ExtensionOptionDynamicFeeTxAmino): ExtensionOptionDynamicFeeTx {
+    const message = createBaseExtensionOptionDynamicFeeTx();
+    if (object.max_priority_price !== undefined && object.max_priority_price !== null) {
+      message.maxPriorityPrice = object.max_priority_price;
+    }
+    return message;
+  },
+  toAmino(message: ExtensionOptionDynamicFeeTx): ExtensionOptionDynamicFeeTxAmino {
+    const obj: any = {};
+    obj.max_priority_price = message.maxPriorityPrice === "" ? undefined : message.maxPriorityPrice;
+    return obj;
+  },
+  fromAminoMsg(object: ExtensionOptionDynamicFeeTxAminoMsg): ExtensionOptionDynamicFeeTx {
+    return ExtensionOptionDynamicFeeTx.fromAmino(object.value);
+  },
+  fromProtoMsg(message: ExtensionOptionDynamicFeeTxProtoMsg): ExtensionOptionDynamicFeeTx {
+    return ExtensionOptionDynamicFeeTx.decode(message.value);
+  },
+  toProto(message: ExtensionOptionDynamicFeeTx): Uint8Array {
+    return ExtensionOptionDynamicFeeTx.encode(message).finish();
+  },
+  toProtoMsg(message: ExtensionOptionDynamicFeeTx): ExtensionOptionDynamicFeeTxProtoMsg {
+    return {
+      typeUrl: "/ethermint.types.v1.ExtensionOptionDynamicFeeTx",
+      value: ExtensionOptionDynamicFeeTx.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(ExtensionOptionDynamicFeeTx.typeUrl, ExtensionOptionDynamicFeeTx);

package/src/ethermint/types/v1/indexer.ts

@@ -0,0 +1,205 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/** TxResult is the value stored in eth tx indexer */
+export interface TxResult {
+  /** height of the blockchain */
+  height: bigint;
+  /** tx_index of the cosmos transaction */
+  txIndex: number;
+  /** msg_index in a batch transaction */
+  msgIndex: number;
+  /**
+   * eth_tx_index is the index in the list of valid eth tx in the block,
+   * aka. the transaction list returned by eth_getBlock api.
+   */
+  ethTxIndex: number;
+  /** failed is true if the eth transaction did not go succeed */
+  failed: boolean;
+  /**
+   * gas_used by the transaction. If it exceeds the block gas limit,
+   * it's set to gas limit, which is what's actually deducted by ante handler.
+   */
+  gasUsed: bigint;
+  /**
+   * cumulative_gas_used specifies the cumulated amount of gas used for all
+   * processed messages within the current batch transaction.
+   */
+  cumulativeGasUsed: bigint;
+}
+export interface TxResultProtoMsg {
+  typeUrl: "/ethermint.types.v1.TxResult";
+  value: Uint8Array;
+}
+/** TxResult is the value stored in eth tx indexer */
+export interface TxResultAmino {
+  /** height of the blockchain */
+  height: string;
+  /** tx_index of the cosmos transaction */
+  tx_index: number;
+  /** msg_index in a batch transaction */
+  msg_index: number;
+  /**
+   * eth_tx_index is the index in the list of valid eth tx in the block,
+   * aka. the transaction list returned by eth_getBlock api.
+   */
+  eth_tx_index: number;
+  /** failed is true if the eth transaction did not go succeed */
+  failed: boolean;
+  /**
+   * gas_used by the transaction. If it exceeds the block gas limit,
+   * it's set to gas limit, which is what's actually deducted by ante handler.
+   */
+  gas_used: string;
+  /**
+   * cumulative_gas_used specifies the cumulated amount of gas used for all
+   * processed messages within the current batch transaction.
+   */
+  cumulative_gas_used: string;
+}
+export interface TxResultAminoMsg {
+  type: "/ethermint.types.v1.TxResult";
+  value: TxResultAmino;
+}
+function createBaseTxResult(): TxResult {
+  return {
+    height: BigInt(0),
+    txIndex: 0,
+    msgIndex: 0,
+    ethTxIndex: 0,
+    failed: false,
+    gasUsed: BigInt(0),
+    cumulativeGasUsed: BigInt(0)
+  };
+}
+export const TxResult = {
+  typeUrl: "/ethermint.types.v1.TxResult",
+  is(o: any): o is TxResult {
+    return o && (o.$typeUrl === TxResult.typeUrl || typeof o.height === "bigint" && typeof o.txIndex === "number" && typeof o.msgIndex === "number" && typeof o.ethTxIndex === "number" && typeof o.failed === "boolean" && typeof o.gasUsed === "bigint" && typeof o.cumulativeGasUsed === "bigint");
+  },
+  isAmino(o: any): o is TxResultAmino {
+    return o && (o.$typeUrl === TxResult.typeUrl || typeof o.height === "bigint" && typeof o.tx_index === "number" && typeof o.msg_index === "number" && typeof o.eth_tx_index === "number" && typeof o.failed === "boolean" && typeof o.gas_used === "bigint" && typeof o.cumulative_gas_used === "bigint");
+  },
+  encode(message: TxResult, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.height !== BigInt(0)) {
+      writer.uint32(8).int64(message.height);
+    }
+    if (message.txIndex !== 0) {
+      writer.uint32(16).uint32(message.txIndex);
+    }
+    if (message.msgIndex !== 0) {
+      writer.uint32(24).uint32(message.msgIndex);
+    }
+    if (message.ethTxIndex !== 0) {
+      writer.uint32(32).int32(message.ethTxIndex);
+    }
+    if (message.failed === true) {
+      writer.uint32(40).bool(message.failed);
+    }
+    if (message.gasUsed !== BigInt(0)) {
+      writer.uint32(48).uint64(message.gasUsed);
+    }
+    if (message.cumulativeGasUsed !== BigInt(0)) {
+      writer.uint32(56).uint64(message.cumulativeGasUsed);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): TxResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTxResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.int64();
+          break;
+        case 2:
+          message.txIndex = reader.uint32();
+          break;
+        case 3:
+          message.msgIndex = reader.uint32();
+          break;
+        case 4:
+          message.ethTxIndex = reader.int32();
+          break;
+        case 5:
+          message.failed = reader.bool();
+          break;
+        case 6:
+          message.gasUsed = reader.uint64();
+          break;
+        case 7:
+          message.cumulativeGasUsed = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<TxResult>): TxResult {
+    const message = createBaseTxResult();
+    message.height = object.height !== undefined && object.height !== null ? BigInt(object.height.toString()) : BigInt(0);
+    message.txIndex = object.txIndex ?? 0;
+    message.msgIndex = object.msgIndex ?? 0;
+    message.ethTxIndex = object.ethTxIndex ?? 0;
+    message.failed = object.failed ?? false;
+    message.gasUsed = object.gasUsed !== undefined && object.gasUsed !== null ? BigInt(object.gasUsed.toString()) : BigInt(0);
+    message.cumulativeGasUsed = object.cumulativeGasUsed !== undefined && object.cumulativeGasUsed !== null ? BigInt(object.cumulativeGasUsed.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: TxResultAmino): TxResult {
+    const message = createBaseTxResult();
+    if (object.height !== undefined && object.height !== null) {
+      message.height = BigInt(object.height);
+    }
+    if (object.tx_index !== undefined && object.tx_index !== null) {
+      message.txIndex = object.tx_index;
+    }
+    if (object.msg_index !== undefined && object.msg_index !== null) {
+      message.msgIndex = object.msg_index;
+    }
+    if (object.eth_tx_index !== undefined && object.eth_tx_index !== null) {
+      message.ethTxIndex = object.eth_tx_index;
+    }
+    if (object.failed !== undefined && object.failed !== null) {
+      message.failed = object.failed;
+    }
+    if (object.gas_used !== undefined && object.gas_used !== null) {
+      message.gasUsed = BigInt(object.gas_used);
+    }
+    if (object.cumulative_gas_used !== undefined && object.cumulative_gas_used !== null) {
+      message.cumulativeGasUsed = BigInt(object.cumulative_gas_used);
+    }
+    return message;
+  },
+  toAmino(message: TxResult): TxResultAmino {
+    const obj: any = {};
+    obj.height = message.height !== BigInt(0) ? message.height?.toString() : undefined;
+    obj.tx_index = message.txIndex === 0 ? undefined : message.txIndex;
+    obj.msg_index = message.msgIndex === 0 ? undefined : message.msgIndex;
+    obj.eth_tx_index = message.ethTxIndex === 0 ? undefined : message.ethTxIndex;
+    obj.failed = message.failed === false ? undefined : message.failed;
+    obj.gas_used = message.gasUsed !== BigInt(0) ? message.gasUsed?.toString() : undefined;
+    obj.cumulative_gas_used = message.cumulativeGasUsed !== BigInt(0) ? message.cumulativeGasUsed?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: TxResultAminoMsg): TxResult {
+    return TxResult.fromAmino(object.value);
+  },
+  fromProtoMsg(message: TxResultProtoMsg): TxResult {
+    return TxResult.decode(message.value);
+  },
+  toProto(message: TxResult): Uint8Array {
+    return TxResult.encode(message).finish();
+  },
+  toProtoMsg(message: TxResult): TxResultProtoMsg {
+    return {
+      typeUrl: "/ethermint.types.v1.TxResult",
+      value: TxResult.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(TxResult.typeUrl, TxResult);