@injectivelabs/indexer-proto-ts-v2 1.0.0

package/generated/injective_auction_rpc_pb.js

@@ -0,0 +1,1917 @@
+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 AuctionEndpointRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionEndpointRequest", [
+      {
+        no: 1,
+        name: "round",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.round = 0n;
+    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 /* sint64 round */
+        1:
+          message.round = reader.sint64().toBigInt();
+          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.round !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.round);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionEndpointRequest = new AuctionEndpointRequest$Type();
+class AuctionEndpointResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionEndpointResponse", [
+      { no: 1, name: "auction", kind: "message", T: () => Auction },
+      { no: 2, name: "bids", kind: "message", repeat: 2, T: () => Bid }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.bids = [];
+    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 /* injective_auction_rpc.Auction auction */
+        1:
+          message.auction = Auction.internalBinaryRead(reader, reader.uint32(), options, message.auction);
+          break;
+        case /* repeated injective_auction_rpc.Bid bids */
+        2:
+          message.bids.push(Bid.internalBinaryRead(reader, reader.uint32(), options));
+          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.auction)
+      Auction.internalBinaryWrite(message.auction, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.bids.length; i++)
+      Bid.internalBinaryWrite(message.bids[i], 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 AuctionEndpointResponse = new AuctionEndpointResponse$Type();
+class Auction$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.Auction", [
+      {
+        no: 1,
+        name: "winner",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "basket", kind: "message", repeat: 2, T: () => Coin },
+      {
+        no: 3,
+        name: "winning_bid_amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "round",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "end_timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 6,
+        name: "updated_at",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 7, name: "contract", kind: "message", T: () => AuctionContract }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.winner = "";
+    message.basket = [];
+    message.winningBidAmount = "";
+    message.round = 0n;
+    message.endTimestamp = 0n;
+    message.updatedAt = 0n;
+    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 winner */
+        1:
+          message.winner = reader.string();
+          break;
+        case /* repeated injective_auction_rpc.Coin basket */
+        2:
+          message.basket.push(Coin.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* string winning_bid_amount */
+        3:
+          message.winningBidAmount = reader.string();
+          break;
+        case /* uint64 round */
+        4:
+          message.round = reader.uint64().toBigInt();
+          break;
+        case /* sint64 end_timestamp */
+        5:
+          message.endTimestamp = reader.sint64().toBigInt();
+          break;
+        case /* sint64 updated_at */
+        6:
+          message.updatedAt = reader.sint64().toBigInt();
+          break;
+        case /* injective_auction_rpc.AuctionContract contract */
+        7:
+          message.contract = AuctionContract.internalBinaryRead(reader, reader.uint32(), options, message.contract);
+          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.winner !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.winner);
+    for (let i = 0; i < message.basket.length; i++)
+      Coin.internalBinaryWrite(message.basket[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.winningBidAmount !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.winningBidAmount);
+    if (message.round !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.round);
+    if (message.endTimestamp !== 0n)
+      writer.tag(5, WireType.Varint).sint64(message.endTimestamp);
+    if (message.updatedAt !== 0n)
+      writer.tag(6, WireType.Varint).sint64(message.updatedAt);
+    if (message.contract)
+      AuctionContract.internalBinaryWrite(message.contract, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const Auction = new Auction$Type();
+class Coin$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.Coin", [
+      {
+        no: 1,
+        name: "denom",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "usd_value",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.denom = "";
+    message.amount = "";
+    message.usdValue = "";
+    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;
+        case /* string usd_value */
+        3:
+          message.usdValue = 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);
+    if (message.usdValue !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.usdValue);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const Coin = new Coin$Type();
+class AuctionContract$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionContract", [
+      {
+        no: 1,
+        name: "id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "bid_target",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "current_slots",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "total_slots",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "max_user_allocation",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "total_committed",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "whitelist_addresses",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "start_timestamp",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 9,
+        name: "end_timestamp",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 10,
+        name: "max_round_allocation",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 11,
+        name: "is_bid_placed",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.bidTarget = "";
+    message.currentSlots = 0n;
+    message.totalSlots = 0n;
+    message.maxUserAllocation = "";
+    message.totalCommitted = "";
+    message.whitelistAddresses = [];
+    message.startTimestamp = 0n;
+    message.endTimestamp = 0n;
+    message.maxRoundAllocation = "";
+    message.isBidPlaced = 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 /* uint64 id */
+        1:
+          message.id = reader.uint64().toBigInt();
+          break;
+        case /* string bid_target */
+        2:
+          message.bidTarget = reader.string();
+          break;
+        case /* uint64 current_slots */
+        3:
+          message.currentSlots = reader.uint64().toBigInt();
+          break;
+        case /* uint64 total_slots */
+        4:
+          message.totalSlots = reader.uint64().toBigInt();
+          break;
+        case /* string max_user_allocation */
+        5:
+          message.maxUserAllocation = reader.string();
+          break;
+        case /* string total_committed */
+        6:
+          message.totalCommitted = reader.string();
+          break;
+        case /* repeated string whitelist_addresses */
+        7:
+          message.whitelistAddresses.push(reader.string());
+          break;
+        case /* uint64 start_timestamp */
+        8:
+          message.startTimestamp = reader.uint64().toBigInt();
+          break;
+        case /* uint64 end_timestamp */
+        9:
+          message.endTimestamp = reader.uint64().toBigInt();
+          break;
+        case /* string max_round_allocation */
+        10:
+          message.maxRoundAllocation = reader.string();
+          break;
+        case /* bool is_bid_placed */
+        11:
+          message.isBidPlaced = 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) {
+    if (message.id !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.id);
+    if (message.bidTarget !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.bidTarget);
+    if (message.currentSlots !== 0n)
+      writer.tag(3, WireType.Varint).uint64(message.currentSlots);
+    if (message.totalSlots !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.totalSlots);
+    if (message.maxUserAllocation !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.maxUserAllocation);
+    if (message.totalCommitted !== "")
+      writer.tag(6, WireType.LengthDelimited).string(message.totalCommitted);
+    for (let i = 0; i < message.whitelistAddresses.length; i++)
+      writer.tag(7, WireType.LengthDelimited).string(message.whitelistAddresses[i]);
+    if (message.startTimestamp !== 0n)
+      writer.tag(8, WireType.Varint).uint64(message.startTimestamp);
+    if (message.endTimestamp !== 0n)
+      writer.tag(9, WireType.Varint).uint64(message.endTimestamp);
+    if (message.maxRoundAllocation !== "")
+      writer.tag(10, WireType.LengthDelimited).string(message.maxRoundAllocation);
+    if (message.isBidPlaced !== false)
+      writer.tag(11, WireType.Varint).bool(message.isBidPlaced);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionContract = new AuctionContract$Type();
+class Bid$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.Bid", [
+      {
+        no: 1,
+        name: "bidder",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.bidder = "";
+    message.amount = "";
+    message.timestamp = 0n;
+    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 bidder */
+        1:
+          message.bidder = reader.string();
+          break;
+        case /* string amount */
+        2:
+          message.amount = reader.string();
+          break;
+        case /* sint64 timestamp */
+        3:
+          message.timestamp = reader.sint64().toBigInt();
+          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.bidder !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.bidder);
+    if (message.amount !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.amount);
+    if (message.timestamp !== 0n)
+      writer.tag(3, WireType.Varint).sint64(message.timestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const Bid = new Bid$Type();
+class AuctionsRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsRequest", []);
+  }
+  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 AuctionsRequest = new AuctionsRequest$Type();
+class AuctionsResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsResponse", [
+      { no: 1, name: "auctions", kind: "message", repeat: 2, T: () => Auction }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.auctions = [];
+    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_auction_rpc.Auction auctions */
+        1:
+          message.auctions.push(Auction.internalBinaryRead(reader, reader.uint32(), options));
+          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.auctions.length; i++)
+      Auction.internalBinaryWrite(message.auctions[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionsResponse = new AuctionsResponse$Type();
+class AuctionsHistoryV2Request$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsHistoryV2Request", [
+      {
+        no: 1,
+        name: "per_page",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 2,
+        name: "token",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "end_time",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.perPage = 0;
+    message.token = "";
+    message.endTime = 0n;
+    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 /* sint32 per_page */
+        1:
+          message.perPage = reader.sint32();
+          break;
+        case /* string token */
+        2:
+          message.token = reader.string();
+          break;
+        case /* sint64 end_time */
+        3:
+          message.endTime = reader.sint64().toBigInt();
+          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.perPage !== 0)
+      writer.tag(1, WireType.Varint).sint32(message.perPage);
+    if (message.token !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.token);
+    if (message.endTime !== 0n)
+      writer.tag(3, WireType.Varint).sint64(message.endTime);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionsHistoryV2Request = new AuctionsHistoryV2Request$Type();
+class AuctionsHistoryV2Response$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsHistoryV2Response", [
+      { no: 1, name: "auctions", kind: "message", repeat: 2, T: () => AuctionV2Result },
+      {
+        no: 2,
+        name: "next",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.auctions = [];
+    message.next = [];
+    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_auction_rpc.AuctionV2Result auctions */
+        1:
+          message.auctions.push(AuctionV2Result.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated string next */
+        2:
+          message.next.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) {
+    for (let i = 0; i < message.auctions.length; i++)
+      AuctionV2Result.internalBinaryWrite(message.auctions[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.next.length; i++)
+      writer.tag(2, WireType.LengthDelimited).string(message.next[i]);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionsHistoryV2Response = new AuctionsHistoryV2Response$Type();
+class AuctionV2Result$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionV2Result", [
+      {
+        no: 1,
+        name: "winner",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "basket", kind: "message", repeat: 2, T: () => CoinPrices },
+      {
+        no: 3,
+        name: "winning_bid_amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "round",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "end_timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 6,
+        name: "updated_at",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 7, name: "contract", kind: "message", T: () => AuctionContract },
+      {
+        no: 8,
+        name: "winning_bid_amount_usd",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.winner = "";
+    message.basket = [];
+    message.winningBidAmount = "";
+    message.round = 0n;
+    message.endTimestamp = 0n;
+    message.updatedAt = 0n;
+    message.winningBidAmountUsd = "";
+    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 winner */
+        1:
+          message.winner = reader.string();
+          break;
+        case /* repeated injective_auction_rpc.CoinPrices basket */
+        2:
+          message.basket.push(CoinPrices.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* string winning_bid_amount */
+        3:
+          message.winningBidAmount = reader.string();
+          break;
+        case /* uint64 round */
+        4:
+          message.round = reader.uint64().toBigInt();
+          break;
+        case /* sint64 end_timestamp */
+        5:
+          message.endTimestamp = reader.sint64().toBigInt();
+          break;
+        case /* sint64 updated_at */
+        6:
+          message.updatedAt = reader.sint64().toBigInt();
+          break;
+        case /* injective_auction_rpc.AuctionContract contract */
+        7:
+          message.contract = AuctionContract.internalBinaryRead(reader, reader.uint32(), options, message.contract);
+          break;
+        case /* string winning_bid_amount_usd */
+        8:
+          message.winningBidAmountUsd = 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.winner !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.winner);
+    for (let i = 0; i < message.basket.length; i++)
+      CoinPrices.internalBinaryWrite(message.basket[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.winningBidAmount !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.winningBidAmount);
+    if (message.round !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.round);
+    if (message.endTimestamp !== 0n)
+      writer.tag(5, WireType.Varint).sint64(message.endTimestamp);
+    if (message.updatedAt !== 0n)
+      writer.tag(6, WireType.Varint).sint64(message.updatedAt);
+    if (message.contract)
+      AuctionContract.internalBinaryWrite(message.contract, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    if (message.winningBidAmountUsd !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.winningBidAmountUsd);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionV2Result = new AuctionV2Result$Type();
+class CoinPrices$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.CoinPrices", [
+      {
+        no: 1,
+        name: "denom",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 3, name: "prices", kind: "map", K: 9, V: {
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      } }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.denom = "";
+    message.amount = "";
+    message.prices = {};
+    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;
+        case /* map<string, string> prices */
+        3:
+          this.binaryReadMap3(message.prices, reader, options);
+          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;
+  }
+  binaryReadMap3(map, reader, options) {
+    let len = reader.uint32(), end = reader.pos + len, key, val;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case 1:
+          key = reader.string();
+          break;
+        case 2:
+          val = reader.string();
+          break;
+        default:
+          throw new globalThis.Error("unknown map entry field for injective_auction_rpc.CoinPrices.prices");
+      }
+    }
+    map[key ?? ""] = val ?? "";
+  }
+  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);
+    for (let k of globalThis.Object.keys(message.prices))
+      writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.prices[k]).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const CoinPrices = new CoinPrices$Type();
+class AuctionV2Request$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionV2Request", [
+      {
+        no: 1,
+        name: "round",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.round = 0n;
+    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 /* sint64 round */
+        1:
+          message.round = reader.sint64().toBigInt();
+          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.round !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.round);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionV2Request = new AuctionV2Request$Type();
+class AuctionV2Response$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionV2Response", [
+      {
+        no: 1,
+        name: "winner",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "basket", kind: "message", repeat: 2, T: () => CoinPrices },
+      {
+        no: 3,
+        name: "winning_bid_amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "round",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 5,
+        name: "end_timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 6,
+        name: "updated_at",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      { no: 7, name: "contract", kind: "message", T: () => AuctionContract },
+      {
+        no: 8,
+        name: "winning_bid_amount_usd",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.winner = "";
+    message.basket = [];
+    message.winningBidAmount = "";
+    message.round = 0n;
+    message.endTimestamp = 0n;
+    message.updatedAt = 0n;
+    message.winningBidAmountUsd = "";
+    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 winner */
+        1:
+          message.winner = reader.string();
+          break;
+        case /* repeated injective_auction_rpc.CoinPrices basket */
+        2:
+          message.basket.push(CoinPrices.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* string winning_bid_amount */
+        3:
+          message.winningBidAmount = reader.string();
+          break;
+        case /* uint64 round */
+        4:
+          message.round = reader.uint64().toBigInt();
+          break;
+        case /* sint64 end_timestamp */
+        5:
+          message.endTimestamp = reader.sint64().toBigInt();
+          break;
+        case /* sint64 updated_at */
+        6:
+          message.updatedAt = reader.sint64().toBigInt();
+          break;
+        case /* injective_auction_rpc.AuctionContract contract */
+        7:
+          message.contract = AuctionContract.internalBinaryRead(reader, reader.uint32(), options, message.contract);
+          break;
+        case /* string winning_bid_amount_usd */
+        8:
+          message.winningBidAmountUsd = 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.winner !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.winner);
+    for (let i = 0; i < message.basket.length; i++)
+      CoinPrices.internalBinaryWrite(message.basket[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.winningBidAmount !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.winningBidAmount);
+    if (message.round !== 0n)
+      writer.tag(4, WireType.Varint).uint64(message.round);
+    if (message.endTimestamp !== 0n)
+      writer.tag(5, WireType.Varint).sint64(message.endTimestamp);
+    if (message.updatedAt !== 0n)
+      writer.tag(6, WireType.Varint).sint64(message.updatedAt);
+    if (message.contract)
+      AuctionContract.internalBinaryWrite(message.contract, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+    if (message.winningBidAmountUsd !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.winningBidAmountUsd);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionV2Response = new AuctionV2Response$Type();
+class AccountAuctionsV2Request$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AccountAuctionsV2Request", [
+      {
+        no: 1,
+        name: "address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "per_page",
+        kind: "scalar",
+        T: 17
+        /*ScalarType.SINT32*/
+      },
+      {
+        no: 3,
+        name: "token",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.address = "";
+    message.perPage = 0;
+    message.token = "";
+    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 address */
+        1:
+          message.address = reader.string();
+          break;
+        case /* sint32 per_page */
+        2:
+          message.perPage = reader.sint32();
+          break;
+        case /* string token */
+        3:
+          message.token = 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.address !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.address);
+    if (message.perPage !== 0)
+      writer.tag(2, WireType.Varint).sint32(message.perPage);
+    if (message.token !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.token);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AccountAuctionsV2Request = new AccountAuctionsV2Request$Type();
+class AccountAuctionsV2Response$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AccountAuctionsV2Response", [
+      { no: 1, name: "auctions", kind: "message", repeat: 2, T: () => AccountAuctionV2 },
+      {
+        no: 2,
+        name: "next",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "total",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.auctions = [];
+    message.next = [];
+    message.total = 0n;
+    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_auction_rpc.AccountAuctionV2 auctions */
+        1:
+          message.auctions.push(AccountAuctionV2.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated string next */
+        2:
+          message.next.push(reader.string());
+          break;
+        case /* sint64 total */
+        3:
+          message.total = reader.sint64().toBigInt();
+          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.auctions.length; i++)
+      AccountAuctionV2.internalBinaryWrite(message.auctions[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    for (let i = 0; i < message.next.length; i++)
+      writer.tag(2, WireType.LengthDelimited).string(message.next[i]);
+    if (message.total !== 0n)
+      writer.tag(3, WireType.Varint).sint64(message.total);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AccountAuctionsV2Response = new AccountAuctionsV2Response$Type();
+class AccountAuctionV2$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AccountAuctionV2", [
+      {
+        no: 1,
+        name: "id",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "round",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 3,
+        name: "amount_deposited",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "is_claimable",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 5, name: "claimed_assets", kind: "message", repeat: 2, T: () => CoinPrices }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.id = 0n;
+    message.round = 0n;
+    message.amountDeposited = "";
+    message.isClaimable = false;
+    message.claimedAssets = [];
+    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 id */
+        1:
+          message.id = reader.uint64().toBigInt();
+          break;
+        case /* uint64 round */
+        2:
+          message.round = reader.uint64().toBigInt();
+          break;
+        case /* string amount_deposited */
+        3:
+          message.amountDeposited = reader.string();
+          break;
+        case /* bool is_claimable */
+        4:
+          message.isClaimable = reader.bool();
+          break;
+        case /* repeated injective_auction_rpc.CoinPrices claimed_assets */
+        5:
+          message.claimedAssets.push(CoinPrices.internalBinaryRead(reader, reader.uint32(), options));
+          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.id !== 0n)
+      writer.tag(1, WireType.Varint).uint64(message.id);
+    if (message.round !== 0n)
+      writer.tag(2, WireType.Varint).uint64(message.round);
+    if (message.amountDeposited !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.amountDeposited);
+    if (message.isClaimable !== false)
+      writer.tag(4, WireType.Varint).bool(message.isClaimable);
+    for (let i = 0; i < message.claimedAssets.length; i++)
+      CoinPrices.internalBinaryWrite(message.claimedAssets[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AccountAuctionV2 = new AccountAuctionV2$Type();
+class AuctionAccountStatusRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionAccountStatusRequest", [
+      {
+        no: 1,
+        name: "round",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 2,
+        name: "address",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.round = 0n;
+    message.address = "";
+    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 /* sint64 round */
+        1:
+          message.round = reader.sint64().toBigInt();
+          break;
+        case /* string address */
+        2:
+          message.address = 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.round !== 0n)
+      writer.tag(1, WireType.Varint).sint64(message.round);
+    if (message.address !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.address);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionAccountStatusRequest = new AuctionAccountStatusRequest$Type();
+class AuctionAccountStatusResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionAccountStatusResponse", [
+      {
+        no: 1,
+        name: "status",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.status = "";
+    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 status */
+        1:
+          message.status = 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.status !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.status);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionAccountStatusResponse = new AuctionAccountStatusResponse$Type();
+class StreamBidsRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.StreamBidsRequest", []);
+  }
+  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 StreamBidsRequest = new StreamBidsRequest$Type();
+class StreamBidsResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.StreamBidsResponse", [
+      {
+        no: 1,
+        name: "bidder",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "bid_amount",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "round",
+        kind: "scalar",
+        T: 4,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 4,
+        name: "timestamp",
+        kind: "scalar",
+        T: 18,
+        L: 0
+        /*LongType.BIGINT*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.bidder = "";
+    message.bidAmount = "";
+    message.round = 0n;
+    message.timestamp = 0n;
+    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 bidder */
+        1:
+          message.bidder = reader.string();
+          break;
+        case /* string bid_amount */
+        2:
+          message.bidAmount = reader.string();
+          break;
+        case /* uint64 round */
+        3:
+          message.round = reader.uint64().toBigInt();
+          break;
+        case /* sint64 timestamp */
+        4:
+          message.timestamp = reader.sint64().toBigInt();
+          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.bidder !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.bidder);
+    if (message.bidAmount !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.bidAmount);
+    if (message.round !== 0n)
+      writer.tag(3, WireType.Varint).uint64(message.round);
+    if (message.timestamp !== 0n)
+      writer.tag(4, WireType.Varint).sint64(message.timestamp);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const StreamBidsResponse = new StreamBidsResponse$Type();
+class InjBurntEndpointRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.InjBurntEndpointRequest", []);
+  }
+  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 InjBurntEndpointRequest = new InjBurntEndpointRequest$Type();
+class InjBurntEndpointResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.InjBurntEndpointResponse", [
+      {
+        no: 1,
+        name: "total_inj_burnt",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.totalInjBurnt = "";
+    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 total_inj_burnt */
+        1:
+          message.totalInjBurnt = 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.totalInjBurnt !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.totalInjBurnt);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const InjBurntEndpointResponse = new InjBurntEndpointResponse$Type();
+class AuctionsStatsRequest$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsStatsRequest", []);
+  }
+  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 AuctionsStatsRequest = new AuctionsStatsRequest$Type();
+class AuctionsStatsResponse$Type extends MessageType {
+  constructor() {
+    super("injective_auction_rpc.AuctionsStatsResponse", [
+      {
+        no: 1,
+        name: "total_burnt",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "total_usd_value",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.totalBurnt = "";
+    message.totalUsdValue = "";
+    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 total_burnt */
+        1:
+          message.totalBurnt = reader.string();
+          break;
+        case /* string total_usd_value */
+        2:
+          message.totalUsdValue = 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.totalBurnt !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.totalBurnt);
+    if (message.totalUsdValue !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.totalUsdValue);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+const AuctionsStatsResponse = new AuctionsStatsResponse$Type();
+const InjectiveAuctionRPC = new ServiceType("injective_auction_rpc.InjectiveAuctionRPC", [
+  { name: "AuctionEndpoint", options: {}, I: AuctionEndpointRequest, O: AuctionEndpointResponse },
+  { name: "Auctions", options: {}, I: AuctionsRequest, O: AuctionsResponse },
+  { name: "AuctionsHistoryV2", options: {}, I: AuctionsHistoryV2Request, O: AuctionsHistoryV2Response },
+  { name: "AuctionV2", options: {}, I: AuctionV2Request, O: AuctionV2Response },
+  { name: "AccountAuctionsV2", options: {}, I: AccountAuctionsV2Request, O: AccountAuctionsV2Response },
+  { name: "AuctionAccountStatus", options: {}, I: AuctionAccountStatusRequest, O: AuctionAccountStatusResponse },
+  { name: "StreamBids", serverStreaming: true, options: {}, I: StreamBidsRequest, O: StreamBidsResponse },
+  { name: "InjBurntEndpoint", options: {}, I: InjBurntEndpointRequest, O: InjBurntEndpointResponse },
+  { name: "AuctionsStats", options: {}, I: AuctionsStatsRequest, O: AuctionsStatsResponse }
+]);
+export {
+  AccountAuctionV2,
+  AccountAuctionsV2Request,
+  AccountAuctionsV2Response,
+  Auction,
+  AuctionAccountStatusRequest,
+  AuctionAccountStatusResponse,
+  AuctionContract,
+  AuctionEndpointRequest,
+  AuctionEndpointResponse,
+  AuctionV2Request,
+  AuctionV2Response,
+  AuctionV2Result,
+  AuctionsHistoryV2Request,
+  AuctionsHistoryV2Response,
+  AuctionsRequest,
+  AuctionsResponse,
+  AuctionsStatsRequest,
+  AuctionsStatsResponse,
+  Bid,
+  Coin,
+  CoinPrices,
+  InjBurntEndpointRequest,
+  InjBurntEndpointResponse,
+  InjectiveAuctionRPC,
+  StreamBidsRequest,
+  StreamBidsResponse
+};