@zoguxprotocol/proto 0.1.0

package/src/codegen/cosmos/store/streaming/abci/grpc.ts

@@ -0,0 +1,231 @@
+import { RequestFinalizeBlock, RequestFinalizeBlockSDKType, ResponseFinalizeBlock, ResponseFinalizeBlockSDKType, ResponseCommit, ResponseCommitSDKType } from "../../../../tendermint/abci/types";
+import { StoreKVPair, StoreKVPairSDKType } from "../../v1beta1/listening";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../../../helpers";
+/** ListenEndBlockRequest is the request type for the ListenEndBlock RPC method */
+
+export interface ListenFinalizeBlockRequest {
+  req?: RequestFinalizeBlock;
+  res?: ResponseFinalizeBlock;
+}
+/** ListenEndBlockRequest is the request type for the ListenEndBlock RPC method */
+
+export interface ListenFinalizeBlockRequestSDKType {
+  req?: RequestFinalizeBlockSDKType;
+  res?: ResponseFinalizeBlockSDKType;
+}
+/** ListenEndBlockResponse is the response type for the ListenEndBlock RPC method */
+
+export interface ListenFinalizeBlockResponse {}
+/** ListenEndBlockResponse is the response type for the ListenEndBlock RPC method */
+
+export interface ListenFinalizeBlockResponseSDKType {}
+/** ListenCommitRequest is the request type for the ListenCommit RPC method */
+
+export interface ListenCommitRequest {
+  /** explicitly pass in block height as ResponseCommit does not contain this info */
+  blockHeight: Long;
+  res?: ResponseCommit;
+  changeSet: StoreKVPair[];
+}
+/** ListenCommitRequest is the request type for the ListenCommit RPC method */
+
+export interface ListenCommitRequestSDKType {
+  block_height: Long;
+  res?: ResponseCommitSDKType;
+  change_set: StoreKVPairSDKType[];
+}
+/** ListenCommitResponse is the response type for the ListenCommit RPC method */
+
+export interface ListenCommitResponse {}
+/** ListenCommitResponse is the response type for the ListenCommit RPC method */
+
+export interface ListenCommitResponseSDKType {}
+
+function createBaseListenFinalizeBlockRequest(): ListenFinalizeBlockRequest {
+  return {
+    req: undefined,
+    res: undefined
+  };
+}
+
+export const ListenFinalizeBlockRequest = {
+  encode(message: ListenFinalizeBlockRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.req !== undefined) {
+      RequestFinalizeBlock.encode(message.req, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.res !== undefined) {
+      ResponseFinalizeBlock.encode(message.res, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListenFinalizeBlockRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListenFinalizeBlockRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.req = RequestFinalizeBlock.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.res = ResponseFinalizeBlock.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ListenFinalizeBlockRequest>): ListenFinalizeBlockRequest {
+    const message = createBaseListenFinalizeBlockRequest();
+    message.req = object.req !== undefined && object.req !== null ? RequestFinalizeBlock.fromPartial(object.req) : undefined;
+    message.res = object.res !== undefined && object.res !== null ? ResponseFinalizeBlock.fromPartial(object.res) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseListenFinalizeBlockResponse(): ListenFinalizeBlockResponse {
+  return {};
+}
+
+export const ListenFinalizeBlockResponse = {
+  encode(_: ListenFinalizeBlockResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListenFinalizeBlockResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListenFinalizeBlockResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<ListenFinalizeBlockResponse>): ListenFinalizeBlockResponse {
+    const message = createBaseListenFinalizeBlockResponse();
+    return message;
+  }
+
+};
+
+function createBaseListenCommitRequest(): ListenCommitRequest {
+  return {
+    blockHeight: Long.ZERO,
+    res: undefined,
+    changeSet: []
+  };
+}
+
+export const ListenCommitRequest = {
+  encode(message: ListenCommitRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.blockHeight.isZero()) {
+      writer.uint32(8).int64(message.blockHeight);
+    }
+
+    if (message.res !== undefined) {
+      ResponseCommit.encode(message.res, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.changeSet) {
+      StoreKVPair.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListenCommitRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListenCommitRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.blockHeight = (reader.int64() as Long);
+          break;
+
+        case 2:
+          message.res = ResponseCommit.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.changeSet.push(StoreKVPair.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<ListenCommitRequest>): ListenCommitRequest {
+    const message = createBaseListenCommitRequest();
+    message.blockHeight = object.blockHeight !== undefined && object.blockHeight !== null ? Long.fromValue(object.blockHeight) : Long.ZERO;
+    message.res = object.res !== undefined && object.res !== null ? ResponseCommit.fromPartial(object.res) : undefined;
+    message.changeSet = object.changeSet?.map(e => StoreKVPair.fromPartial(e)) || [];
+    return message;
+  }
+
+};
+
+function createBaseListenCommitResponse(): ListenCommitResponse {
+  return {};
+}
+
+export const ListenCommitResponse = {
+  encode(_: ListenCommitResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListenCommitResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListenCommitResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<ListenCommitResponse>): ListenCommitResponse {
+    const message = createBaseListenCommitResponse();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/store/v1beta1/commit_info.ts

@@ -0,0 +1,234 @@
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { Long, toTimestamp, fromTimestamp, DeepPartial } from "../../../helpers";
+import * as _m0 from "protobufjs/minimal";
+/**
+ * CommitInfo defines commit information used by the multi-store when committing
+ * a version/height.
+ */
+
+export interface CommitInfo {
+  version: Long;
+  storeInfos: StoreInfo[];
+  timestamp?: Date;
+}
+/**
+ * CommitInfo defines commit information used by the multi-store when committing
+ * a version/height.
+ */
+
+export interface CommitInfoSDKType {
+  version: Long;
+  store_infos: StoreInfoSDKType[];
+  timestamp?: Date;
+}
+/**
+ * StoreInfo defines store-specific commit information. It contains a reference
+ * between a store name and the commit ID.
+ */
+
+export interface StoreInfo {
+  name: string;
+  commitId?: CommitID;
+}
+/**
+ * StoreInfo defines store-specific commit information. It contains a reference
+ * between a store name and the commit ID.
+ */
+
+export interface StoreInfoSDKType {
+  name: string;
+  commit_id?: CommitIDSDKType;
+}
+/**
+ * CommitID defines the commitment information when a specific store is
+ * committed.
+ */
+
+export interface CommitID {
+  version: Long;
+  hash: Uint8Array;
+}
+/**
+ * CommitID defines the commitment information when a specific store is
+ * committed.
+ */
+
+export interface CommitIDSDKType {
+  version: Long;
+  hash: Uint8Array;
+}
+
+function createBaseCommitInfo(): CommitInfo {
+  return {
+    version: Long.ZERO,
+    storeInfos: [],
+    timestamp: undefined
+  };
+}
+
+export const CommitInfo = {
+  encode(message: CommitInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.version.isZero()) {
+      writer.uint32(8).int64(message.version);
+    }
+
+    for (const v of message.storeInfos) {
+      StoreInfo.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CommitInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommitInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.version = (reader.int64() as Long);
+          break;
+
+        case 2:
+          message.storeInfos.push(StoreInfo.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CommitInfo>): CommitInfo {
+    const message = createBaseCommitInfo();
+    message.version = object.version !== undefined && object.version !== null ? Long.fromValue(object.version) : Long.ZERO;
+    message.storeInfos = object.storeInfos?.map(e => StoreInfo.fromPartial(e)) || [];
+    message.timestamp = object.timestamp ?? undefined;
+    return message;
+  }
+
+};
+
+function createBaseStoreInfo(): StoreInfo {
+  return {
+    name: "",
+    commitId: undefined
+  };
+}
+
+export const StoreInfo = {
+  encode(message: StoreInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+
+    if (message.commitId !== undefined) {
+      CommitID.encode(message.commitId, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StoreInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStoreInfo();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.name = reader.string();
+          break;
+
+        case 2:
+          message.commitId = CommitID.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StoreInfo>): StoreInfo {
+    const message = createBaseStoreInfo();
+    message.name = object.name ?? "";
+    message.commitId = object.commitId !== undefined && object.commitId !== null ? CommitID.fromPartial(object.commitId) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseCommitID(): CommitID {
+  return {
+    version: Long.ZERO,
+    hash: new Uint8Array()
+  };
+}
+
+export const CommitID = {
+  encode(message: CommitID, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.version.isZero()) {
+      writer.uint32(8).int64(message.version);
+    }
+
+    if (message.hash.length !== 0) {
+      writer.uint32(18).bytes(message.hash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CommitID {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommitID();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.version = (reader.int64() as Long);
+          break;
+
+        case 2:
+          message.hash = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<CommitID>): CommitID {
+    const message = createBaseCommitID();
+    message.version = object.version !== undefined && object.version !== null ? Long.fromValue(object.version) : Long.ZERO;
+    message.hash = object.hash ?? new Uint8Array();
+    return message;
+  }
+
+};

package/src/codegen/cosmos/store/v1beta1/listening.ts

@@ -0,0 +1,196 @@
+import { ResponseCommit, ResponseCommitSDKType, RequestFinalizeBlock, RequestFinalizeBlockSDKType, ResponseFinalizeBlock, ResponseFinalizeBlockSDKType } from "../../../tendermint/abci/types";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../../helpers";
+/**
+ * StoreKVPair is a KVStore KVPair used for listening to state changes (Sets and Deletes)
+ * It optionally includes the StoreKey for the originating KVStore and a Boolean flag to distinguish between Sets and
+ * Deletes
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+export interface StoreKVPair {
+  /** the store key for the KVStore this pair originates from */
+  storeKey: string;
+  /** true indicates a delete operation, false indicates a set operation */
+
+  delete: boolean;
+  key: Uint8Array;
+  value: Uint8Array;
+}
+/**
+ * StoreKVPair is a KVStore KVPair used for listening to state changes (Sets and Deletes)
+ * It optionally includes the StoreKey for the originating KVStore and a Boolean flag to distinguish between Sets and
+ * Deletes
+ * 
+ * Since: cosmos-sdk 0.43
+ */
+
+export interface StoreKVPairSDKType {
+  store_key: string;
+  delete: boolean;
+  key: Uint8Array;
+  value: Uint8Array;
+}
+/**
+ * BlockMetadata contains all the abci event data of a block
+ * the file streamer dump them into files together with the state changes.
+ */
+
+export interface BlockMetadata {
+  responseCommit?: ResponseCommit;
+  requestFinalizeBlock?: RequestFinalizeBlock;
+  /** TODO: should we renumber this? */
+
+  responseFinalizeBlock?: ResponseFinalizeBlock;
+}
+/**
+ * BlockMetadata contains all the abci event data of a block
+ * the file streamer dump them into files together with the state changes.
+ */
+
+export interface BlockMetadataSDKType {
+  response_commit?: ResponseCommitSDKType;
+  request_finalize_block?: RequestFinalizeBlockSDKType;
+  response_finalize_block?: ResponseFinalizeBlockSDKType;
+}
+
+function createBaseStoreKVPair(): StoreKVPair {
+  return {
+    storeKey: "",
+    delete: false,
+    key: new Uint8Array(),
+    value: new Uint8Array()
+  };
+}
+
+export const StoreKVPair = {
+  encode(message: StoreKVPair, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.storeKey !== "") {
+      writer.uint32(10).string(message.storeKey);
+    }
+
+    if (message.delete === true) {
+      writer.uint32(16).bool(message.delete);
+    }
+
+    if (message.key.length !== 0) {
+      writer.uint32(26).bytes(message.key);
+    }
+
+    if (message.value.length !== 0) {
+      writer.uint32(34).bytes(message.value);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): StoreKVPair {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStoreKVPair();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.storeKey = reader.string();
+          break;
+
+        case 2:
+          message.delete = reader.bool();
+          break;
+
+        case 3:
+          message.key = reader.bytes();
+          break;
+
+        case 4:
+          message.value = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<StoreKVPair>): StoreKVPair {
+    const message = createBaseStoreKVPair();
+    message.storeKey = object.storeKey ?? "";
+    message.delete = object.delete ?? false;
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseBlockMetadata(): BlockMetadata {
+  return {
+    responseCommit: undefined,
+    requestFinalizeBlock: undefined,
+    responseFinalizeBlock: undefined
+  };
+}
+
+export const BlockMetadata = {
+  encode(message: BlockMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.responseCommit !== undefined) {
+      ResponseCommit.encode(message.responseCommit, writer.uint32(50).fork()).ldelim();
+    }
+
+    if (message.requestFinalizeBlock !== undefined) {
+      RequestFinalizeBlock.encode(message.requestFinalizeBlock, writer.uint32(58).fork()).ldelim();
+    }
+
+    if (message.responseFinalizeBlock !== undefined) {
+      ResponseFinalizeBlock.encode(message.responseFinalizeBlock, writer.uint32(66).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): BlockMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBlockMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 6:
+          message.responseCommit = ResponseCommit.decode(reader, reader.uint32());
+          break;
+
+        case 7:
+          message.requestFinalizeBlock = RequestFinalizeBlock.decode(reader, reader.uint32());
+          break;
+
+        case 8:
+          message.responseFinalizeBlock = ResponseFinalizeBlock.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<BlockMetadata>): BlockMetadata {
+    const message = createBaseBlockMetadata();
+    message.responseCommit = object.responseCommit !== undefined && object.responseCommit !== null ? ResponseCommit.fromPartial(object.responseCommit) : undefined;
+    message.requestFinalizeBlock = object.requestFinalizeBlock !== undefined && object.requestFinalizeBlock !== null ? RequestFinalizeBlock.fromPartial(object.requestFinalizeBlock) : undefined;
+    message.responseFinalizeBlock = object.responseFinalizeBlock !== undefined && object.responseFinalizeBlock !== null ? ResponseFinalizeBlock.fromPartial(object.responseFinalizeBlock) : undefined;
+    return message;
+  }
+
+};