juno-network 0.7.0 → 0.9.0

package/types/codegen/ibc/core/channel/v1/query.lcd.d.ts

@@ -0,0 +1,21 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryChannelRequest, QueryChannelResponseSDKType, QueryChannelsRequest, QueryChannelsResponseSDKType, QueryConnectionChannelsRequest, QueryConnectionChannelsResponseSDKType, QueryChannelClientStateRequest, QueryChannelClientStateResponseSDKType, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponseSDKType, QueryPacketCommitmentRequest, QueryPacketCommitmentResponseSDKType, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponseSDKType, QueryPacketReceiptRequest, QueryPacketReceiptResponseSDKType, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponseSDKType, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponseSDKType, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponseSDKType, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponseSDKType, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    channel(params: QueryChannelRequest): Promise<QueryChannelResponseSDKType>;
+    channels(params?: QueryChannelsRequest): Promise<QueryChannelsResponseSDKType>;
+    connectionChannels(params: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponseSDKType>;
+    channelClientState(params: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponseSDKType>;
+    channelConsensusState(params: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponseSDKType>;
+    packetCommitment(params: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponseSDKType>;
+    packetCommitments(params: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponseSDKType>;
+    packetReceipt(params: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponseSDKType>;
+    packetAcknowledgement(params: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponseSDKType>;
+    packetAcknowledgements(params: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponseSDKType>;
+    unreceivedPackets(params: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponseSDKType>;
+    unreceivedAcks(params: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponseSDKType>;
+    nextSequenceReceive(params: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponseSDKType>;
+}

package/types/codegen/ibc/core/channel/v1/query.rpc.Query.d.ts

@@ -0,0 +1,88 @@
+import { Rpc } from "../../../../helpers";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryChannelRequest, QueryChannelResponse, QueryChannelsRequest, QueryChannelsResponse, QueryConnectionChannelsRequest, QueryConnectionChannelsResponse, QueryChannelClientStateRequest, QueryChannelClientStateResponse, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse, QueryPacketCommitmentRequest, QueryPacketCommitmentResponse, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse, QueryPacketReceiptRequest, QueryPacketReceiptResponse, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse } from "./query";
+/** Query provides defines the gRPC querier service */
+export interface Query {
+    /** Channel queries an IBC Channel. */
+    channel(request: QueryChannelRequest): Promise<QueryChannelResponse>;
+    /** Channels queries all the IBC channels of a chain. */
+    channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse>;
+    /**
+     * ConnectionChannels queries all the channels associated with a connection
+     * end.
+     */
+    connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse>;
+    /**
+     * ChannelClientState queries for the client state for the channel associated
+     * with the provided channel identifiers.
+     */
+    channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse>;
+    /**
+     * ChannelConsensusState queries for the consensus state for the channel
+     * associated with the provided channel identifiers.
+     */
+    channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse>;
+    /** PacketCommitment queries a stored packet commitment hash. */
+    packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse>;
+    /**
+     * PacketCommitments returns all the packet commitments hashes associated
+     * with a channel.
+     */
+    packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse>;
+    /**
+     * PacketReceipt queries if a given packet sequence has been received on the
+     * queried chain
+     */
+    packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse>;
+    /** PacketAcknowledgement queries a stored packet acknowledgement hash. */
+    packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse>;
+    /**
+     * PacketAcknowledgements returns all the packet acknowledgements associated
+     * with a channel.
+     */
+    packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse>;
+    /**
+     * UnreceivedPackets returns all the unreceived IBC packets associated with a
+     * channel and sequences.
+     */
+    unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse>;
+    /**
+     * UnreceivedAcks returns all the unreceived IBC acknowledgements associated
+     * with a channel and sequences.
+     */
+    unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse>;
+    /** NextSequenceReceive returns the next receive sequence for a given channel. */
+    nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    channel(request: QueryChannelRequest): Promise<QueryChannelResponse>;
+    channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse>;
+    connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse>;
+    channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse>;
+    channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse>;
+    packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse>;
+    packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse>;
+    packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse>;
+    packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse>;
+    packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse>;
+    unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse>;
+    unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse>;
+    nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    channel(request: QueryChannelRequest): Promise<QueryChannelResponse>;
+    channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse>;
+    connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse>;
+    channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse>;
+    channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse>;
+    packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse>;
+    packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse>;
+    packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse>;
+    packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse>;
+    packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse>;
+    unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse>;
+    unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse>;
+    nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse>;
+};

package/types/codegen/ibc/core/channel/v1/tx.amino.d.ts

@@ -0,0 +1,209 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoHeight } from "../../../../helpers";
+import { MsgChannelOpenInit, MsgChannelOpenTry, MsgChannelOpenAck, MsgChannelOpenConfirm, MsgChannelCloseInit, MsgChannelCloseConfirm, MsgRecvPacket, MsgTimeout, MsgTimeoutOnClose, MsgAcknowledgement } from "./tx";
+export interface AminoMsgChannelOpenInit extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelOpenInit";
+    value: {
+        port_id: string;
+        channel: {
+            state: number;
+            ordering: number;
+            counterparty: {
+                port_id: string;
+                channel_id: string;
+            };
+            connection_hops: string[];
+            version: string;
+        };
+        signer: string;
+    };
+}
+export interface AminoMsgChannelOpenTry extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelOpenTry";
+    value: {
+        port_id: string;
+        previous_channel_id: string;
+        channel: {
+            state: number;
+            ordering: number;
+            counterparty: {
+                port_id: string;
+                channel_id: string;
+            };
+            connection_hops: string[];
+            version: string;
+        };
+        counterparty_version: string;
+        proof_init: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgChannelOpenAck extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelOpenAck";
+    value: {
+        port_id: string;
+        channel_id: string;
+        counterparty_channel_id: string;
+        counterparty_version: string;
+        proof_try: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgChannelOpenConfirm extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelOpenConfirm";
+    value: {
+        port_id: string;
+        channel_id: string;
+        proof_ack: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgChannelCloseInit extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelCloseInit";
+    value: {
+        port_id: string;
+        channel_id: string;
+        signer: string;
+    };
+}
+export interface AminoMsgChannelCloseConfirm extends AminoMsg {
+    type: "cosmos-sdk/MsgChannelCloseConfirm";
+    value: {
+        port_id: string;
+        channel_id: string;
+        proof_init: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgRecvPacket extends AminoMsg {
+    type: "cosmos-sdk/MsgRecvPacket";
+    value: {
+        packet: {
+            sequence: string;
+            source_port: string;
+            source_channel: string;
+            destination_port: string;
+            destination_channel: string;
+            data: Uint8Array;
+            timeout_height: AminoHeight;
+            timeout_timestamp: string;
+        };
+        proof_commitment: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgTimeout extends AminoMsg {
+    type: "cosmos-sdk/MsgTimeout";
+    value: {
+        packet: {
+            sequence: string;
+            source_port: string;
+            source_channel: string;
+            destination_port: string;
+            destination_channel: string;
+            data: Uint8Array;
+            timeout_height: AminoHeight;
+            timeout_timestamp: string;
+        };
+        proof_unreceived: Uint8Array;
+        proof_height: AminoHeight;
+        next_sequence_recv: string;
+        signer: string;
+    };
+}
+export interface AminoMsgTimeoutOnClose extends AminoMsg {
+    type: "cosmos-sdk/MsgTimeoutOnClose";
+    value: {
+        packet: {
+            sequence: string;
+            source_port: string;
+            source_channel: string;
+            destination_port: string;
+            destination_channel: string;
+            data: Uint8Array;
+            timeout_height: AminoHeight;
+            timeout_timestamp: string;
+        };
+        proof_unreceived: Uint8Array;
+        proof_close: Uint8Array;
+        proof_height: AminoHeight;
+        next_sequence_recv: string;
+        signer: string;
+    };
+}
+export interface AminoMsgAcknowledgement extends AminoMsg {
+    type: "cosmos-sdk/MsgAcknowledgement";
+    value: {
+        packet: {
+            sequence: string;
+            source_port: string;
+            source_channel: string;
+            destination_port: string;
+            destination_channel: string;
+            data: Uint8Array;
+            timeout_height: AminoHeight;
+            timeout_timestamp: string;
+        };
+        acknowledgement: Uint8Array;
+        proof_acked: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export declare const AminoConverter: {
+    "/ibc.core.channel.v1.MsgChannelOpenInit": {
+        aminoType: string;
+        toAmino: ({ portId, channel, signer }: MsgChannelOpenInit) => AminoMsgChannelOpenInit["value"];
+        fromAmino: ({ port_id, channel, signer }: AminoMsgChannelOpenInit["value"]) => MsgChannelOpenInit;
+    };
+    "/ibc.core.channel.v1.MsgChannelOpenTry": {
+        aminoType: string;
+        toAmino: ({ portId, previousChannelId, channel, counterpartyVersion, proofInit, proofHeight, signer }: MsgChannelOpenTry) => AminoMsgChannelOpenTry["value"];
+        fromAmino: ({ port_id, previous_channel_id, channel, counterparty_version, proof_init, proof_height, signer }: AminoMsgChannelOpenTry["value"]) => MsgChannelOpenTry;
+    };
+    "/ibc.core.channel.v1.MsgChannelOpenAck": {
+        aminoType: string;
+        toAmino: ({ portId, channelId, counterpartyChannelId, counterpartyVersion, proofTry, proofHeight, signer }: MsgChannelOpenAck) => AminoMsgChannelOpenAck["value"];
+        fromAmino: ({ port_id, channel_id, counterparty_channel_id, counterparty_version, proof_try, proof_height, signer }: AminoMsgChannelOpenAck["value"]) => MsgChannelOpenAck;
+    };
+    "/ibc.core.channel.v1.MsgChannelOpenConfirm": {
+        aminoType: string;
+        toAmino: ({ portId, channelId, proofAck, proofHeight, signer }: MsgChannelOpenConfirm) => AminoMsgChannelOpenConfirm["value"];
+        fromAmino: ({ port_id, channel_id, proof_ack, proof_height, signer }: AminoMsgChannelOpenConfirm["value"]) => MsgChannelOpenConfirm;
+    };
+    "/ibc.core.channel.v1.MsgChannelCloseInit": {
+        aminoType: string;
+        toAmino: ({ portId, channelId, signer }: MsgChannelCloseInit) => AminoMsgChannelCloseInit["value"];
+        fromAmino: ({ port_id, channel_id, signer }: AminoMsgChannelCloseInit["value"]) => MsgChannelCloseInit;
+    };
+    "/ibc.core.channel.v1.MsgChannelCloseConfirm": {
+        aminoType: string;
+        toAmino: ({ portId, channelId, proofInit, proofHeight, signer }: MsgChannelCloseConfirm) => AminoMsgChannelCloseConfirm["value"];
+        fromAmino: ({ port_id, channel_id, proof_init, proof_height, signer }: AminoMsgChannelCloseConfirm["value"]) => MsgChannelCloseConfirm;
+    };
+    "/ibc.core.channel.v1.MsgRecvPacket": {
+        aminoType: string;
+        toAmino: ({ packet, proofCommitment, proofHeight, signer }: MsgRecvPacket) => AminoMsgRecvPacket["value"];
+        fromAmino: ({ packet, proof_commitment, proof_height, signer }: AminoMsgRecvPacket["value"]) => MsgRecvPacket;
+    };
+    "/ibc.core.channel.v1.MsgTimeout": {
+        aminoType: string;
+        toAmino: ({ packet, proofUnreceived, proofHeight, nextSequenceRecv, signer }: MsgTimeout) => AminoMsgTimeout["value"];
+        fromAmino: ({ packet, proof_unreceived, proof_height, next_sequence_recv, signer }: AminoMsgTimeout["value"]) => MsgTimeout;
+    };
+    "/ibc.core.channel.v1.MsgTimeoutOnClose": {
+        aminoType: string;
+        toAmino: ({ packet, proofUnreceived, proofClose, proofHeight, nextSequenceRecv, signer }: MsgTimeoutOnClose) => AminoMsgTimeoutOnClose["value"];
+        fromAmino: ({ packet, proof_unreceived, proof_close, proof_height, next_sequence_recv, signer }: AminoMsgTimeoutOnClose["value"]) => MsgTimeoutOnClose;
+    };
+    "/ibc.core.channel.v1.MsgAcknowledgement": {
+        aminoType: string;
+        toAmino: ({ packet, acknowledgement, proofAcked, proofHeight, signer }: MsgAcknowledgement) => AminoMsgAcknowledgement["value"];
+        fromAmino: ({ packet, acknowledgement, proof_acked, proof_height, signer }: AminoMsgAcknowledgement["value"]) => MsgAcknowledgement;
+    };
+};