juno-network 0.5.3 → 0.6.0

package/src/codegen/ibc/core/client/v1/genesis.ts

@@ -0,0 +1,288 @@
+import { IdentifiedClientState, IdentifiedClientStateSDKType, ClientConsensusStates, ClientConsensusStatesSDKType, Params, ParamsSDKType } from "./client";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the ibc client submodule's genesis state. */
+
+export interface GenesisState {
+  /** client states with their corresponding identifiers */
+  clients: IdentifiedClientState[];
+  /** consensus states from each client */
+
+  clientsConsensus: ClientConsensusStates[];
+  /** metadata from each client */
+
+  clientsMetadata: IdentifiedGenesisMetadata[];
+  params: Params;
+  /** create localhost on initialization */
+
+  createLocalhost: boolean;
+  /** the sequence for the next generated client identifier */
+
+  nextClientSequence: Long;
+}
+/** GenesisState defines the ibc client submodule's genesis state. */
+
+export interface GenesisStateSDKType {
+  /** client states with their corresponding identifiers */
+  clients: IdentifiedClientStateSDKType[];
+  /** consensus states from each client */
+
+  clients_consensus: ClientConsensusStatesSDKType[];
+  /** metadata from each client */
+
+  clients_metadata: IdentifiedGenesisMetadataSDKType[];
+  params: ParamsSDKType;
+  /** create localhost on initialization */
+
+  create_localhost: boolean;
+  /** the sequence for the next generated client identifier */
+
+  next_client_sequence: Long;
+}
+/**
+ * GenesisMetadata defines the genesis type for metadata that clients may return
+ * with ExportMetadata
+ */
+
+export interface GenesisMetadata {
+  /** store key of metadata without clientID-prefix */
+  key: Uint8Array;
+  /** metadata value */
+
+  value: Uint8Array;
+}
+/**
+ * GenesisMetadata defines the genesis type for metadata that clients may return
+ * with ExportMetadata
+ */
+
+export interface GenesisMetadataSDKType {
+  /** store key of metadata without clientID-prefix */
+  key: Uint8Array;
+  /** metadata value */
+
+  value: Uint8Array;
+}
+/**
+ * IdentifiedGenesisMetadata has the client metadata with the corresponding
+ * client id.
+ */
+
+export interface IdentifiedGenesisMetadata {
+  clientId: string;
+  clientMetadata: GenesisMetadata[];
+}
+/**
+ * IdentifiedGenesisMetadata has the client metadata with the corresponding
+ * client id.
+ */
+
+export interface IdentifiedGenesisMetadataSDKType {
+  client_id: string;
+  client_metadata: GenesisMetadataSDKType[];
+}
+
+function createBaseGenesisState(): GenesisState {
+  return {
+    clients: [],
+    clientsConsensus: [],
+    clientsMetadata: [],
+    params: undefined,
+    createLocalhost: false,
+    nextClientSequence: Long.UZERO
+  };
+}
+
+export const GenesisState = {
+  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.clients) {
+      IdentifiedClientState.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.clientsConsensus) {
+      ClientConsensusStates.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.clientsMetadata) {
+      IdentifiedGenesisMetadata.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(34).fork()).ldelim();
+    }
+
+    if (message.createLocalhost === true) {
+      writer.uint32(40).bool(message.createLocalhost);
+    }
+
+    if (!message.nextClientSequence.isZero()) {
+      writer.uint32(48).uint64(message.nextClientSequence);
+    }
+
+    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.clients.push(IdentifiedClientState.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.clientsConsensus.push(ClientConsensusStates.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.clientsMetadata.push(IdentifiedGenesisMetadata.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        case 5:
+          message.createLocalhost = reader.bool();
+          break;
+
+        case 6:
+          message.nextClientSequence = (reader.uint64() as Long);
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.clients = object.clients?.map(e => IdentifiedClientState.fromPartial(e)) || [];
+    message.clientsConsensus = object.clientsConsensus?.map(e => ClientConsensusStates.fromPartial(e)) || [];
+    message.clientsMetadata = object.clientsMetadata?.map(e => IdentifiedGenesisMetadata.fromPartial(e)) || [];
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.createLocalhost = object.createLocalhost ?? false;
+    message.nextClientSequence = object.nextClientSequence !== undefined && object.nextClientSequence !== null ? Long.fromValue(object.nextClientSequence) : Long.UZERO;
+    return message;
+  }
+
+};
+
+function createBaseGenesisMetadata(): GenesisMetadata {
+  return {
+    key: new Uint8Array(),
+    value: new Uint8Array()
+  };
+}
+
+export const GenesisMetadata = {
+  encode(message: GenesisMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.bytes();
+          break;
+
+        case 2:
+          message.value = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<GenesisMetadata>): GenesisMetadata {
+    const message = createBaseGenesisMetadata();
+    message.key = object.key ?? new Uint8Array();
+    message.value = object.value ?? new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseIdentifiedGenesisMetadata(): IdentifiedGenesisMetadata {
+  return {
+    clientId: "",
+    clientMetadata: []
+  };
+}
+
+export const IdentifiedGenesisMetadata = {
+  encode(message: IdentifiedGenesisMetadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.clientId !== "") {
+      writer.uint32(10).string(message.clientId);
+    }
+
+    for (const v of message.clientMetadata) {
+      GenesisMetadata.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): IdentifiedGenesisMetadata {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIdentifiedGenesisMetadata();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.clientId = reader.string();
+          break;
+
+        case 2:
+          message.clientMetadata.push(GenesisMetadata.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<IdentifiedGenesisMetadata>): IdentifiedGenesisMetadata {
+    const message = createBaseIdentifiedGenesisMetadata();
+    message.clientId = object.clientId ?? "";
+    message.clientMetadata = object.clientMetadata?.map(e => GenesisMetadata.fromPartial(e)) || [];
+    return message;
+  }
+
+};

package/src/codegen/ibc/core/client/v1/query.lcd.ts

@@ -0,0 +1,107 @@
+import { setPaginationParams } from "@osmonauts/helpers";
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryClientStateRequest, QueryClientStateResponseSDKType, QueryClientStatesRequest, QueryClientStatesResponseSDKType, QueryConsensusStateRequest, QueryConsensusStateResponseSDKType, QueryConsensusStatesRequest, QueryConsensusStatesResponseSDKType, QueryClientStatusRequest, QueryClientStatusResponseSDKType, QueryClientParamsRequest, QueryClientParamsResponseSDKType, QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponseSDKType, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.clientState = this.clientState.bind(this);
+    this.clientStates = this.clientStates.bind(this);
+    this.consensusState = this.consensusState.bind(this);
+    this.consensusStates = this.consensusStates.bind(this);
+    this.clientStatus = this.clientStatus.bind(this);
+    this.clientParams = this.clientParams.bind(this);
+    this.upgradedClientState = this.upgradedClientState.bind(this);
+    this.upgradedConsensusState = this.upgradedConsensusState.bind(this);
+  }
+  /* ClientState queries an IBC light client. */
+
+
+  async clientState(params: QueryClientStateRequest): Promise<QueryClientStateResponseSDKType> {
+    const endpoint = `ibc/core/client/v1/client_states/${params.clientId}`;
+    return await this.req.get<QueryClientStateResponseSDKType>(endpoint);
+  }
+  /* ClientStates queries all the IBC light clients of a chain. */
+
+
+  async clientStates(params: QueryClientStatesRequest = {
+    pagination: undefined
+  }): Promise<QueryClientStatesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `ibc/core/client/v1/client_states`;
+    return await this.req.get<QueryClientStatesResponseSDKType>(endpoint, options);
+  }
+  /* ConsensusState queries a consensus state associated with a client state at
+  a given height. */
+
+
+  async consensusState(params: QueryConsensusStateRequest): Promise<QueryConsensusStateResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.latestHeight !== "undefined") {
+      options.params.latest_height = params.latestHeight;
+    }
+
+    const endpoint = `ibc/core/client/v1/consensus_states/${params.clientId}/revision/${params.revisionNumber}height/${params.revisionHeight}`;
+    return await this.req.get<QueryConsensusStateResponseSDKType>(endpoint, options);
+  }
+  /* ConsensusStates queries all the consensus state associated with a given
+  client. */
+
+
+  async consensusStates(params: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+
+    const endpoint = `ibc/core/client/v1/consensus_states/${params.clientId}`;
+    return await this.req.get<QueryConsensusStatesResponseSDKType>(endpoint, options);
+  }
+  /* Status queries the status of an IBC client. */
+
+
+  async clientStatus(params: QueryClientStatusRequest): Promise<QueryClientStatusResponseSDKType> {
+    const endpoint = `ibc/core/client/v1/client_status/${params.clientId}`;
+    return await this.req.get<QueryClientStatusResponseSDKType>(endpoint);
+  }
+  /* ClientParams queries all parameters of the ibc client. */
+
+
+  async clientParams(_params: QueryClientParamsRequest = {}): Promise<QueryClientParamsResponseSDKType> {
+    const endpoint = `ibc/client/v1/params`;
+    return await this.req.get<QueryClientParamsResponseSDKType>(endpoint);
+  }
+  /* UpgradedClientState queries an Upgraded IBC light client. */
+
+
+  async upgradedClientState(_params: QueryUpgradedClientStateRequest = {}): Promise<QueryUpgradedClientStateResponseSDKType> {
+    const endpoint = `ibc/core/client/v1/upgraded_client_states`;
+    return await this.req.get<QueryUpgradedClientStateResponseSDKType>(endpoint);
+  }
+  /* UpgradedConsensusState queries an Upgraded IBC consensus state. */
+
+
+  async upgradedConsensusState(_params: QueryUpgradedConsensusStateRequest = {}): Promise<QueryUpgradedConsensusStateResponseSDKType> {
+    const endpoint = `ibc/core/client/v1/upgraded_consensus_states`;
+    return await this.req.get<QueryUpgradedConsensusStateResponseSDKType>(endpoint);
+  }
+
+}

