@zoguxprotocol/proto 0.1.0

package/src/codegen/zogux/delaymsg/genesis.ts

@@ -0,0 +1,73 @@
+import { DelayedMessage, DelayedMessageSDKType } from "./delayed_message";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/** GenesisState defines the delaymsg module's genesis state. */
+
+export interface GenesisState {
+  /** delayed_messages is a list of delayed messages. */
+  delayedMessages: DelayedMessage[];
+  /** next_delayed_message_id is the id to be assigned to next delayed message. */
+
+  nextDelayedMessageId: number;
+}
+/** GenesisState defines the delaymsg module's genesis state. */
+
+export interface GenesisStateSDKType {
+  delayed_messages: DelayedMessageSDKType[];
+  next_delayed_message_id: number;
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    delayedMessages: [],
+    nextDelayedMessageId: 0
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.delayedMessages) {
+      DelayedMessage.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.nextDelayedMessageId !== 0) {
+      writer.uint32(16).uint32(message.nextDelayedMessageId);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.delayedMessages.push(DelayedMessage.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.nextDelayedMessageId = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.delayedMessages = object.delayedMessages?.map(e => DelayedMessage.fromPartial(e)) || [];
+    message.nextDelayedMessageId = object.nextDelayedMessageId ?? 0;
+    return message;
+  }
+
+};

package/src/codegen/zogux/delaymsg/query.lcd.ts

