@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/indexer/indexer_manager/event.ts

@@ -0,0 +1,428 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, toTimestamp, fromTimestamp } from "../../../helpers";
+/** enum to specify that the IndexerTendermintEvent is a block event. */
+
+export enum IndexerTendermintEvent_BlockEvent {
+  /** BLOCK_EVENT_UNSPECIFIED - Default value. This value is invalid and unused. */
+  BLOCK_EVENT_UNSPECIFIED = 0,
+
+  /**
+   * BLOCK_EVENT_BEGIN_BLOCK - BLOCK_EVENT_BEGIN_BLOCK indicates that the event was generated during
+   * BeginBlock.
+   */
+  BLOCK_EVENT_BEGIN_BLOCK = 1,
+
+  /**
+   * BLOCK_EVENT_END_BLOCK - BLOCK_EVENT_END_BLOCK indicates that the event was generated during
+   * EndBlock.
+   */
+  BLOCK_EVENT_END_BLOCK = 2,
+  UNRECOGNIZED = -1,
+}
+export const IndexerTendermintEvent_BlockEventSDKType = IndexerTendermintEvent_BlockEvent;
+export function indexerTendermintEvent_BlockEventFromJSON(object: any): IndexerTendermintEvent_BlockEvent {
+  switch (object) {
+    case 0:
+    case "BLOCK_EVENT_UNSPECIFIED":
+      return IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_UNSPECIFIED;
+
+    case 1:
+    case "BLOCK_EVENT_BEGIN_BLOCK":
+      return IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_BEGIN_BLOCK;
+
+    case 2:
+    case "BLOCK_EVENT_END_BLOCK":
+      return IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_END_BLOCK;
+
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return IndexerTendermintEvent_BlockEvent.UNRECOGNIZED;
+  }
+}
+export function indexerTendermintEvent_BlockEventToJSON(object: IndexerTendermintEvent_BlockEvent): string {
+  switch (object) {
+    case IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_UNSPECIFIED:
+      return "BLOCK_EVENT_UNSPECIFIED";
+
+    case IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_BEGIN_BLOCK:
+      return "BLOCK_EVENT_BEGIN_BLOCK";
+
+    case IndexerTendermintEvent_BlockEvent.BLOCK_EVENT_END_BLOCK:
+      return "BLOCK_EVENT_END_BLOCK";
+
+    case IndexerTendermintEvent_BlockEvent.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/**
+ * IndexerTendermintEventWrapper is a wrapper around IndexerTendermintEvent,
+ * with an additional txn_hash field.
+ */
+
+export interface IndexerTendermintEventWrapper {
+  event?: IndexerTendermintEvent;
+  txnHash: string;
+}
+/**
+ * IndexerTendermintEventWrapper is a wrapper around IndexerTendermintEvent,
+ * with an additional txn_hash field.
+ */
+
+export interface IndexerTendermintEventWrapperSDKType {
+  event?: IndexerTendermintEventSDKType;
+  txn_hash: string;
+}
+/**
+ * IndexerEventsStoreValue represents the type of the value of the
+ * `IndexerEventsStore` in state.
+ */
+
+export interface IndexerEventsStoreValue {
+  events: IndexerTendermintEventWrapper[];
+}
+/**
+ * IndexerEventsStoreValue represents the type of the value of the
+ * `IndexerEventsStore` in state.
+ */
+
+export interface IndexerEventsStoreValueSDKType {
+  events: IndexerTendermintEventWrapperSDKType[];
+}
+/**
+ * IndexerTendermintEvent contains the base64 encoded event proto emitted from
+ * the Zogux application as well as additional metadata to determine the
+ * ordering of the event within the block and the subtype of the event.
+ */
+
+export interface IndexerTendermintEvent {
+  /** Subtype of the event e.g. "order_fill", "subaccount_update", etc. */
+  subtype: string;
+  transactionIndex?: number;
+  blockEvent?: IndexerTendermintEvent_BlockEvent;
+  /**
+   * Index of the event within the list of events that happened either during a
+   * transaction or during processing of a block.
+   * TODO(DEC-537): Deprecate this field because events are already ordered.
+   */
+
+  eventIndex: number;
+  /** Version of the event. */
+
+  version: number;
+  /** Tendermint event bytes. */
+
+  dataBytes: Uint8Array;
+}
+/**
+ * IndexerTendermintEvent contains the base64 encoded event proto emitted from
+ * the Zogux application as well as additional metadata to determine the
+ * ordering of the event within the block and the subtype of the event.
+ */
+
+export interface IndexerTendermintEventSDKType {
+  subtype: string;
+  transaction_index?: number;
+  block_event?: IndexerTendermintEvent_BlockEvent;
+  event_index: number;
+  version: number;
+  data_bytes: Uint8Array;
+}
+/**
+ * IndexerTendermintBlock contains all the events for the block along with
+ * metadata for the block height, timestamp of the block and a list of all the
+ * hashes of the transactions within the block. The transaction hashes follow
+ * the ordering of the transactions as they appear within the block.
+ */
+
+export interface IndexerTendermintBlock {
+  height: number;
+  time?: Date;
+  events: IndexerTendermintEvent[];
+  txHashes: string[];
+}
+/**
+ * IndexerTendermintBlock contains all the events for the block along with
+ * metadata for the block height, timestamp of the block and a list of all the
+ * hashes of the transactions within the block. The transaction hashes follow
+ * the ordering of the transactions as they appear within the block.
+ */
+
+export interface IndexerTendermintBlockSDKType {
+  height: number;
+  time?: Date;
+  events: IndexerTendermintEventSDKType[];
+  tx_hashes: string[];
+}
+
+function createBaseIndexerTendermintEventWrapper(): IndexerTendermintEventWrapper {
+  return {
+    event: undefined,
+    txnHash: ""
+  };
+}
+
+export const IndexerTendermintEventWrapper = {
+  encode(message: IndexerTendermintEventWrapper, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.event !== undefined) {
+      IndexerTendermintEvent.encode(message.event, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.txnHash !== "") {
+      writer.uint32(18).string(message.txnHash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerTendermintEventWrapper {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerTendermintEventWrapper();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.event = IndexerTendermintEvent.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.txnHash = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerTendermintEventWrapper>): IndexerTendermintEventWrapper {
+    const message = createBaseIndexerTendermintEventWrapper();
+    message.event = object.event !== undefined && object.event !== null ? IndexerTendermintEvent.fromPartial(object.event) : undefined;
+    message.txnHash = object.txnHash ?? "";
+    return message;
+  }
+
+};
+
+function createBaseIndexerEventsStoreValue(): IndexerEventsStoreValue {
+  return {
+    events: []
+  };
+}
+
+export const IndexerEventsStoreValue = {
+  encode(message: IndexerEventsStoreValue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.events) {
+      IndexerTendermintEventWrapper.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerEventsStoreValue {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerEventsStoreValue();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.events.push(IndexerTendermintEventWrapper.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerEventsStoreValue>): IndexerEventsStoreValue {
+    const message = createBaseIndexerEventsStoreValue();
+    message.events = object.events?.map(e => IndexerTendermintEventWrapper.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseIndexerTendermintEvent(): IndexerTendermintEvent {
+  return {
+    subtype: "",
+    transactionIndex: undefined,
+    blockEvent: undefined,
+    eventIndex: 0,
+    version: 0,
+    dataBytes: new Uint8Array()
+  };
+}
+
+export const IndexerTendermintEvent = {
+  encode(message: IndexerTendermintEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.subtype !== "") {
+      writer.uint32(10).string(message.subtype);
+    }
+
+    if (message.transactionIndex !== undefined) {
+      writer.uint32(24).uint32(message.transactionIndex);
+    }
+
+    if (message.blockEvent !== undefined) {
+      writer.uint32(32).int32(message.blockEvent);
+    }
+
+    if (message.eventIndex !== 0) {
+      writer.uint32(40).uint32(message.eventIndex);
+    }
+
+    if (message.version !== 0) {
+      writer.uint32(48).uint32(message.version);
+    }
+
+    if (message.dataBytes.length !== 0) {
+      writer.uint32(58).bytes(message.dataBytes);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerTendermintEvent {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerTendermintEvent();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.subtype = reader.string();
+          break;
+
+        case 3:
+          message.transactionIndex = reader.uint32();
+          break;
+
+        case 4:
+          message.blockEvent = (reader.int32() as any);
+          break;
+
+        case 5:
+          message.eventIndex = reader.uint32();
+          break;
+
+        case 6:
+          message.version = reader.uint32();
+          break;
+
+        case 7:
+          message.dataBytes = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerTendermintEvent>): IndexerTendermintEvent {
+    const message = createBaseIndexerTendermintEvent();
+    message.subtype = object.subtype ?? "";
+    message.transactionIndex = object.transactionIndex ?? undefined;
+    message.blockEvent = object.blockEvent ?? undefined;
+    message.eventIndex = object.eventIndex ?? 0;
+    message.version = object.version ?? 0;
+    message.dataBytes = object.dataBytes ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseIndexerTendermintBlock(): IndexerTendermintBlock {
+  return {
+    height: 0,
+    time: undefined,
+    events: [],
+    txHashes: []
+  };
+}
+
+export const IndexerTendermintBlock = {
+  encode(message: IndexerTendermintBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.height !== 0) {
+      writer.uint32(8).uint32(message.height);
+    }
+
+    if (message.time !== undefined) {
+      Timestamp.encode(toTimestamp(message.time), writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.events) {
+      IndexerTendermintEvent.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.txHashes) {
+      writer.uint32(34).string(v!);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IndexerTendermintBlock {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIndexerTendermintBlock();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.height = reader.uint32();
+          break;
+
+        case 2:
+          message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.events.push(IndexerTendermintEvent.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.txHashes.push(reader.string());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IndexerTendermintBlock>): IndexerTendermintBlock {
+    const message = createBaseIndexerTendermintBlock();
+    message.height = object.height ?? 0;
+    message.time = object.time ?? undefined;
+    message.events = object.events?.map(e => IndexerTendermintEvent.fromPartial(e)) || [];
+    message.txHashes = object.txHashes?.map(e => e) || [];
+    return message;
+  }
+
+};