juno-network 0.0.2

package/types/codegen/ibc/applications/transfer/v1/query.d.ts

@@ -0,0 +1,88 @@
+import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination";
+import { DenomTrace, Params } 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;
+}
+/**
+ * QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
+ * method.
+ */
+export interface QueryDenomTraceResponse {
+    /** denom_trace returns the requested denomination trace information. */
+    denomTrace: DenomTrace;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/DenomTraces RPC
+ * method
+ */
+export interface QueryDenomTracesRequest {
+    /** pagination defines an optional pagination for the request. */
+    pagination: PageRequest;
+}
+/**
+ * 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;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+export declare const QueryDenomTraceRequest: {
+    encode(message: QueryDenomTraceRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceRequest;
+    fromJSON(object: any): QueryDenomTraceRequest;
+    toJSON(message: QueryDenomTraceRequest): unknown;
+    fromPartial(object: DeepPartial<QueryDenomTraceRequest>): QueryDenomTraceRequest;
+};
+export declare const QueryDenomTraceResponse: {
+    encode(message: QueryDenomTraceResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceResponse;
+    fromJSON(object: any): QueryDenomTraceResponse;
+    toJSON(message: QueryDenomTraceResponse): unknown;
+    fromPartial(object: DeepPartial<QueryDenomTraceResponse>): QueryDenomTraceResponse;
+};
+export declare const QueryDenomTracesRequest: {
+    encode(message: QueryDenomTracesRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesRequest;
+    fromJSON(object: any): QueryDenomTracesRequest;
+    toJSON(message: QueryDenomTracesRequest): unknown;
+    fromPartial(object: DeepPartial<QueryDenomTracesRequest>): QueryDenomTracesRequest;
+};
+export declare const QueryDenomTracesResponse: {
+    encode(message: QueryDenomTracesResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesResponse;
+    fromJSON(object: any): QueryDenomTracesResponse;
+    toJSON(message: QueryDenomTracesResponse): unknown;
+    fromPartial(object: DeepPartial<QueryDenomTracesResponse>): QueryDenomTracesResponse;
+};
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): unknown;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+};

package/types/codegen/ibc/applications/transfer/v1/query.lcd.d.ts

@@ -0,0 +1,10 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryDenomTraceRequest, QueryDenomTraceResponse, QueryDenomTracesRequest, QueryDenomTracesResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    denomTrace(params: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse>;
+    denomTraces(params: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse>;
+    params(params: QueryParamsRequest): Promise<QueryParamsResponse>;
+}

package/types/codegen/ibc/applications/transfer/v1/query.rpc.query.d.ts

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryDenomTraceRequest, QueryDenomTraceResponse, QueryDenomTracesRequest, QueryDenomTracesResponse, QueryParamsRequest, QueryParamsResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    denomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse>;
+    denomTraces(request: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse>;
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    denomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse>;
+    denomTraces(request: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse>;
+    params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+}

package/types/codegen/ibc/applications/transfer/v1/transfer.d.ts

@@ -0,0 +1,47 @@
+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;
+}
+/**
+ * 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;
+}
+export declare const DenomTrace: {
+    encode(message: DenomTrace, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DenomTrace;
+    fromJSON(object: any): DenomTrace;
+    toJSON(message: DenomTrace): unknown;
+    fromPartial(object: DeepPartial<DenomTrace>): DenomTrace;
+};
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromJSON(object: any): Params;
+    toJSON(message: Params): unknown;
+    fromPartial(object: DeepPartial<Params>): Params;
+};

package/types/codegen/ibc/applications/transfer/v1/tx.amino.d.ts

@@ -0,0 +1,25 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoHeight } 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 declare const AminoConverter: {
+    "/ibc.applications.transfer.v1.MsgTransfer": {
+        aminoType: string;
+        toAmino: ({ sourcePort, sourceChannel, token, sender, receiver, timeoutHeight, timeoutTimestamp }: MsgTransfer) => AminoMsgTransfer["value"];
+        fromAmino: ({ source_port, source_channel, token, sender, receiver, timeout_height, timeout_timestamp }: AminoMsgTransfer["value"]) => MsgTransfer;
+    };
+};

package/types/codegen/ibc/applications/transfer/v1/tx.d.ts

@@ -0,0 +1,48 @@
+import { Coin } from "../../../../cosmos/base/v1beta1/coin";
+import { Height } from "../../../core/client/v1/client";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
+ * ICS20 enabled chains. See ICS Spec here:
+ * https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
+ */
+export interface MsgTransfer {
+    /** the port on which the packet will be sent */
+    sourcePort: string;
+    /** the channel by which the packet will be sent */
+    sourceChannel: string;
+    /** the tokens to be transferred */
+    token: Coin;
+    /** the sender address */
+    sender: string;
+    /** the recipient address on the destination chain */
+    receiver: string;
+    /**
+     * Timeout height relative to the current block height.
+     * The timeout is disabled when set to 0.
+     */
+    timeoutHeight: Height;
+    /**
+     * Timeout timestamp (in nanoseconds) relative to the current block timestamp.
+     * The timeout is disabled when set to 0.
+     */
+    timeoutTimestamp: Long;
+}
+/** MsgTransferResponse defines the Msg/Transfer response type. */
+export interface MsgTransferResponse {
+}
+export declare const MsgTransfer: {
+    encode(message: MsgTransfer, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransfer;
+    fromJSON(object: any): MsgTransfer;
+    toJSON(message: MsgTransfer): unknown;
+    fromPartial(object: DeepPartial<MsgTransfer>): MsgTransfer;
+};
+export declare const MsgTransferResponse: {
+    encode(_: MsgTransferResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransferResponse;
+    fromJSON(_: any): MsgTransferResponse;
+    toJSON(_: MsgTransferResponse): unknown;
+    fromPartial(_: DeepPartial<MsgTransferResponse>): MsgTransferResponse;
+};

package/types/codegen/ibc/applications/transfer/v1/tx.registry.d.ts

@@ -0,0 +1,36 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgTransfer } from "./tx";
+export declare const registry: ReadonlyArray<[string, GeneratedType]>;
+export declare const load: (protoRegistry: Registry) => void;
+export declare const MessageComposer: {
+    encoded: {
+        transfer(value: MsgTransfer): {
+            typeUrl: string;
+            value: Uint8Array;
+        };
+    };
+    withTypeUrl: {
+        transfer(value: MsgTransfer): {
+            typeUrl: string;
+            value: MsgTransfer;
+        };
+    };
+    toJSON: {
+        transfer(value: MsgTransfer): {
+            typeUrl: string;
+            value: unknown;
+        };
+    };
+    fromJSON: {
+        transfer(value: any): {
+            typeUrl: string;
+            value: MsgTransfer;
+        };
+    };
+    fromPartial: {
+        transfer(value: MsgTransfer): {
+            typeUrl: string;
+            value: MsgTransfer;
+        };
+    };
+};

package/types/codegen/ibc/applications/transfer/v1/tx.rpc.msg.d.ts

@@ -0,0 +1,11 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgTransfer, MsgTransferResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    transfer(request: MsgTransfer): Promise<MsgTransferResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    transfer(request: MsgTransfer): Promise<MsgTransferResponse>;
+}

package/types/codegen/ibc/applications/transfer/v2/packet.d.ts

@@ -0,0 +1,24 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * FungibleTokenPacketData defines a struct for the packet payload
+ * See FungibleTokenPacketData spec:
+ * https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
+ */
+export interface FungibleTokenPacketData {
+    /** the token denomination to be transferred */
+    denom: string;
+    /** the token amount to be transferred */
+    amount: string;
+    /** the sender address */
+    sender: string;
+    /** the recipient address on the destination chain */
+    receiver: string;
+}
+export declare const FungibleTokenPacketData: {
+    encode(message: FungibleTokenPacketData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FungibleTokenPacketData;
+    fromJSON(object: any): FungibleTokenPacketData;
+    toJSON(message: FungibleTokenPacketData): unknown;
+    fromPartial(object: DeepPartial<FungibleTokenPacketData>): FungibleTokenPacketData;
+};