@@ -0,0 +1,38 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryNextDelayedMessageIdRequest, QueryNextDelayedMessageIdResponseSDKType, QueryMessageRequest, QueryMessageResponseSDKType, QueryBlockMessageIdsRequest, QueryBlockMessageIdsResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.nextDelayedMessageId = this.nextDelayedMessageId.bind(this);
+    this.message = this.message.bind(this);
+    this.blockMessageIds = this.blockMessageIds.bind(this);
+  }
+  /* Queries the next DelayedMessage's id. */
+
+
+  async nextDelayedMessageId(_params: QueryNextDelayedMessageIdRequest = {}): Promise<QueryNextDelayedMessageIdResponseSDKType> {
+    const endpoint = `zogux/v4/delaymsg/next_id`;
+    return await this.req.get<QueryNextDelayedMessageIdResponseSDKType>(endpoint);
+  }
+  /* Queries the DelayedMessage by id. */
+
+
+  async message(params: QueryMessageRequest): Promise<QueryMessageResponseSDKType> {
+    const endpoint = `zogux/v4/delaymsg/message/${params.id}`;
+    return await this.req.get<QueryMessageResponseSDKType>(endpoint);
+  }
+  /* Queries the DelayedMessages at a given block height. */
+
+
+  async blockMessageIds(params: QueryBlockMessageIdsRequest): Promise<QueryBlockMessageIdsResponseSDKType> {
+    const endpoint = `zogux/v4/delaymsg/block/message_ids/${params.blockHeight}`;
+    return await this.req.get<QueryBlockMessageIdsResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/zogux/delaymsg/query.rpc.Query.ts

@@ -0,0 +1,63 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryNextDelayedMessageIdRequest, QueryNextDelayedMessageIdResponse, QueryMessageRequest, QueryMessageResponse, QueryBlockMessageIdsRequest, QueryBlockMessageIdsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+
+export interface Query {
+  /** Queries the next DelayedMessage's id. */
+  nextDelayedMessageId(request?: QueryNextDelayedMessageIdRequest): Promise<QueryNextDelayedMessageIdResponse>;
+  /** Queries the DelayedMessage by id. */
+
+  message(request: QueryMessageRequest): Promise<QueryMessageResponse>;
+  /** Queries the DelayedMessages at a given block height. */
+
+  blockMessageIds(request: QueryBlockMessageIdsRequest): Promise<QueryBlockMessageIdsResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.nextDelayedMessageId = this.nextDelayedMessageId.bind(this);
+    this.message = this.message.bind(this);
+    this.blockMessageIds = this.blockMessageIds.bind(this);
+  }
+
+  nextDelayedMessageId(request: QueryNextDelayedMessageIdRequest = {}): Promise<QueryNextDelayedMessageIdResponse> {
+    const data = QueryNextDelayedMessageIdRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.delaymsg.Query", "NextDelayedMessageId", data);
+    return promise.then(data => QueryNextDelayedMessageIdResponse.decode(new _m0.Reader(data)));
+  }
+
+  message(request: QueryMessageRequest): Promise<QueryMessageResponse> {
+    const data = QueryMessageRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.delaymsg.Query", "Message", data);
+    return promise.then(data => QueryMessageResponse.decode(new _m0.Reader(data)));
+  }
+
+  blockMessageIds(request: QueryBlockMessageIdsRequest): Promise<QueryBlockMessageIdsResponse> {
+    const data = QueryBlockMessageIdsRequest.encode(request).finish();
+    const promise = this.rpc.request("zogux.delaymsg.Query", "BlockMessageIds", data);
+    return promise.then(data => QueryBlockMessageIdsResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    nextDelayedMessageId(request?: QueryNextDelayedMessageIdRequest): Promise<QueryNextDelayedMessageIdResponse> {
+      return queryService.nextDelayedMessageId(request);
+    },
+
+    message(request: QueryMessageRequest): Promise<QueryMessageResponse> {
+      return queryService.message(request);
+    },
+
+    blockMessageIds(request: QueryBlockMessageIdsRequest): Promise<QueryBlockMessageIdsResponse> {
+      return queryService.blockMessageIds(request);
+    }
+
+  };
+};

package/src/codegen/zogux/delaymsg/query.ts

@@ -0,0 +1,364 @@
+import { DelayedMessage, DelayedMessageSDKType } from "./delayed_message";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "../../helpers";
+/**
+ * QueryNextDelayedMessageIdRequest is the request type for the
+ * NextDelayedMessageId RPC method.
+ */
+
+export interface QueryNextDelayedMessageIdRequest {}
+/**
+ * QueryNextDelayedMessageIdRequest is the request type for the
+ * NextDelayedMessageId RPC method.
+ */
+
+export interface QueryNextDelayedMessageIdRequestSDKType {}
+/**
+ * QueryNextDelayedMessageIdResponse is the response type for the
+ * NextDelayedMessageId RPC method.
+ */
+
+export interface QueryNextDelayedMessageIdResponse {
+  nextDelayedMessageId: number;
+}
+/**
+ * QueryNextDelayedMessageIdResponse is the response type for the
+ * NextDelayedMessageId RPC method.
+ */
+
+export interface QueryNextDelayedMessageIdResponseSDKType {
+  next_delayed_message_id: number;
+}
+/** QueryMessageRequest is the request type for the Message RPC method. */
+
+export interface QueryMessageRequest {
+  /** QueryMessageRequest is the request type for the Message RPC method. */
+  id: number;
+}
+/** QueryMessageRequest is the request type for the Message RPC method. */
+
+export interface QueryMessageRequestSDKType {
+  id: number;
+}
+/** QueryGetMessageResponse is the response type for the Message RPC method. */
+
+export interface QueryMessageResponse {
+  /** QueryGetMessageResponse is the response type for the Message RPC method. */
+  message?: DelayedMessage;
+}
+/** QueryGetMessageResponse is the response type for the Message RPC method. */
+
+export interface QueryMessageResponseSDKType {
+  message?: DelayedMessageSDKType;
+}
+/**
+ * QueryBlockMessageIdsRequest is the request type for the BlockMessageIds
+ * RPC method.
+ */
+
+export interface QueryBlockMessageIdsRequest {
+  /**
+   * QueryBlockMessageIdsRequest is the request type for the BlockMessageIds
+   * RPC method.
+   */
+  blockHeight: number;
+}
+/**
+ * QueryBlockMessageIdsRequest is the request type for the BlockMessageIds
+ * RPC method.
+ */
+
+export interface QueryBlockMessageIdsRequestSDKType {
+  block_height: number;
+}
+/**
+ * QueryGetBlockMessageIdsResponse is the response type for the BlockMessageIds
+ * RPC method.
+ */
+
+export interface QueryBlockMessageIdsResponse {
+  /**
+   * QueryGetBlockMessageIdsResponse is the response type for the BlockMessageIds
+   * RPC method.
+   */
+  messageIds: number[];
+}
+/**
+ * QueryGetBlockMessageIdsResponse is the response type for the BlockMessageIds
+ * RPC method.
+ */
+
+export interface QueryBlockMessageIdsResponseSDKType {
+  message_ids: number[];
+}
+
+function createBaseQueryNextDelayedMessageIdRequest(): QueryNextDelayedMessageIdRequest {
+  return {};
+}
+
+export const QueryNextDelayedMessageIdRequest = {
+  encode(_: QueryNextDelayedMessageIdRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryNextDelayedMessageIdRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryNextDelayedMessageIdRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QueryNextDelayedMessageIdRequest>): QueryNextDelayedMessageIdRequest {
+    const message = createBaseQueryNextDelayedMessageIdRequest();
+    return message;
+  }
+
+};
+
+function createBaseQueryNextDelayedMessageIdResponse(): QueryNextDelayedMessageIdResponse {
+  return {
+    nextDelayedMessageId: 0
+  };
+}
+
+export const QueryNextDelayedMessageIdResponse = {
+  encode(message: QueryNextDelayedMessageIdResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.nextDelayedMessageId !== 0) {
+      writer.uint32(8).uint32(message.nextDelayedMessageId);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryNextDelayedMessageIdResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryNextDelayedMessageIdResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.nextDelayedMessageId = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryNextDelayedMessageIdResponse>): QueryNextDelayedMessageIdResponse {
+    const message = createBaseQueryNextDelayedMessageIdResponse();
+    message.nextDelayedMessageId = object.nextDelayedMessageId ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseQueryMessageRequest(): QueryMessageRequest {
+  return {
+    id: 0
+  };
+}
+
+export const QueryMessageRequest = {
+  encode(message: QueryMessageRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== 0) {
+      writer.uint32(8).uint32(message.id);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryMessageRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryMessageRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryMessageRequest>): QueryMessageRequest {
+    const message = createBaseQueryMessageRequest();
+    message.id = object.id ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseQueryMessageResponse(): QueryMessageResponse {
+  return {
+    message: undefined
+  };
+}
+
+export const QueryMessageResponse = {
+  encode(message: QueryMessageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== undefined) {
+      DelayedMessage.encode(message.message, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryMessageResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.message = DelayedMessage.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryMessageResponse>): QueryMessageResponse {
+    const message = createBaseQueryMessageResponse();
+    message.message = object.message !== undefined && object.message !== null ? DelayedMessage.fromPartial(object.message) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryBlockMessageIdsRequest(): QueryBlockMessageIdsRequest {
+  return {
+    blockHeight: 0
+  };
+}
+
+export const QueryBlockMessageIdsRequest = {
+  encode(message: QueryBlockMessageIdsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.blockHeight !== 0) {
+      writer.uint32(8).uint32(message.blockHeight);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryBlockMessageIdsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryBlockMessageIdsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.blockHeight = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryBlockMessageIdsRequest>): QueryBlockMessageIdsRequest {
+    const message = createBaseQueryBlockMessageIdsRequest();
+    message.blockHeight = object.blockHeight ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseQueryBlockMessageIdsResponse(): QueryBlockMessageIdsResponse {
+  return {
+    messageIds: []
+  };
+}
+
+export const QueryBlockMessageIdsResponse = {
+  encode(message: QueryBlockMessageIdsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    writer.uint32(10).fork();
+
+    for (const v of message.messageIds) {
+      writer.uint32(v);
+    }
+
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryBlockMessageIdsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryBlockMessageIdsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+
+            while (reader.pos < end2) {
+              message.messageIds.push(reader.uint32());
+            }
+          } else {
+            message.messageIds.push(reader.uint32());
+          }
+
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryBlockMessageIdsResponse>): QueryBlockMessageIdsResponse {
+    const message = createBaseQueryBlockMessageIdsResponse();
+    message.messageIds = object.messageIds?.map(e => e) || [];
+    return message;
+  }
+
+};

package/src/codegen/zogux/delaymsg/tx.rpc.msg.ts

@@ -0,0 +1,27 @@
+import { Rpc } from "../../helpers";
+import * as _m0 from "protobufjs/minimal";
+import { MsgDelayMessage, MsgDelayMessageResponse } from "./tx";
+/** Msg defines the Msg service. */
+
+export interface Msg {
+  /**
+   * DelayMessage delays the execution of a message for a given number of
+   * blocks.
+   */
+  delayMessage(request: MsgDelayMessage): Promise<MsgDelayMessageResponse>;
+}
+export class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.delayMessage = this.delayMessage.bind(this);
+  }
+
+  delayMessage(request: MsgDelayMessage): Promise<MsgDelayMessageResponse> {
+    const data = MsgDelayMessage.encode(request).finish();
+    const promise = this.rpc.request("zogux.delaymsg.Msg", "DelayMessage", data);
+    return promise.then(data => MsgDelayMessageResponse.decode(new _m0.Reader(data)));
+  }
+
+}

package/src/codegen/zogux/delaymsg/tx.ts

@@ -0,0 +1,142 @@
+import { Any, AnySDKType } from "../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "../../helpers";
+/** MsgDelayMessage is a request type for the DelayMessage method. */
+
+export interface MsgDelayMessage {
+  authority: string;
+  /** The message to be delayed. */
+
+  msg?: Any;
+  /** The number of blocks to delay the message for. */
+
+  delayBlocks: number;
+}
+/** MsgDelayMessage is a request type for the DelayMessage method. */
+
+export interface MsgDelayMessageSDKType {
+  authority: string;
+  msg?: AnySDKType;
+  delay_blocks: number;
+}
+/** MsgDelayMessageResponse is a response type for the DelayMessage method. */
+
+export interface MsgDelayMessageResponse {
+  /** The id of the created delayed message. */
+  id: Long;
+}
+/** MsgDelayMessageResponse is a response type for the DelayMessage method. */
+
+export interface MsgDelayMessageResponseSDKType {
+  id: Long;
+}
+
+function createBaseMsgDelayMessage(): MsgDelayMessage {
+  return {
+    authority: "",
+    msg: undefined,
+    delayBlocks: 0
+  };
+}
+
+export const MsgDelayMessage = {
+  encode(message: MsgDelayMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+
+    if (message.msg !== undefined) {
+      Any.encode(message.msg, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.delayBlocks !== 0) {
+      writer.uint32(24).uint32(message.delayBlocks);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDelayMessage {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDelayMessage();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+
+        case 2:
+          message.msg = Any.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.delayBlocks = reader.uint32();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgDelayMessage>): MsgDelayMessage {
+    const message = createBaseMsgDelayMessage();
+    message.authority = object.authority ?? "";
+    message.msg = object.msg !== undefined && object.msg !== null ? Any.fromPartial(object.msg) : undefined;
+    message.delayBlocks = object.delayBlocks ?? 0;
+    return message;
+  }
+
+};
+
+function createBaseMsgDelayMessageResponse(): MsgDelayMessageResponse {
+  return {
+    id: Long.UZERO
+  };
+}
+
+export const MsgDelayMessageResponse = {
+  encode(message: MsgDelayMessageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (!message.id.isZero()) {
+      writer.uint32(8).uint64(message.id);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MsgDelayMessageResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgDelayMessageResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.id = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<MsgDelayMessageResponse>): MsgDelayMessageResponse {
+    const message = createBaseMsgDelayMessageResponse();
+    message.id = object.id !== undefined && object.id !== null ? Long.fromValue(object.id) : Long.UZERO;
+    return message;
+  }
+
+};