juno-network 0.5.3 → 0.6.0

package/src/codegen/ibc/applications/transfer/v1/query.rpc.query.ts

@@ -0,0 +1,66 @@
+import { Rpc } from "@osmonauts/helpers";
+import * as _m0 from "protobufjs/minimal";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryDenomTraceRequest, QueryDenomTraceResponse, QueryDenomTracesRequest, QueryDenomTracesResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
+/** Query defines the RPC service */
+
+export interface Query {
+  denomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse>;
+  /*DenomTrace queries a denomination trace information.*/
+
+  denomTraces(request?: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse>;
+  /*DenomTraces queries all denomination traces.*/
+
+  params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+  /*Params queries all parameters of the ibc-transfer module.*/
+
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.denomTrace = this.denomTrace.bind(this);
+    this.denomTraces = this.denomTraces.bind(this);
+    this.params = this.params.bind(this);
+  }
+
+  denomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse> {
+    const data = QueryDenomTraceRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTrace", data);
+    return promise.then(data => QueryDenomTraceResponse.decode(new _m0.Reader(data)));
+  }
+
+  denomTraces(request: QueryDenomTracesRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomTracesResponse> {
+    const data = QueryDenomTracesRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTraces", data);
+    return promise.then(data => QueryDenomTracesResponse.decode(new _m0.Reader(data)));
+  }
+
+  params(request: QueryParamsRequest = {}): Promise<QueryParamsResponse> {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+  }
+
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    denomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse> {
+      return queryService.denomTrace(request);
+    },
+
+    denomTraces(request?: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse> {
+      return queryService.denomTraces(request);
+    },
+
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    }
+
+  };
+};

package/src/codegen/ibc/applications/transfer/v1/query.ts

