import { ServiceType } from "@protobuf-ts/runtime-rpc";
import { WireType } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { OracleType } from "../../oracle/v1beta1/oracle_pb.js";
import { Params } from "./params_pb.js";
import { BridgeValidator } from "./types_pb.js";
import { Any } from "../../../google/protobuf/any_pb.js";
import { Coin } from "../../../cosmos/base/v1beta1/coin_pb.js";
class MsgSetOrchestratorAddresses$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSetOrchestratorAddresses", [
      {
        no: 1,
        name: "sender",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 2,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "eth_address",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgSetOrchestratorAddresses", "cosmos.msg.v1.signer": ["sender"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.sender = "";
    message.orchestrator = "";
    message.ethAddress = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string sender */
        1:
          message.sender = reader.string();
          break;
        case /* string orchestrator */
        2:
          message.orchestrator = reader.string();
          break;
        case /* string eth_address */
        3:
          message.ethAddress = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.sender !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.sender);
    if (message.orchestrator !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.orchestrator);
    if (message.ethAddress !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.ethAddress);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSetOrchestratorAddresses = new MsgSetOrchestratorAddresses$Type();
class MsgSetOrchestratorAddressesResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSetOrchestratorAddressesResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSetOrchestratorAddressesResponse = new MsgSetOrchestratorAddressesResponse$Type();
class MsgValsetConfirm$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgValsetConfirm", [
      {
        no: 1,
        name: "nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "eth_address",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 4,
        name: "signature",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgValsetConfirm", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.nonce = 0n;
    message.orchestrator = "";
    message.ethAddress = "";
    message.signature = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 nonce */
        1:
          message.nonce = reader.uint64().toBigInt();
          break;
        case /* string orchestrator */
        2:
          message.orchestrator = reader.string();
          break;
        case /* string eth_address */
        3:
          message.ethAddress = reader.string();
          break;
        case /* string signature */
        4:
          message.signature = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.nonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.nonce);
    if (message.orchestrator !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.orchestrator);
    if (message.ethAddress !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.ethAddress);
    if (message.signature !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.signature);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgValsetConfirm = new MsgValsetConfirm$Type();
class MsgValsetConfirmResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgValsetConfirmResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgValsetConfirmResponse = new MsgValsetConfirmResponse$Type();
class MsgSendToEth$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSendToEth", [
      {
        no: 1,
        name: "sender",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 2,
        name: "eth_dest",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      { no: 3, name: "amount", kind: "message", T: () => Coin, options: { "gogoproto.nullable": false } },
      { no: 4, name: "bridge_fee", kind: "message", T: () => Coin, options: { "gogoproto.nullable": false } }
    ], { "amino.name": "peggy/MsgSendToEth", "cosmos.msg.v1.signer": ["sender"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.sender = "";
    message.ethDest = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string sender */
        1:
          message.sender = reader.string();
          break;
        case /* string eth_dest */
        2:
          message.ethDest = reader.string();
          break;
        case /* cosmos.base.v1beta1.Coin amount */
        3:
          message.amount = Coin.internalBinaryRead(reader, reader.uint32(), options, message.amount);
          break;
        case /* cosmos.base.v1beta1.Coin bridge_fee */
        4:
          message.bridgeFee = Coin.internalBinaryRead(reader, reader.uint32(), options, message.bridgeFee);
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.sender !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.sender);
    if (message.ethDest !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.ethDest);
    if (message.amount)
      Coin.internalBinaryWrite(message.amount, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
    if (message.bridgeFee)
      Coin.internalBinaryWrite(message.bridgeFee, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSendToEth = new MsgSendToEth$Type();
class MsgSendToEthResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSendToEthResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSendToEthResponse = new MsgSendToEthResponse$Type();
class MsgRequestBatch$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRequestBatch", [
      {
        no: 1,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 2,
        name: "denom",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgRequestBatch", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.orchestrator = "";
    message.denom = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string orchestrator */
        1:
          message.orchestrator = reader.string();
          break;
        case /* string denom */
        2:
          message.denom = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.orchestrator !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.orchestrator);
    if (message.denom !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.denom);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRequestBatch = new MsgRequestBatch$Type();
class MsgRequestBatchResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRequestBatchResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRequestBatchResponse = new MsgRequestBatchResponse$Type();
class MsgConfirmBatch$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgConfirmBatch", [
      {
        no: 1,
        name: "nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "token_contract",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "eth_signer",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 4,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 5,
        name: "signature",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgConfirmBatch", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.nonce = 0n;
    message.tokenContract = "";
    message.ethSigner = "";
    message.orchestrator = "";
    message.signature = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 nonce */
        1:
          message.nonce = reader.uint64().toBigInt();
          break;
        case /* string token_contract */
        2:
          message.tokenContract = reader.string();
          break;
        case /* string eth_signer */
        3:
          message.ethSigner = reader.string();
          break;
        case /* string orchestrator */
        4:
          message.orchestrator = reader.string();
          break;
        case /* string signature */
        5:
          message.signature = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.nonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.nonce);
    if (message.tokenContract !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.tokenContract);
    if (message.ethSigner !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.ethSigner);
    if (message.orchestrator !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.orchestrator);
    if (message.signature !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.signature);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgConfirmBatch = new MsgConfirmBatch$Type();
class MsgConfirmBatchResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgConfirmBatchResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgConfirmBatchResponse = new MsgConfirmBatchResponse$Type();
class MsgDepositClaim$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgDepositClaim", [
      {
        no: 1,
        name: "event_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "block_height",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 3,
        name: "token_contract",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      { no: 4, name: "amount", kind: "scalar", T: 9, options: { "gogoproto.nullable": false, "gogoproto.customtype": "cosmossdk.io/math.Int" } },
      {
        no: 5,
        name: "ethereum_sender",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 6,
        name: "cosmos_receiver",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 7,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 8,
        name: "data",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "cosmos_proto.implements_interface": ["peggy.v1beta1.EthereumClaim"], "amino.name": "peggy/MsgDepositClaim", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.eventNonce = 0n;
    message.blockHeight = 0n;
    message.tokenContract = "";
    message.amount = "";
    message.ethereumSender = "";
    message.cosmosReceiver = "";
    message.orchestrator = "";
    message.data = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 event_nonce */
        1:
          message.eventNonce = reader.uint64().toBigInt();
          break;
        case /* uint64 block_height */
        2:
          message.blockHeight = reader.uint64().toBigInt();
          break;
        case /* string token_contract */
        3:
          message.tokenContract = reader.string();
          break;
        case /* string amount */
        4:
          message.amount = reader.string();
          break;
        case /* string ethereum_sender */
        5:
          message.ethereumSender = reader.string();
          break;
        case /* string cosmos_receiver */
        6:
          message.cosmosReceiver = reader.string();
          break;
        case /* string orchestrator */
        7:
          message.orchestrator = reader.string();
          break;
        case /* string data */
        8:
          message.data = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.eventNonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.eventNonce);
    if (message.blockHeight !== 0n)
      writer.tag(2, WireType.Varint).uint64(message.blockHeight);
    if (message.tokenContract !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.tokenContract);
    if (message.amount !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.amount);
    if (message.ethereumSender !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.ethereumSender);
    if (message.cosmosReceiver !== "")
      writer.tag(6, WireType.LengthDelimited).string(message.cosmosReceiver);
    if (message.orchestrator !== "")
      writer.tag(7, WireType.LengthDelimited).string(message.orchestrator);
    if (message.data !== "")
      writer.tag(8, WireType.LengthDelimited).string(message.data);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgDepositClaim = new MsgDepositClaim$Type();
class MsgDepositClaimResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgDepositClaimResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgDepositClaimResponse = new MsgDepositClaimResponse$Type();
class MsgWithdrawClaim$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgWithdrawClaim", [
      {
        no: 1,
        name: "event_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "block_height",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 3,
        name: "batch_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 4,
        name: "token_contract",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 5,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "cosmos_proto.implements_interface": ["peggy.v1beta1.EthereumClaim"], "amino.name": "peggy/MsgWithdrawClaim", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.eventNonce = 0n;
    message.blockHeight = 0n;
    message.batchNonce = 0n;
    message.tokenContract = "";
    message.orchestrator = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 event_nonce */
        1:
          message.eventNonce = reader.uint64().toBigInt();
          break;
        case /* uint64 block_height */
        2:
          message.blockHeight = reader.uint64().toBigInt();
          break;
        case /* uint64 batch_nonce */
        3:
          message.batchNonce = reader.uint64().toBigInt();
          break;
        case /* string token_contract */
        4:
          message.tokenContract = reader.string();
          break;
        case /* string orchestrator */
        5:
          message.orchestrator = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.eventNonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.eventNonce);
    if (message.blockHeight !== 0n)
      writer.tag(2, WireType.Varint).uint64(message.blockHeight);
    if (message.batchNonce !== 0n)
      writer.tag(3, WireType.Varint).uint64(message.batchNonce);
    if (message.tokenContract !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.tokenContract);
    if (message.orchestrator !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.orchestrator);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgWithdrawClaim = new MsgWithdrawClaim$Type();
class MsgWithdrawClaimResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgWithdrawClaimResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgWithdrawClaimResponse = new MsgWithdrawClaimResponse$Type();
class MsgERC20DeployedClaim$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgERC20DeployedClaim", [
      {
        no: 1,
        name: "event_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "block_height",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 3,
        name: "cosmos_denom",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 4,
        name: "token_contract",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 5,
        name: "name",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 6,
        name: "symbol",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 7,
        name: "decimals",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 8,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "cosmos_proto.implements_interface": ["peggy.v1beta1.EthereumClaim"], "amino.name": "peggy/MsgERC20DeployedClaim", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.eventNonce = 0n;
    message.blockHeight = 0n;
    message.cosmosDenom = "";
    message.tokenContract = "";
    message.name = "";
    message.symbol = "";
    message.decimals = 0n;
    message.orchestrator = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 event_nonce */
        1:
          message.eventNonce = reader.uint64().toBigInt();
          break;
        case /* uint64 block_height */
        2:
          message.blockHeight = reader.uint64().toBigInt();
          break;
        case /* string cosmos_denom */
        3:
          message.cosmosDenom = reader.string();
          break;
        case /* string token_contract */
        4:
          message.tokenContract = reader.string();
          break;
        case /* string name */
        5:
          message.name = reader.string();
          break;
        case /* string symbol */
        6:
          message.symbol = reader.string();
          break;
        case /* uint64 decimals */
        7:
          message.decimals = reader.uint64().toBigInt();
          break;
        case /* string orchestrator */
        8:
          message.orchestrator = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.eventNonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.eventNonce);
    if (message.blockHeight !== 0n)
      writer.tag(2, WireType.Varint).uint64(message.blockHeight);
    if (message.cosmosDenom !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.cosmosDenom);
    if (message.tokenContract !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.tokenContract);
    if (message.name !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.name);
    if (message.symbol !== "")
      writer.tag(6, WireType.LengthDelimited).string(message.symbol);
    if (message.decimals !== 0n)
      writer.tag(7, WireType.Varint).uint64(message.decimals);
    if (message.orchestrator !== "")
      writer.tag(8, WireType.LengthDelimited).string(message.orchestrator);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgERC20DeployedClaim = new MsgERC20DeployedClaim$Type();
class MsgERC20DeployedClaimResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgERC20DeployedClaimResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgERC20DeployedClaimResponse = new MsgERC20DeployedClaimResponse$Type();
class MsgCancelSendToEth$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgCancelSendToEth", [
      {
        no: 1,
        name: "transaction_id",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "sender",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgCancelSendToEth", "cosmos.msg.v1.signer": ["sender"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.transactionId = 0n;
    message.sender = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 transaction_id */
        1:
          message.transactionId = reader.uint64().toBigInt();
          break;
        case /* string sender */
        2:
          message.sender = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.transactionId !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.transactionId);
    if (message.sender !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.sender);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgCancelSendToEth = new MsgCancelSendToEth$Type();
class MsgCancelSendToEthResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgCancelSendToEthResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgCancelSendToEthResponse = new MsgCancelSendToEthResponse$Type();
class MsgSubmitBadSignatureEvidence$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSubmitBadSignatureEvidence", [
      { no: 1, name: "subject", kind: "message", T: () => Any, options: { "cosmos_proto.accepts_interface": "injective.peggy.v1.EthereumSigned" } },
      {
        no: 2,
        name: "signature",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "sender",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgSubmitBadSignatureEvidence", "cosmos.msg.v1.signer": ["sender"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.signature = "";
    message.sender = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* google.protobuf.Any subject */
        1:
          message.subject = Any.internalBinaryRead(reader, reader.uint32(), options, message.subject);
          break;
        case /* string signature */
        2:
          message.signature = reader.string();
          break;
        case /* string sender */
        3:
          message.sender = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.subject)
      Any.internalBinaryWrite(message.subject, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
    if (message.signature !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.signature);
    if (message.sender !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.sender);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSubmitBadSignatureEvidence = new MsgSubmitBadSignatureEvidence$Type();
class MsgSubmitBadSignatureEvidenceResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgSubmitBadSignatureEvidenceResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgSubmitBadSignatureEvidenceResponse = new MsgSubmitBadSignatureEvidenceResponse$Type();
class MsgValsetUpdatedClaim$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgValsetUpdatedClaim", [
      {
        no: 1,
        name: "event_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 2,
        name: "valset_nonce",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      {
        no: 3,
        name: "block_height",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      { no: 4, name: "members", kind: "message", repeat: 2, T: () => BridgeValidator },
      { no: 5, name: "reward_amount", kind: "scalar", T: 9, options: { "gogoproto.nullable": false, "gogoproto.customtype": "cosmossdk.io/math.Int" } },
      {
        no: 6,
        name: "reward_token",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 7,
        name: "orchestrator",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "cosmos_proto.implements_interface": ["peggy.v1beta1.EthereumClaim"], "amino.name": "peggy/MsgValsetUpdatedClaim", "cosmos.msg.v1.signer": ["orchestrator"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.eventNonce = 0n;
    message.valsetNonce = 0n;
    message.blockHeight = 0n;
    message.members = [];
    message.rewardAmount = "";
    message.rewardToken = "";
    message.orchestrator = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* uint64 event_nonce */
        1:
          message.eventNonce = reader.uint64().toBigInt();
          break;
        case /* uint64 valset_nonce */
        2:
          message.valsetNonce = reader.uint64().toBigInt();
          break;
        case /* uint64 block_height */
        3:
          message.blockHeight = reader.uint64().toBigInt();
          break;
        case /* repeated injective.peggy.v1.BridgeValidator members */
        4:
          message.members.push(BridgeValidator.internalBinaryRead(reader, reader.uint32(), options));
          break;
        case /* string reward_amount */
        5:
          message.rewardAmount = reader.string();
          break;
        case /* string reward_token */
        6:
          message.rewardToken = reader.string();
          break;
        case /* string orchestrator */
        7:
          message.orchestrator = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.eventNonce !== 0n)
      writer.tag(1, WireType.Varint).uint64(message.eventNonce);
    if (message.valsetNonce !== 0n)
      writer.tag(2, WireType.Varint).uint64(message.valsetNonce);
    if (message.blockHeight !== 0n)
      writer.tag(3, WireType.Varint).uint64(message.blockHeight);
    for (let i = 0; i < message.members.length; i++)
      BridgeValidator.internalBinaryWrite(message.members[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
    if (message.rewardAmount !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.rewardAmount);
    if (message.rewardToken !== "")
      writer.tag(6, WireType.LengthDelimited).string(message.rewardToken);
    if (message.orchestrator !== "")
      writer.tag(7, WireType.LengthDelimited).string(message.orchestrator);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgValsetUpdatedClaim = new MsgValsetUpdatedClaim$Type();
class MsgValsetUpdatedClaimResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgValsetUpdatedClaimResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgValsetUpdatedClaimResponse = new MsgValsetUpdatedClaimResponse$Type();
class MsgUpdateParams$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgUpdateParams", [
      { no: 1, name: "authority", kind: "scalar", T: 9, options: { "cosmos_proto.scalar": "cosmos.AddressString" } },
      { no: 2, name: "params", kind: "message", T: () => Params, options: { "gogoproto.nullable": false } }
    ], { "amino.name": "peggy/MsgUpdateParams", "cosmos.msg.v1.signer": ["authority"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.authority = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string authority */
        1:
          message.authority = reader.string();
          break;
        case /* injective.peggy.v1.Params params */
        2:
          message.params = Params.internalBinaryRead(reader, reader.uint32(), options, message.params);
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.authority !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.authority);
    if (message.params)
      Params.internalBinaryWrite(message.params, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgUpdateParams = new MsgUpdateParams$Type();
class MsgUpdateParamsResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgUpdateParamsResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgUpdateParamsResponse = new MsgUpdateParamsResponse$Type();
class MsgBlacklistEthereumAddresses$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgBlacklistEthereumAddresses", [
      {
        no: 1,
        name: "signer",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 2,
        name: "blacklist_addresses",
        kind: "scalar",
        repeat: 2,
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgBlacklistEthereumAddresses", "cosmos.msg.v1.signer": ["signer"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.signer = "";
    message.blacklistAddresses = [];
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string signer */
        1:
          message.signer = reader.string();
          break;
        case /* repeated string blacklist_addresses */
        2:
          message.blacklistAddresses.push(reader.string());
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.signer !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.signer);
    for (let i = 0; i < message.blacklistAddresses.length; i++)
      writer.tag(2, WireType.LengthDelimited).string(message.blacklistAddresses[i]);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgBlacklistEthereumAddresses = new MsgBlacklistEthereumAddresses$Type();
class MsgBlacklistEthereumAddressesResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgBlacklistEthereumAddressesResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgBlacklistEthereumAddressesResponse = new MsgBlacklistEthereumAddressesResponse$Type();
class MsgRevokeEthereumBlacklist$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRevokeEthereumBlacklist", [
      {
        no: 1,
        name: "signer",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 2,
        name: "blacklist_addresses",
        kind: "scalar",
        repeat: 2,
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgRevokeEthereumBlacklist", "cosmos.msg.v1.signer": ["signer"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.signer = "";
    message.blacklistAddresses = [];
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string signer */
        1:
          message.signer = reader.string();
          break;
        case /* repeated string blacklist_addresses */
        2:
          message.blacklistAddresses.push(reader.string());
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.signer !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.signer);
    for (let i = 0; i < message.blacklistAddresses.length; i++)
      writer.tag(2, WireType.LengthDelimited).string(message.blacklistAddresses[i]);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRevokeEthereumBlacklist = new MsgRevokeEthereumBlacklist$Type();
class MsgRevokeEthereumBlacklistResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRevokeEthereumBlacklistResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRevokeEthereumBlacklistResponse = new MsgRevokeEthereumBlacklistResponse$Type();
class MsgCreateRateLimit$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgCreateRateLimit", [
      { no: 1, name: "authority", kind: "scalar", T: 9, options: { "cosmos_proto.scalar": "cosmos.AddressString" } },
      {
        no: 2,
        name: "token_address",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "token_decimals",
        kind: "scalar",
        T: 13
        /*ScalarType.UINT32*/
      },
      {
        no: 4,
        name: "token_price_id",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      { no: 5, name: "rate_limit_usd", kind: "scalar", T: 9, options: { "gogoproto.nullable": false, "gogoproto.customtype": "cosmossdk.io/math.LegacyDec" } },
      { no: 6, name: "absolute_mint_limit", kind: "scalar", T: 9, options: { "gogoproto.nullable": false, "gogoproto.customtype": "cosmossdk.io/math.Int" } },
      {
        no: 7,
        name: "rate_limit_window",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      { no: 8, name: "token_oracle_type", kind: "enum", T: () => ["injective.oracle.v1beta1.OracleType", OracleType] }
    ], { "amino.name": "peggy/MsgCreateRateLimit", "cosmos.msg.v1.signer": ["authority"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.authority = "";
    message.tokenAddress = "";
    message.tokenDecimals = 0;
    message.tokenPriceId = "";
    message.rateLimitUsd = "";
    message.absoluteMintLimit = "";
    message.rateLimitWindow = 0n;
    message.tokenOracleType = 0;
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string authority */
        1:
          message.authority = reader.string();
          break;
        case /* string token_address */
        2:
          message.tokenAddress = reader.string();
          break;
        case /* uint32 token_decimals */
        3:
          message.tokenDecimals = reader.uint32();
          break;
        case /* string token_price_id */
        4:
          message.tokenPriceId = reader.string();
          break;
        case /* string rate_limit_usd */
        5:
          message.rateLimitUsd = reader.string();
          break;
        case /* string absolute_mint_limit = 6 [deprecated = true] */
        6:
          message.absoluteMintLimit = reader.string();
          break;
        case /* uint64 rate_limit_window */
        7:
          message.rateLimitWindow = reader.uint64().toBigInt();
          break;
        case /* injective.oracle.v1beta1.OracleType token_oracle_type */
        8:
          message.tokenOracleType = reader.int32();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.authority !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.authority);
    if (message.tokenAddress !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.tokenAddress);
    if (message.tokenDecimals !== 0)
      writer.tag(3, WireType.Varint).uint32(message.tokenDecimals);
    if (message.tokenPriceId !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.tokenPriceId);
    if (message.rateLimitUsd !== "")
      writer.tag(5, WireType.LengthDelimited).string(message.rateLimitUsd);
    if (message.absoluteMintLimit !== "")
      writer.tag(6, WireType.LengthDelimited).string(message.absoluteMintLimit);
    if (message.rateLimitWindow !== 0n)
      writer.tag(7, WireType.Varint).uint64(message.rateLimitWindow);
    if (message.tokenOracleType !== 0)
      writer.tag(8, WireType.Varint).int32(message.tokenOracleType);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgCreateRateLimit = new MsgCreateRateLimit$Type();
class MsgCreateRateLimitResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgCreateRateLimitResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgCreateRateLimitResponse = new MsgCreateRateLimitResponse$Type();
class MsgUpdateRateLimit$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgUpdateRateLimit", [
      { no: 1, name: "authority", kind: "scalar", T: 9, options: { "cosmos_proto.scalar": "cosmos.AddressString" } },
      {
        no: 2,
        name: "token_address",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      {
        no: 3,
        name: "new_token_price_id",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      },
      { no: 4, name: "new_rate_limit_usd", kind: "scalar", T: 9, options: { "gogoproto.nullable": false, "gogoproto.customtype": "cosmossdk.io/math.LegacyDec" } },
      {
        no: 5,
        name: "new_rate_limit_window",
        kind: "scalar",
        T: 4,
        L: 0
        /*LongType.BIGINT*/
      },
      { no: 6, name: "new_token_oracle_type", kind: "enum", T: () => ["injective.oracle.v1beta1.OracleType", OracleType] }
    ], { "amino.name": "peggy/MsgUpdateRateLimit", "cosmos.msg.v1.signer": ["authority"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.authority = "";
    message.tokenAddress = "";
    message.newTokenPriceId = "";
    message.newRateLimitUsd = "";
    message.newRateLimitWindow = 0n;
    message.newTokenOracleType = 0;
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string authority */
        1:
          message.authority = reader.string();
          break;
        case /* string token_address */
        2:
          message.tokenAddress = reader.string();
          break;
        case /* string new_token_price_id */
        3:
          message.newTokenPriceId = reader.string();
          break;
        case /* string new_rate_limit_usd */
        4:
          message.newRateLimitUsd = reader.string();
          break;
        case /* uint64 new_rate_limit_window */
        5:
          message.newRateLimitWindow = reader.uint64().toBigInt();
          break;
        case /* injective.oracle.v1beta1.OracleType new_token_oracle_type */
        6:
          message.newTokenOracleType = reader.int32();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.authority !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.authority);
    if (message.tokenAddress !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.tokenAddress);
    if (message.newTokenPriceId !== "")
      writer.tag(3, WireType.LengthDelimited).string(message.newTokenPriceId);
    if (message.newRateLimitUsd !== "")
      writer.tag(4, WireType.LengthDelimited).string(message.newRateLimitUsd);
    if (message.newRateLimitWindow !== 0n)
      writer.tag(5, WireType.Varint).uint64(message.newRateLimitWindow);
    if (message.newTokenOracleType !== 0)
      writer.tag(6, WireType.Varint).int32(message.newTokenOracleType);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgUpdateRateLimit = new MsgUpdateRateLimit$Type();
class MsgUpdateRateLimitResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgUpdateRateLimitResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgUpdateRateLimitResponse = new MsgUpdateRateLimitResponse$Type();
class MsgRemoveRateLimit$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRemoveRateLimit", [
      { no: 1, name: "authority", kind: "scalar", T: 9, options: { "cosmos_proto.scalar": "cosmos.AddressString" } },
      {
        no: 2,
        name: "token_address",
        kind: "scalar",
        T: 9
        /*ScalarType.STRING*/
      }
    ], { "amino.name": "peggy/MsgRemoveRateLimit", "cosmos.msg.v1.signer": ["authority"] });
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    message.authority = "";
    message.tokenAddress = "";
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        case /* string authority */
        1:
          message.authority = reader.string();
          break;
        case /* string token_address */
        2:
          message.tokenAddress = reader.string();
          break;
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    if (message.authority !== "")
      writer.tag(1, WireType.LengthDelimited).string(message.authority);
    if (message.tokenAddress !== "")
      writer.tag(2, WireType.LengthDelimited).string(message.tokenAddress);
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRemoveRateLimit = new MsgRemoveRateLimit$Type();
class MsgRemoveRateLimitResponse$Type extends MessageType {
  constructor() {
    super("injective.peggy.v1.MsgRemoveRateLimitResponse", []);
  }
  create(value) {
    const message = globalThis.Object.create(this.messagePrototype);
    if (value !== void 0)
      reflectionMergePartial(this, message, value);
    return message;
  }
  internalBinaryRead(reader, length, options, target) {
    let message = target ?? this.create(), end = reader.pos + length;
    while (reader.pos < end) {
      let [fieldNo, wireType] = reader.tag();
      switch (fieldNo) {
        default:
          let u = options.readUnknownField;
          if (u === "throw")
            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
          let d = reader.skip(wireType);
          if (u !== false)
            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
      }
    }
    return message;
  }
  internalBinaryWrite(message, writer, options) {
    let u = options.writeUnknownFields;
    if (u !== false)
      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
    return writer;
  }
}
const MsgRemoveRateLimitResponse = new MsgRemoveRateLimitResponse$Type();
const Msg = new ServiceType("injective.peggy.v1.Msg", [
  { name: "ValsetConfirm", options: { "google.api.http": { post: "/injective/peggy/v1/valset_confirm" } }, I: MsgValsetConfirm, O: MsgValsetConfirmResponse },
  { name: "SendToEth", options: { "google.api.http": { post: "/injective/peggy/v1/send_to_eth" } }, I: MsgSendToEth, O: MsgSendToEthResponse },
  { name: "RequestBatch", options: { "google.api.http": { post: "/injective/peggy/v1/request_batch" } }, I: MsgRequestBatch, O: MsgRequestBatchResponse },
  { name: "ConfirmBatch", options: { "google.api.http": { post: "/injective/peggy/v1/confirm_batch" } }, I: MsgConfirmBatch, O: MsgConfirmBatchResponse },
  { name: "DepositClaim", options: { "google.api.http": { post: "/injective/peggy/v1/deposit_claim" } }, I: MsgDepositClaim, O: MsgDepositClaimResponse },
  { name: "WithdrawClaim", options: { "google.api.http": { post: "/injective/peggy/v1/withdraw_claim" } }, I: MsgWithdrawClaim, O: MsgWithdrawClaimResponse },
  { name: "ValsetUpdateClaim", options: { "google.api.http": { post: "/injective/peggy/v1/valset_updated_claim" } }, I: MsgValsetUpdatedClaim, O: MsgValsetUpdatedClaimResponse },
  { name: "ERC20DeployedClaim", options: { "google.api.http": { post: "/injective/peggy/v1/erc20_deployed_claim" } }, I: MsgERC20DeployedClaim, O: MsgERC20DeployedClaimResponse },
  { name: "SetOrchestratorAddresses", options: { "google.api.http": { post: "/injective/peggy/v1/set_orchestrator_address" } }, I: MsgSetOrchestratorAddresses, O: MsgSetOrchestratorAddressesResponse },
  { name: "CancelSendToEth", options: { "google.api.http": { post: "/injective/peggy/v1/cancel_send_to_eth" } }, I: MsgCancelSendToEth, O: MsgCancelSendToEthResponse },
  { name: "SubmitBadSignatureEvidence", options: { "google.api.http": { post: "/injective/peggy/v1/submit_bad_signature_evidence" } }, I: MsgSubmitBadSignatureEvidence, O: MsgSubmitBadSignatureEvidenceResponse },
  { name: "UpdateParams", options: {}, I: MsgUpdateParams, O: MsgUpdateParamsResponse },
  { name: "BlacklistEthereumAddresses", options: {}, I: MsgBlacklistEthereumAddresses, O: MsgBlacklistEthereumAddressesResponse },
  { name: "RevokeEthereumBlacklist", options: {}, I: MsgRevokeEthereumBlacklist, O: MsgRevokeEthereumBlacklistResponse },
  { name: "CreateRateLimit", options: {}, I: MsgCreateRateLimit, O: MsgCreateRateLimitResponse },
  { name: "UpdateRateLimit", options: {}, I: MsgUpdateRateLimit, O: MsgUpdateRateLimitResponse },
  { name: "RemoveRateLimit", options: {}, I: MsgRemoveRateLimit, O: MsgRemoveRateLimitResponse }
], { "cosmos.msg.v1.service": true });
export {
  Msg,
  MsgBlacklistEthereumAddresses,
  MsgBlacklistEthereumAddressesResponse,
  MsgCancelSendToEth,
  MsgCancelSendToEthResponse,
  MsgConfirmBatch,
  MsgConfirmBatchResponse,
  MsgCreateRateLimit,
  MsgCreateRateLimitResponse,
  MsgDepositClaim,
  MsgDepositClaimResponse,
  MsgERC20DeployedClaim,
  MsgERC20DeployedClaimResponse,
  MsgRemoveRateLimit,
  MsgRemoveRateLimitResponse,
  MsgRequestBatch,
  MsgRequestBatchResponse,
  MsgRevokeEthereumBlacklist,
  MsgRevokeEthereumBlacklistResponse,
  MsgSendToEth,
  MsgSendToEthResponse,
  MsgSetOrchestratorAddresses,
  MsgSetOrchestratorAddressesResponse,
  MsgSubmitBadSignatureEvidence,
  MsgSubmitBadSignatureEvidenceResponse,
  MsgUpdateParams,
  MsgUpdateParamsResponse,
  MsgUpdateRateLimit,
  MsgUpdateRateLimitResponse,
  MsgValsetConfirm,
  MsgValsetConfirmResponse,
  MsgValsetUpdatedClaim,
  MsgValsetUpdatedClaimResponse,
  MsgWithdrawClaim,
  MsgWithdrawClaimResponse
};