package/src/codegen/ibc/core/client/v1/query.rpc.query.ts

@@ -0,0 +1,138 @@
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryClientStateRequest, QueryClientStateResponse, QueryClientStatesRequest, QueryClientStatesResponse, QueryConsensusStateRequest, QueryConsensusStateResponse, QueryConsensusStatesRequest, QueryConsensusStatesResponse, QueryClientStatusRequest, QueryClientStatusResponse, QueryClientParamsRequest, QueryClientParamsResponse, QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse } from "./query";
+/** Query defines the RPC service */
+
+export interface Query {
+  clientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse>;
+  /*ClientState queries an IBC light client.*/
+
+  clientStates(request?: QueryClientStatesRequest): Promise<QueryClientStatesResponse>;
+  /*ClientStates queries all the IBC light clients of a chain.*/
+
+  consensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse>;
+  /*ConsensusState queries a consensus state associated with a client state at
+  a given height.*/
+
+  consensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse>;
+  /*ConsensusStates queries all the consensus state associated with a given
+  client.*/
+
+  clientStatus(request: QueryClientStatusRequest): Promise<QueryClientStatusResponse>;
+  /*Status queries the status of an IBC client.*/
+
+  clientParams(request?: QueryClientParamsRequest): Promise<QueryClientParamsResponse>;
+  /*ClientParams queries all parameters of the ibc client.*/
+
+  upgradedClientState(request?: QueryUpgradedClientStateRequest): Promise<QueryUpgradedClientStateResponse>;
+  /*UpgradedClientState queries an Upgraded IBC light client.*/
+
+  upgradedConsensusState(request?: QueryUpgradedConsensusStateRequest): Promise<QueryUpgradedConsensusStateResponse>;
+  /*UpgradedConsensusState queries an Upgraded IBC consensus state.*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.clientState = this.clientState.bind(this);
+    this.clientStates = this.clientStates.bind(this);
+    this.consensusState = this.consensusState.bind(this);
+    this.consensusStates = this.consensusStates.bind(this);
+    this.clientStatus = this.clientStatus.bind(this);
+    this.clientParams = this.clientParams.bind(this);
+    this.upgradedClientState = this.upgradedClientState.bind(this);
+    this.upgradedConsensusState = this.upgradedConsensusState.bind(this);
+  }
+
+  clientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse> {
+    const data = QueryClientStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientState", data);
+    return promise.then(data => QueryClientStateResponse.decode(new _m0.Reader(data)));
+  }
+
+  clientStates(request: QueryClientStatesRequest = {
+    pagination: undefined
+  }): Promise<QueryClientStatesResponse> {
+    const data = QueryClientStatesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientStates", data);
+    return promise.then(data => QueryClientStatesResponse.decode(new _m0.Reader(data)));
+  }
+
+  consensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse> {
+    const data = QueryConsensusStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusState", data);
+    return promise.then(data => QueryConsensusStateResponse.decode(new _m0.Reader(data)));
+  }
+
+  consensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse> {
+    const data = QueryConsensusStatesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusStates", data);
+    return promise.then(data => QueryConsensusStatesResponse.decode(new _m0.Reader(data)));
+  }
+
+  clientStatus(request: QueryClientStatusRequest): Promise<QueryClientStatusResponse> {
+    const data = QueryClientStatusRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientStatus", data);
+    return promise.then(data => QueryClientStatusResponse.decode(new _m0.Reader(data)));
+  }
+
+  clientParams(request: QueryClientParamsRequest = {}): Promise<QueryClientParamsResponse> {
+    const data = QueryClientParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientParams", data);
+    return promise.then(data => QueryClientParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+  upgradedClientState(request: QueryUpgradedClientStateRequest = {}): Promise<QueryUpgradedClientStateResponse> {
+    const data = QueryUpgradedClientStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "UpgradedClientState", data);
+    return promise.then(data => QueryUpgradedClientStateResponse.decode(new _m0.Reader(data)));
+  }
+
+  upgradedConsensusState(request: QueryUpgradedConsensusStateRequest = {}): Promise<QueryUpgradedConsensusStateResponse> {
+    const data = QueryUpgradedConsensusStateRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v1.Query", "UpgradedConsensusState", data);
+    return promise.then(data => QueryUpgradedConsensusStateResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    clientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse> {
+      return queryService.clientState(request);
+    },
+
+    clientStates(request?: QueryClientStatesRequest): Promise<QueryClientStatesResponse> {
+      return queryService.clientStates(request);
+    },
+
+    consensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse> {
+      return queryService.consensusState(request);
+    },
+
+    consensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse> {
+      return queryService.consensusStates(request);
+    },
+
+    clientStatus(request: QueryClientStatusRequest): Promise<QueryClientStatusResponse> {
+      return queryService.clientStatus(request);
+    },
+
+    clientParams(request?: QueryClientParamsRequest): Promise<QueryClientParamsResponse> {
+      return queryService.clientParams(request);
+    },
+
+    upgradedClientState(request?: QueryUpgradedClientStateRequest): Promise<QueryUpgradedClientStateResponse> {
+      return queryService.upgradedClientState(request);
+    },
+
+    upgradedConsensusState(request?: QueryUpgradedConsensusStateRequest): Promise<QueryUpgradedConsensusStateResponse> {
+      return queryService.upgradedConsensusState(request);
+    }
+
+  };
+};