@@ -0,0 +1,369 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../../../cosmos/base/query/v1beta1/pagination";
+import { DenomTrace, DenomTraceSDKType, Params, ParamsSDKType } from "./transfer";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC
+ * method
+ */
+
+export interface QueryDenomTraceRequest {
+  /** hash (in hex format) of the denomination trace information. */
+  hash: string;
+}
+/**
+ * QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC
+ * method
+ */
+
+export interface QueryDenomTraceRequestSDKType {
+  /** hash (in hex format) of the denomination trace information. */
+  hash: string;
+}
+/**
+ * QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
+ * method.
+ */
+
+export interface QueryDenomTraceResponse {
+  /** denom_trace returns the requested denomination trace information. */
+  denomTrace: DenomTrace;
+}
+/**
+ * QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
+ * method.
+ */
+
+export interface QueryDenomTraceResponseSDKType {
+  /** denom_trace returns the requested denomination trace information. */
+  denom_trace: DenomTraceSDKType;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/DenomTraces RPC
+ * method
+ */
+
+export interface QueryDenomTracesRequest {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequest;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/DenomTraces RPC
+ * method
+ */
+
+export interface QueryDenomTracesRequestSDKType {
+  /** pagination defines an optional pagination for the request. */
+  pagination?: PageRequestSDKType;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/DenomTraces RPC
+ * method.
+ */
+
+export interface QueryDenomTracesResponse {
+  /** denom_traces returns all denominations trace information. */
+  denomTraces: DenomTrace[];
+  /** pagination defines the pagination in the response. */
+
+  pagination?: PageResponse;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/DenomTraces RPC
+ * method.
+ */
+
+export interface QueryDenomTracesResponseSDKType {
+  /** denom_traces returns all denominations trace information. */
+  denom_traces: DenomTraceSDKType[];
+  /** pagination defines the pagination in the response. */
+
+  pagination?: PageResponseSDKType;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequest {}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+
+export interface QueryParamsRequestSDKType {}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponse {
+  /** params defines the parameters of the module. */
+  params: Params;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+
+export interface QueryParamsResponseSDKType {
+  /** params defines the parameters of the module. */
+  params: ParamsSDKType;
+}
+
+function createBaseQueryDenomTraceRequest(): QueryDenomTraceRequest {
+  return {
+    hash: ""
+  };
+}
+
+export const QueryDenomTraceRequest = {
+  encode(message: QueryDenomTraceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hash !== "") {
+      writer.uint32(10).string(message.hash);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomTraceRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.hash = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomTraceRequest>): QueryDenomTraceRequest {
+    const message = createBaseQueryDenomTraceRequest();
+    message.hash = object.hash ?? "";
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomTraceResponse(): QueryDenomTraceResponse {
+  return {
+    denomTrace: undefined
+  };
+}
+
+export const QueryDenomTraceResponse = {
+  encode(message: QueryDenomTraceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.denomTrace !== undefined) {
+      DenomTrace.encode(message.denomTrace, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomTraceResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denomTrace = DenomTrace.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomTraceResponse>): QueryDenomTraceResponse {
+    const message = createBaseQueryDenomTraceResponse();
+    message.denomTrace = object.denomTrace !== undefined && object.denomTrace !== null ? DenomTrace.fromPartial(object.denomTrace) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomTracesRequest(): QueryDenomTracesRequest {
+  return {
+    pagination: undefined
+  };
+}
+
+export const QueryDenomTracesRequest = {
+  encode(message: QueryDenomTracesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pagination !== undefined) {
+      PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomTracesRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.pagination = PageRequest.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomTracesRequest>): QueryDenomTracesRequest {
+    const message = createBaseQueryDenomTracesRequest();
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryDenomTracesResponse(): QueryDenomTracesResponse {
+  return {
+    denomTraces: [],
+    pagination: undefined
+  };
+}
+
+export const QueryDenomTracesResponse = {
+  encode(message: QueryDenomTracesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.denomTraces) {
+      DenomTrace.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.pagination !== undefined) {
+      PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryDenomTracesResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.denomTraces.push(DenomTrace.decode(reader, reader.uint32()));
+          break;
+
+        case 2:
+          message.pagination = PageResponse.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryDenomTracesResponse>): QueryDenomTracesResponse {
+    const message = createBaseQueryDenomTracesResponse();
+    message.denomTraces = object.denomTraces?.map(e => DenomTrace.fromPartial(e)) || [];
+    message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseQueryParamsRequest(): QueryParamsRequest {
+  return {};
+}
+
+export const QueryParamsRequest = {
+  encode(_: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsRequest();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
+    const message = createBaseQueryParamsRequest();
+    return message;
+  }
+
+};
+
+function createBaseQueryParamsResponse(): QueryParamsResponse {
+  return {
+    params: undefined
+  };
+}
+
+export const QueryParamsResponse = {
+  encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryParamsResponse();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
+    const message = createBaseQueryParamsResponse();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    return message;
+  }
+
+};

package/src/codegen/ibc/applications/transfer/v1/transfer.ts

@@ -0,0 +1,182 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+
+export interface DenomTrace {
+  /**
+   * path defines the chain of port/channel identifiers used for tracing the
+   * source of the fungible token.
+   */
+  path: string;
+  /** base denomination of the relayed fungible token. */
+
+  baseDenom: string;
+}
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+
+export interface DenomTraceSDKType {
+  /**
+   * path defines the chain of port/channel identifiers used for tracing the
+   * source of the fungible token.
+   */
+  path: string;
+  /** base denomination of the relayed fungible token. */
+
+  base_denom: string;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+
+export interface Params {
+  /**
+   * send_enabled enables or disables all cross-chain token transfers from this
+   * chain.
+   */
+  sendEnabled: boolean;
+  /**
+   * receive_enabled enables or disables all cross-chain token transfers to this
+   * chain.
+   */
+
+  receiveEnabled: boolean;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+
+export interface ParamsSDKType {
+  /**
+   * send_enabled enables or disables all cross-chain token transfers from this
+   * chain.
+   */
+  send_enabled: boolean;
+  /**
+   * receive_enabled enables or disables all cross-chain token transfers to this
+   * chain.
+   */
+
+  receive_enabled: boolean;
+}
+
+function createBaseDenomTrace(): DenomTrace {
+  return {
+    path: "",
+    baseDenom: ""
+  };
+}
+
+export const DenomTrace = {
+  encode(message: DenomTrace, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.path !== "") {
+      writer.uint32(10).string(message.path);
+    }
+
+    if (message.baseDenom !== "") {
+      writer.uint32(18).string(message.baseDenom);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DenomTrace {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDenomTrace();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.path = reader.string();
+          break;
+
+        case 2:
+          message.baseDenom = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<DenomTrace>): DenomTrace {
+    const message = createBaseDenomTrace();
+    message.path = object.path ?? "";
+    message.baseDenom = object.baseDenom ?? "";
+    return message;
+  }
+
+};
+
+function createBaseParams(): Params {
+  return {
+    sendEnabled: false,
+    receiveEnabled: false
+  };
+}
+
+export const Params = {
+  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.sendEnabled === true) {
+      writer.uint32(8).bool(message.sendEnabled);
+    }
+
+    if (message.receiveEnabled === true) {
+      writer.uint32(16).bool(message.receiveEnabled);
+    }
+
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Params {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParams();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.sendEnabled = reader.bool();
+          break;
+
+        case 2:
+          message.receiveEnabled = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.sendEnabled = object.sendEnabled ?? false;
+    message.receiveEnabled = object.receiveEnabled ?? false;
+    return message;
+  }
+
+};

package/src/codegen/ibc/applications/transfer/v1/tx.amino.ts

@@ -0,0 +1,73 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoHeight, Long, omitDefault } from "@osmonauts/helpers";
+import { MsgTransfer } from "./tx";
+export interface AminoMsgTransfer extends AminoMsg {
+  type: "cosmos-sdk/MsgTransfer";
+  value: {
+    source_port: string;
+    source_channel: string;
+    token: {
+      denom: string;
+      amount: string;
+    };
+    sender: string;
+    receiver: string;
+    timeout_height: AminoHeight;
+    timeout_timestamp: string;
+  };
+}
+export const AminoConverter = {
+  "/ibc.applications.transfer.v1.MsgTransfer": {
+    aminoType: "cosmos-sdk/MsgTransfer",
+    toAmino: ({
+      sourcePort,
+      sourceChannel,
+      token,
+      sender,
+      receiver,
+      timeoutHeight,
+      timeoutTimestamp
+    }: MsgTransfer): AminoMsgTransfer["value"] => {
+      return {
+        source_port: sourcePort,
+        source_channel: sourceChannel,
+        token: {
+          denom: token.denom,
+          amount: Long.fromNumber(token.amount).toString()
+        },
+        sender,
+        receiver,
+        timeout_height: timeoutHeight ? {
+          revision_height: omitDefault(timeoutHeight.revisionHeight)?.toString(),
+          revision_number: omitDefault(timeoutHeight.revisionNumber)?.toString()
+        } : {},
+        timeout_timestamp: timeoutTimestamp.toString()
+      };
+    },
+    fromAmino: ({
+      source_port,
+      source_channel,
+      token,
+      sender,
+      receiver,
+      timeout_height,
+      timeout_timestamp
+    }: AminoMsgTransfer["value"]): MsgTransfer => {
+      return {
+        sourcePort: source_port,
+        sourceChannel: source_channel,
+        token: {
+          denom: token.denom,
+          amount: token.amount
+        },
+        sender,
+        receiver,
+        timeoutHeight: timeout_height ? {
+          revisionHeight: Long.fromString(timeout_height.revision_height || "0", true),
+          revisionNumber: Long.fromString(timeout_height.revision_number || "0", true)
+        } : undefined,
+        timeoutTimestamp: Long.fromString(timeout_timestamp)
+      };
+    }
+  }
+};