@injectivelabs/indexer-proto-ts-v2 1.0.0

package/generated/injective_exchange_rpc_pb.js

@@ -0,0 +1,1740 @@
+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";
+class GetTxRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.GetTxRequest", [
+      {
+        no: 1,
+        name: "hash",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.hash = "";
+    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 hash */
+        1:
+          message.hash = 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.hash !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.hash);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetTxRequest = new GetTxRequest$Type();
+class GetTxResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.GetTxResponse", [
+      {
+        no: 1,
+        name: "tx_hash",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "index",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 4,
+        name: "codespace",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "code",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 6,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 7,
+        name: "raw_log",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "timestamp",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.txHash = "";
+    message.height = 0n;
+    message.index = 0;
+    message.codespace = "";
+    message.code = 0;
+    message.data = new Uint8Array(0);
+    message.rawLog = "";
+    message.timestamp = "";
+    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 tx_hash */
+        1:
+          message.txHash = reader.string();
+          break;
+        case /* sint64 height */
+        2:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* uint32 index */
+        3:
+          message.index = reader.uint32();
+          break;
+        case /* string codespace */
+        4:
+          message.codespace = reader.string();
+          break;
+        case /* uint32 code */
+        5:
+          message.code = reader.uint32();
+          break;
+        case /* bytes data */
+        6:
+          message.data = reader.bytes();
+          break;
+        case /* string raw_log */
+        7:
+          message.rawLog = reader.string();
+          break;
+        case /* string timestamp */
+        8:
+          message.timestamp = 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.txHash !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.txHash);
+    if (message.height !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.height);
+    if (message.index !== 0)
+      writer.tag(3, WireType.Varint).uint32(message.index);
+    if (message.codespace !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.codespace);
+    if (message.code !== 0)
+      writer.tag(5, WireType.Varint).uint32(message.code);
+    if (message.data.length)
+      writer.tag(6, WireType.LengthDelimited).bytes(message.data);
+    if (message.rawLog !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.rawLog);
+    if (message.timestamp !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.timestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const GetTxResponse = new GetTxResponse$Type();
+class PrepareTxRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareTxRequest", [
+      {
+        no: 1,
+        name: "chain_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "signer_address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "sequence",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "memo",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "timeout_height",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 6, name: "fee", kind: "message", T: () => CosmosTxFee },
+      {
+        no: 7,
+        name: "msgs",
+        kind: "scalar",
+        repeat: 2,
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 8,
+        name: "eip712_wrapper",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chainId = 0n;
+    message.signerAddress = "";
+    message.sequence = 0n;
+    message.memo = "";
+    message.timeoutHeight = 0n;
+    message.msgs = [];
+    message.eip712Wrapper = "";
+    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 chain_id */
+        1:
+          message.chainId = reader.uint64().toBigInt();
+          break;
+        case /* string signer_address */
+        2:
+          message.signerAddress = reader.string();
+          break;
+        case /* uint64 sequence */
+        3:
+          message.sequence = reader.uint64().toBigInt();
+          break;
+        case /* string memo */
+        4:
+          message.memo = reader.string();
+          break;
+        case /* uint64 timeout_height */
+        5:
+          message.timeoutHeight = reader.uint64().toBigInt();
+          break;
+        case /* injective_exchange_rpc.CosmosTxFee fee */
+        6:
+          message.fee = CosmosTxFee.internalBinaryRead(reader, reader.uint32(), options, message.fee);
+          break;
+        case /* repeated bytes msgs */
+        7:
+          message.msgs.push(reader.bytes());
+          break;
+        case /* string eip712_wrapper */
+        8:
+          message.eip712Wrapper = 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.chainId !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.chainId);
+    if (message.signerAddress !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.signerAddress);
+    if (message.sequence !== 0n)
+      writer.tag(3, WireType.Varint).uint64(message.sequence);
+    if (message.memo !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.memo);
+    if (message.timeoutHeight !== 0n)
+      writer.tag(5, WireType.Varint).uint64(message.timeoutHeight);
+    if (message.fee)
+      CosmosTxFee.internalBinaryWrite(message.fee, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.msgs.length; i++)
+      writer.tag(7, WireType.LengthDelimited).bytes(message.msgs[i]);
+    if (message.eip712Wrapper !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.eip712Wrapper);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareTxRequest = new PrepareTxRequest$Type();
+class CosmosTxFee$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.CosmosTxFee", [
+      { no: 1, name: "price", kind: "message", repeat: 2, T: () => CosmosCoin },
+      {
+        no: 2,
+        name: "gas",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "delegate_fee",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.price = [];
+    message.gas = 0n;
+    message.delegateFee = false;
+    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 /* repeated injective_exchange_rpc.CosmosCoin price */
+        1:
+          message.price.push(CosmosCoin.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* uint64 gas */
+        2:
+          message.gas = reader.uint64().toBigInt();
+          break;
+        case /* bool delegate_fee */
+        3:
+          message.delegateFee = reader.bool();
+          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) {
+    for (let i = 0; i < message.price.length; i++)
+      CosmosCoin.internalBinaryWrite(message.price[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    if (message.gas !== 0n)
+      writer.tag(2, WireType.Varint).uint64(message.gas);
+    if (message.delegateFee !== false)
+      writer.tag(3, WireType.Varint).bool(message.delegateFee);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const CosmosTxFee = new CosmosTxFee$Type();
+class CosmosCoin$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.CosmosCoin", [
+      {
+        no: 1,
+        name: "denom",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.denom = "";
+    message.amount = "";
+    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 denom */
+        1:
+          message.denom = reader.string();
+          break;
+        case /* string amount */
+        2:
+          message.amount = 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.denom !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.denom);
+    if (message.amount !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.amount);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const CosmosCoin = new CosmosCoin$Type();
+class PrepareTxResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareTxResponse", [
+      {
+        no: 1,
+        name: "data",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "sequence",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "sign_mode",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "pub_key_type",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "fee_payer",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "fee_payer_sig",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.data = "";
+    message.sequence = 0n;
+    message.signMode = "";
+    message.pubKeyType = "";
+    message.feePayer = "";
+    message.feePayerSig = "";
+    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 data */
+        1:
+          message.data = reader.string();
+          break;
+        case /* uint64 sequence */
+        2:
+          message.sequence = reader.uint64().toBigInt();
+          break;
+        case /* string sign_mode */
+        3:
+          message.signMode = reader.string();
+          break;
+        case /* string pub_key_type */
+        4:
+          message.pubKeyType = reader.string();
+          break;
+        case /* string fee_payer */
+        5:
+          message.feePayer = reader.string();
+          break;
+        case /* string fee_payer_sig */
+        6:
+          message.feePayerSig = 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.data !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.data);
+    if (message.sequence !== 0n)
+      writer.tag(2, WireType.Varint).uint64(message.sequence);
+    if (message.signMode !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.signMode);
+    if (message.pubKeyType !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.pubKeyType);
+    if (message.feePayer !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.feePayer);
+    if (message.feePayerSig !== "")
+      writer.tag(6, WireType.LengthDelimited).string(message.feePayerSig);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareTxResponse = new PrepareTxResponse$Type();
+class PrepareEip712Request$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareEip712Request", [
+      {
+        no: 1,
+        name: "chain_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "signer_address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "sequence",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "account_number",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "memo",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "timeout_height",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 7, name: "fee", kind: "message", T: () => CosmosTxFee },
+      {
+        no: 8,
+        name: "msgs",
+        kind: "scalar",
+        repeat: 2,
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 9,
+        name: "eip712_wrapper",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chainId = 0n;
+    message.signerAddress = "";
+    message.sequence = 0n;
+    message.accountNumber = 0n;
+    message.memo = "";
+    message.timeoutHeight = 0n;
+    message.msgs = [];
+    message.eip712Wrapper = "";
+    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 chain_id */
+        1:
+          message.chainId = reader.uint64().toBigInt();
+          break;
+        case /* string signer_address */
+        2:
+          message.signerAddress = reader.string();
+          break;
+        case /* uint64 sequence */
+        3:
+          message.sequence = reader.uint64().toBigInt();
+          break;
+        case /* uint64 account_number */
+        4:
+          message.accountNumber = reader.uint64().toBigInt();
+          break;
+        case /* string memo */
+        5:
+          message.memo = reader.string();
+          break;
+        case /* uint64 timeout_height */
+        6:
+          message.timeoutHeight = reader.uint64().toBigInt();
+          break;
+        case /* injective_exchange_rpc.CosmosTxFee fee */
+        7:
+          message.fee = CosmosTxFee.internalBinaryRead(reader, reader.uint32(), options, message.fee);
+          break;
+        case /* repeated bytes msgs */
+        8:
+          message.msgs.push(reader.bytes());
+          break;
+        case /* string eip712_wrapper */
+        9:
+          message.eip712Wrapper = 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.chainId !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.chainId);
+    if (message.signerAddress !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.signerAddress);
+    if (message.sequence !== 0n)
+      writer.tag(3, WireType.Varint).uint64(message.sequence);
+    if (message.accountNumber !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.accountNumber);
+    if (message.memo !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.memo);
+    if (message.timeoutHeight !== 0n)
+      writer.tag(6, WireType.Varint).uint64(message.timeoutHeight);
+    if (message.fee)
+      CosmosTxFee.internalBinaryWrite(message.fee, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.msgs.length; i++)
+      writer.tag(8, WireType.LengthDelimited).bytes(message.msgs[i]);
+    if (message.eip712Wrapper !== "")
+      writer.tag(9, WireType.LengthDelimited).string(message.eip712Wrapper);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareEip712Request = new PrepareEip712Request$Type();
+class PrepareEip712Response$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareEip712Response", [
+      {
+        no: 1,
+        name: "data",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    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 /* string data */
+        1:
+          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.data !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.data);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareEip712Response = new PrepareEip712Response$Type();
+class BroadcastTxRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.BroadcastTxRequest", [
+      {
+        no: 1,
+        name: "chain_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "tx",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 3,
+        name: "msgs",
+        kind: "scalar",
+        repeat: 2,
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      { no: 4, name: "pub_key", kind: "message", T: () => CosmosPubKey },
+      {
+        no: 5,
+        name: "signature",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "fee_payer",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "fee_payer_sig",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "mode",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chainId = 0n;
+    message.tx = new Uint8Array(0);
+    message.msgs = [];
+    message.signature = "";
+    message.feePayer = "";
+    message.feePayerSig = "";
+    message.mode = "";
+    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 chain_id */
+        1:
+          message.chainId = reader.uint64().toBigInt();
+          break;
+        case /* bytes tx */
+        2:
+          message.tx = reader.bytes();
+          break;
+        case /* repeated bytes msgs */
+        3:
+          message.msgs.push(reader.bytes());
+          break;
+        case /* injective_exchange_rpc.CosmosPubKey pub_key */
+        4:
+          message.pubKey = CosmosPubKey.internalBinaryRead(reader, reader.uint32(), options, message.pubKey);
+          break;
+        case /* string signature */
+        5:
+          message.signature = reader.string();
+          break;
+        case /* string fee_payer */
+        6:
+          message.feePayer = reader.string();
+          break;
+        case /* string fee_payer_sig */
+        7:
+          message.feePayerSig = reader.string();
+          break;
+        case /* string mode */
+        8:
+          message.mode = 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.chainId !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.chainId);
+    if (message.tx.length)
+      writer.tag(2, WireType.LengthDelimited).bytes(message.tx);
+    for (let i = 0; i < message.msgs.length; i++)
+      writer.tag(3, WireType.LengthDelimited).bytes(message.msgs[i]);
+    if (message.pubKey)
+      CosmosPubKey.internalBinaryWrite(message.pubKey, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+    if (message.signature !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.signature);
+    if (message.feePayer !== "")
+      writer.tag(6, WireType.LengthDelimited).string(message.feePayer);
+    if (message.feePayerSig !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.feePayerSig);
+    if (message.mode !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.mode);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BroadcastTxRequest = new BroadcastTxRequest$Type();
+class CosmosPubKey$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.CosmosPubKey", [
+      {
+        no: 1,
+        name: "type",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "key",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.type = "";
+    message.key = "";
+    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 type */
+        1:
+          message.type = reader.string();
+          break;
+        case /* string key */
+        2:
+          message.key = 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.type !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.type);
+    if (message.key !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.key);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const CosmosPubKey = new CosmosPubKey$Type();
+class BroadcastTxResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.BroadcastTxResponse", [
+      {
+        no: 1,
+        name: "tx_hash",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "index",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 4,
+        name: "codespace",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "code",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 6,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 7,
+        name: "raw_log",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "timestamp",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.txHash = "";
+    message.height = 0n;
+    message.index = 0;
+    message.codespace = "";
+    message.code = 0;
+    message.data = new Uint8Array(0);
+    message.rawLog = "";
+    message.timestamp = "";
+    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 tx_hash */
+        1:
+          message.txHash = reader.string();
+          break;
+        case /* sint64 height */
+        2:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* uint32 index */
+        3:
+          message.index = reader.uint32();
+          break;
+        case /* string codespace */
+        4:
+          message.codespace = reader.string();
+          break;
+        case /* uint32 code */
+        5:
+          message.code = reader.uint32();
+          break;
+        case /* bytes data */
+        6:
+          message.data = reader.bytes();
+          break;
+        case /* string raw_log */
+        7:
+          message.rawLog = reader.string();
+          break;
+        case /* string timestamp */
+        8:
+          message.timestamp = 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.txHash !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.txHash);
+    if (message.height !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.height);
+    if (message.index !== 0)
+      writer.tag(3, WireType.Varint).uint32(message.index);
+    if (message.codespace !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.codespace);
+    if (message.code !== 0)
+      writer.tag(5, WireType.Varint).uint32(message.code);
+    if (message.data.length)
+      writer.tag(6, WireType.LengthDelimited).bytes(message.data);
+    if (message.rawLog !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.rawLog);
+    if (message.timestamp !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.timestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BroadcastTxResponse = new BroadcastTxResponse$Type();
+class PrepareCosmosTxRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareCosmosTxRequest", [
+      {
+        no: 1,
+        name: "chain_id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "sender_address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "memo",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "timeout_height",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 5, name: "fee", kind: "message", T: () => CosmosTxFee },
+      {
+        no: 6,
+        name: "msgs",
+        kind: "scalar",
+        repeat: 2,
+        T: 12
+        /*ScalarType.BYTES*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.chainId = 0n;
+    message.senderAddress = "";
+    message.memo = "";
+    message.timeoutHeight = 0n;
+    message.msgs = [];
+    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 chain_id */
+        1:
+          message.chainId = reader.uint64().toBigInt();
+          break;
+        case /* string sender_address */
+        2:
+          message.senderAddress = reader.string();
+          break;
+        case /* string memo */
+        3:
+          message.memo = reader.string();
+          break;
+        case /* uint64 timeout_height */
+        4:
+          message.timeoutHeight = reader.uint64().toBigInt();
+          break;
+        case /* injective_exchange_rpc.CosmosTxFee fee */
+        5:
+          message.fee = CosmosTxFee.internalBinaryRead(reader, reader.uint32(), options, message.fee);
+          break;
+        case /* repeated bytes msgs */
+        6:
+          message.msgs.push(reader.bytes());
+          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.chainId !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.chainId);
+    if (message.senderAddress !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.senderAddress);
+    if (message.memo !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.memo);
+    if (message.timeoutHeight !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.timeoutHeight);
+    if (message.fee)
+      CosmosTxFee.internalBinaryWrite(message.fee, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.msgs.length; i++)
+      writer.tag(6, WireType.LengthDelimited).bytes(message.msgs[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareCosmosTxRequest = new PrepareCosmosTxRequest$Type();
+class PrepareCosmosTxResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.PrepareCosmosTxResponse", [
+      {
+        no: 1,
+        name: "tx",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 2,
+        name: "sign_mode",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "pub_key_type",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "fee_payer",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "fee_payer_sig",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 6, name: "fee_payer_pub_key", kind: "message", T: () => CosmosPubKey }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tx = new Uint8Array(0);
+    message.signMode = "";
+    message.pubKeyType = "";
+    message.feePayer = "";
+    message.feePayerSig = "";
+    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 /* bytes tx */
+        1:
+          message.tx = reader.bytes();
+          break;
+        case /* string sign_mode */
+        2:
+          message.signMode = reader.string();
+          break;
+        case /* string pub_key_type */
+        3:
+          message.pubKeyType = reader.string();
+          break;
+        case /* string fee_payer */
+        4:
+          message.feePayer = reader.string();
+          break;
+        case /* string fee_payer_sig */
+        5:
+          message.feePayerSig = reader.string();
+          break;
+        case /* injective_exchange_rpc.CosmosPubKey fee_payer_pub_key */
+        6:
+          message.feePayerPubKey = CosmosPubKey.internalBinaryRead(reader, reader.uint32(), options, message.feePayerPubKey);
+          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.tx.length)
+      writer.tag(1, WireType.LengthDelimited).bytes(message.tx);
+    if (message.signMode !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.signMode);
+    if (message.pubKeyType !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.pubKeyType);
+    if (message.feePayer !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.feePayer);
+    if (message.feePayerSig !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.feePayerSig);
+    if (message.feePayerPubKey)
+      CosmosPubKey.internalBinaryWrite(message.feePayerPubKey, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const PrepareCosmosTxResponse = new PrepareCosmosTxResponse$Type();
+class BroadcastCosmosTxRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.BroadcastCosmosTxRequest", [
+      {
+        no: 1,
+        name: "tx",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      { no: 2, name: "pub_key", kind: "message", T: () => CosmosPubKey },
+      {
+        no: 3,
+        name: "signature",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "sender_address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tx = new Uint8Array(0);
+    message.signature = "";
+    message.senderAddress = "";
+    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 /* bytes tx */
+        1:
+          message.tx = reader.bytes();
+          break;
+        case /* injective_exchange_rpc.CosmosPubKey pub_key */
+        2:
+          message.pubKey = CosmosPubKey.internalBinaryRead(reader, reader.uint32(), options, message.pubKey);
+          break;
+        case /* string signature */
+        3:
+          message.signature = reader.string();
+          break;
+        case /* string sender_address */
+        4:
+          message.senderAddress = 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.tx.length)
+      writer.tag(1, WireType.LengthDelimited).bytes(message.tx);
+    if (message.pubKey)
+      CosmosPubKey.internalBinaryWrite(message.pubKey, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.signature !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.signature);
+    if (message.senderAddress !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.senderAddress);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BroadcastCosmosTxRequest = new BroadcastCosmosTxRequest$Type();
+class BroadcastCosmosTxResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.BroadcastCosmosTxResponse", [
+      {
+        no: 1,
+        name: "tx_hash",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "height",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "index",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 4,
+        name: "codespace",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "code",
+        kind: "scalar",
+        T: 13
+        /*ScalarType.UINT32*/
+      },
+      {
+        no: 6,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      },
+      {
+        no: 7,
+        name: "raw_log",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "timestamp",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.txHash = "";
+    message.height = 0n;
+    message.index = 0;
+    message.codespace = "";
+    message.code = 0;
+    message.data = new Uint8Array(0);
+    message.rawLog = "";
+    message.timestamp = "";
+    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 tx_hash */
+        1:
+          message.txHash = reader.string();
+          break;
+        case /* sint64 height */
+        2:
+          message.height = reader.sint64().toBigInt();
+          break;
+        case /* uint32 index */
+        3:
+          message.index = reader.uint32();
+          break;
+        case /* string codespace */
+        4:
+          message.codespace = reader.string();
+          break;
+        case /* uint32 code */
+        5:
+          message.code = reader.uint32();
+          break;
+        case /* bytes data */
+        6:
+          message.data = reader.bytes();
+          break;
+        case /* string raw_log */
+        7:
+          message.rawLog = reader.string();
+          break;
+        case /* string timestamp */
+        8:
+          message.timestamp = 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.txHash !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.txHash);
+    if (message.height !== 0n)
+      writer.tag(2, WireType.Varint).sint64(message.height);
+    if (message.index !== 0)
+      writer.tag(3, WireType.Varint).uint32(message.index);
+    if (message.codespace !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.codespace);
+    if (message.code !== 0)
+      writer.tag(5, WireType.Varint).uint32(message.code);
+    if (message.data.length)
+      writer.tag(6, WireType.LengthDelimited).bytes(message.data);
+    if (message.rawLog !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.rawLog);
+    if (message.timestamp !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.timestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const BroadcastCosmosTxResponse = new BroadcastCosmosTxResponse$Type();
+class GetFeePayerRequest$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.GetFeePayerRequest", []);
+  }
+  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 GetFeePayerRequest = new GetFeePayerRequest$Type();
+class GetFeePayerResponse$Type extends MessageType {
+  constructor() {
+    super("injective_exchange_rpc.GetFeePayerResponse", [
+      {
+        no: 1,
+        name: "fee_payer",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "fee_payer_pub_key", kind: "message", T: () => CosmosPubKey }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.feePayer = "";
+    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 fee_payer */
+        1:
+          message.feePayer = reader.string();
+          break;
+        case /* injective_exchange_rpc.CosmosPubKey fee_payer_pub_key */
+        2:
+          message.feePayerPubKey = CosmosPubKey.internalBinaryRead(reader, reader.uint32(), options, message.feePayerPubKey);
+          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.feePayer !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.feePayer);
+    if (message.feePayerPubKey)
+      CosmosPubKey.internalBinaryWrite(message.feePayerPubKey, 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 GetFeePayerResponse = new GetFeePayerResponse$Type();
+const InjectiveExchangeRPC = new ServiceType("injective_exchange_rpc.InjectiveExchangeRPC", [
+  { name: "GetTx", options: {}, I: GetTxRequest, O: GetTxResponse },
+  { name: "PrepareTx", options: {}, I: PrepareTxRequest, O: PrepareTxResponse },
+  { name: "PrepareEip712", options: {}, I: PrepareEip712Request, O: PrepareEip712Response },
+  { name: "BroadcastTx", options: {}, I: BroadcastTxRequest, O: BroadcastTxResponse },
+  { name: "PrepareCosmosTx", options: {}, I: PrepareCosmosTxRequest, O: PrepareCosmosTxResponse },
+  { name: "BroadcastCosmosTx", options: {}, I: BroadcastCosmosTxRequest, O: BroadcastCosmosTxResponse },
+  { name: "GetFeePayer", options: {}, I: GetFeePayerRequest, O: GetFeePayerResponse }
+]);
+export {
+  BroadcastCosmosTxRequest,
+  BroadcastCosmosTxResponse,
+  BroadcastTxRequest,
+  BroadcastTxResponse,
+  CosmosCoin,
+  CosmosPubKey,
+  CosmosTxFee,
+  GetFeePayerRequest,
+  GetFeePayerResponse,
+  GetTxRequest,
+  GetTxResponse,
+  InjectiveExchangeRPC,
+  PrepareCosmosTxRequest,
+  PrepareCosmosTxResponse,
+  PrepareEip712Request,
+  PrepareEip712Response,
+  PrepareTxRequest,
+  PrepareTxResponse
+};