juno-network 0.4.0 → 0.5.0

package/types/codegen/ibc/core/connection/v1/query.d.ts

@@ -0,0 +1,264 @@
+import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../../../cosmos/base/query/v1beta1/pagination";
+import { ConnectionEnd, ConnectionEndSDKType, IdentifiedConnection, IdentifiedConnectionSDKType } from "./connection";
+import { Height, HeightSDKType, IdentifiedClientState, IdentifiedClientStateSDKType } from "../../client/v1/client";
+import { Any, AnySDKType } from "../../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial, Long } from "@osmonauts/helpers";
+/**
+ * QueryConnectionRequest is the request type for the Query/Connection RPC
+ * method
+ */
+export interface QueryConnectionRequest {
+    /** connection unique identifier */
+    connectionId: string;
+}
+/**
+ * QueryConnectionRequest is the request type for the Query/Connection RPC
+ * method
+ */
+export interface QueryConnectionRequestSDKType {
+    /** connection unique identifier */
+    connection_id: string;
+}
+/**
+ * QueryConnectionResponse is the response type for the Query/Connection RPC
+ * method. Besides the connection end, it includes a proof and the height from
+ * which the proof was retrieved.
+ */
+export interface QueryConnectionResponse {
+    /** connection associated with the request identifier */
+    connection: ConnectionEnd;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight: Height;
+}
+/**
+ * QueryConnectionResponse is the response type for the Query/Connection RPC
+ * method. Besides the connection end, it includes a proof and the height from
+ * which the proof was retrieved.
+ */
+export interface QueryConnectionResponseSDKType {
+    /** connection associated with the request identifier */
+    connection: ConnectionEndSDKType;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height: HeightSDKType;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ */
+export interface QueryConnectionsRequest {
+    pagination?: PageRequest;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ */
+export interface QueryConnectionsRequestSDKType {
+    pagination?: PageRequestSDKType;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/Connections RPC
+ * method.
+ */
+export interface QueryConnectionsResponse {
+    /** list of stored connections of the chain. */
+    connections: IdentifiedConnection[];
+    /** pagination response */
+    pagination?: PageResponse;
+    /** query block height */
+    height: Height;
+}
+/**
+ * QueryConnectionsResponse is the response type for the Query/Connections RPC
+ * method.
+ */
+export interface QueryConnectionsResponseSDKType {
+    /** list of stored connections of the chain. */
+    connections: IdentifiedConnectionSDKType[];
+    /** pagination response */
+    pagination?: PageResponseSDKType;
+    /** query block height */
+    height: HeightSDKType;
+}
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsRequest {
+    /** client identifier associated with a connection */
+    clientId: string;
+}
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsRequestSDKType {
+    /** client identifier associated with a connection */
+    client_id: string;
+}
+/**
+ * QueryClientConnectionsResponse is the response type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsResponse {
+    /** slice of all the connection paths associated with a client. */
+    connectionPaths: string[];
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was generated */
+    proofHeight: Height;
+}
+/**
+ * QueryClientConnectionsResponse is the response type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsResponseSDKType {
+    /** slice of all the connection paths associated with a client. */
+    connection_paths: string[];
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was generated */
+    proof_height: HeightSDKType;
+}
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateRequest {
+    /** connection identifier */
+    connectionId: string;
+}
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateRequestSDKType {
+    /** connection identifier */
+    connection_id: string;
+}
+/**
+ * QueryConnectionClientStateResponse is the response type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateResponse {
+    /** client state associated with the channel */
+    identifiedClientState: IdentifiedClientState;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight: Height;
+}
+/**
+ * QueryConnectionClientStateResponse is the response type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateResponseSDKType {
+    /** client state associated with the channel */
+    identified_client_state: IdentifiedClientStateSDKType;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height: HeightSDKType;
+}
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateRequest {
+    /** connection identifier */
+    connectionId: string;
+    revisionNumber: Long;
+    revisionHeight: Long;
+}
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateRequestSDKType {
+    /** connection identifier */
+    connection_id: string;
+    revision_number: Long;
+    revision_height: Long;
+}
+/**
+ * QueryConnectionConsensusStateResponse is the response type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateResponse {
+    /** consensus state associated with the channel */
+    consensusState: Any;
+    /** client ID associated with the consensus state */
+    clientId: string;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proofHeight: Height;
+}
+/**
+ * QueryConnectionConsensusStateResponse is the response type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateResponseSDKType {
+    /** consensus state associated with the channel */
+    consensus_state: AnySDKType;
+    /** client ID associated with the consensus state */
+    client_id: string;
+    /** merkle proof of existence */
+    proof: Uint8Array;
+    /** height at which the proof was retrieved */
+    proof_height: HeightSDKType;
+}
+export declare const QueryConnectionRequest: {
+    encode(message: QueryConnectionRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionRequest;
+    fromPartial(object: DeepPartial<QueryConnectionRequest>): QueryConnectionRequest;
+};
+export declare const QueryConnectionResponse: {
+    encode(message: QueryConnectionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionResponseSDKType;
+    fromPartial(object: DeepPartial<QueryConnectionResponse>): QueryConnectionResponse;
+};
+export declare const QueryConnectionsRequest: {
+    encode(message: QueryConnectionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionsRequest;
+    fromPartial(object: DeepPartial<QueryConnectionsRequest>): QueryConnectionsRequest;
+};
+export declare const QueryConnectionsResponse: {
+    encode(message: QueryConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionsResponseSDKType;
+    fromPartial(object: DeepPartial<QueryConnectionsResponse>): QueryConnectionsResponse;
+};
+export declare const QueryClientConnectionsRequest: {
+    encode(message: QueryClientConnectionsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientConnectionsRequest;
+    fromPartial(object: DeepPartial<QueryClientConnectionsRequest>): QueryClientConnectionsRequest;
+};
+export declare const QueryClientConnectionsResponse: {
+    encode(message: QueryClientConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientConnectionsResponseSDKType;
+    fromPartial(object: DeepPartial<QueryClientConnectionsResponse>): QueryClientConnectionsResponse;
+};
+export declare const QueryConnectionClientStateRequest: {
+    encode(message: QueryConnectionClientStateRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionClientStateRequest;
+    fromPartial(object: DeepPartial<QueryConnectionClientStateRequest>): QueryConnectionClientStateRequest;
+};
+export declare const QueryConnectionClientStateResponse: {
+    encode(message: QueryConnectionClientStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionClientStateResponseSDKType;
+    fromPartial(object: DeepPartial<QueryConnectionClientStateResponse>): QueryConnectionClientStateResponse;
+};
+export declare const QueryConnectionConsensusStateRequest: {
+    encode(message: QueryConnectionConsensusStateRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionConsensusStateRequest;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateRequest>): QueryConnectionConsensusStateRequest;
+};
+export declare const QueryConnectionConsensusStateResponse: {
+    encode(message: QueryConnectionConsensusStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionConsensusStateResponseSDKType;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateResponse>): QueryConnectionConsensusStateResponse;
+};

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

@@ -0,0 +1,13 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryConnectionRequest, QueryConnectionResponseSDKType, QueryConnectionsRequest, QueryConnectionsResponseSDKType, QueryClientConnectionsRequest, QueryClientConnectionsResponseSDKType, QueryConnectionClientStateRequest, QueryConnectionClientStateResponseSDKType, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    connection(params: QueryConnectionRequest): Promise<QueryConnectionResponseSDKType>;
+    connections(params?: QueryConnectionsRequest): Promise<QueryConnectionsResponseSDKType>;
+    clientConnections(params: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponseSDKType>;
+    connectionClientState(params: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponseSDKType>;
+    connectionConsensusState(params: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponseSDKType>;
+}

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

@@ -0,0 +1,27 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryConnectionRequest, QueryConnectionResponseSDKType, QueryConnectionsRequest, QueryConnectionsResponseSDKType, QueryClientConnectionsRequest, QueryClientConnectionsResponseSDKType, QueryConnectionClientStateRequest, QueryConnectionClientStateResponseSDKType, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponseSDKType } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponseSDKType>;
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponseSDKType>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponseSDKType>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponseSDKType>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponseSDKType>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponseSDKType>;
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponseSDKType>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponseSDKType>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponseSDKType>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponseSDKType>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponseSDKType>;
+    connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponseSDKType>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponseSDKType>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponseSDKType>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponseSDKType>;
+};

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

@@ -0,0 +1,103 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoHeight } from "@osmonauts/helpers";
+import { MsgConnectionOpenInit, MsgConnectionOpenTry, MsgConnectionOpenAck, MsgConnectionOpenConfirm } from "./tx";
+export interface AminoMsgConnectionOpenInit extends AminoMsg {
+    type: "cosmos-sdk/MsgConnectionOpenInit";
+    value: {
+        client_id: string;
+        counterparty: {
+            client_id: string;
+            connection_id: string;
+            prefix: {
+                key_prefix: Uint8Array;
+            };
+        };
+        version: {
+            identifier: string;
+            features: string[];
+        };
+        delay_period: string;
+        signer: string;
+    };
+}
+export interface AminoMsgConnectionOpenTry extends AminoMsg {
+    type: "cosmos-sdk/MsgConnectionOpenTry";
+    value: {
+        client_id: string;
+        previous_connection_id: string;
+        client_state: {
+            type_url: string;
+            value: Uint8Array;
+        };
+        counterparty: {
+            client_id: string;
+            connection_id: string;
+            prefix: {
+                key_prefix: Uint8Array;
+            };
+        };
+        delay_period: string;
+        counterparty_versions: {
+            identifier: string;
+            features: string[];
+        }[];
+        proof_height: AminoHeight;
+        proof_init: Uint8Array;
+        proof_client: Uint8Array;
+        proof_consensus: Uint8Array;
+        consensus_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgConnectionOpenAck extends AminoMsg {
+    type: "cosmos-sdk/MsgConnectionOpenAck";
+    value: {
+        connection_id: string;
+        counterparty_connection_id: string;
+        version: {
+            identifier: string;
+            features: string[];
+        };
+        client_state: {
+            type_url: string;
+            value: Uint8Array;
+        };
+        proof_height: AminoHeight;
+        proof_try: Uint8Array;
+        proof_client: Uint8Array;
+        proof_consensus: Uint8Array;
+        consensus_height: AminoHeight;
+        signer: string;
+    };
+}
+export interface AminoMsgConnectionOpenConfirm extends AminoMsg {
+    type: "cosmos-sdk/MsgConnectionOpenConfirm";
+    value: {
+        connection_id: string;
+        proof_ack: Uint8Array;
+        proof_height: AminoHeight;
+        signer: string;
+    };
+}
+export declare const AminoConverter: {
+    "/ibc.core.connection.v1.MsgConnectionOpenInit": {
+        aminoType: string;
+        toAmino: ({ clientId, counterparty, version, delayPeriod, signer }: MsgConnectionOpenInit) => AminoMsgConnectionOpenInit["value"];
+        fromAmino: ({ client_id, counterparty, version, delay_period, signer }: AminoMsgConnectionOpenInit["value"]) => MsgConnectionOpenInit;
+    };
+    "/ibc.core.connection.v1.MsgConnectionOpenTry": {
+        aminoType: string;
+        toAmino: ({ clientId, previousConnectionId, clientState, counterparty, delayPeriod, counterpartyVersions, proofHeight, proofInit, proofClient, proofConsensus, consensusHeight, signer }: MsgConnectionOpenTry) => AminoMsgConnectionOpenTry["value"];
+        fromAmino: ({ client_id, previous_connection_id, client_state, counterparty, delay_period, counterparty_versions, proof_height, proof_init, proof_client, proof_consensus, consensus_height, signer }: AminoMsgConnectionOpenTry["value"]) => MsgConnectionOpenTry;
+    };
+    "/ibc.core.connection.v1.MsgConnectionOpenAck": {
+        aminoType: string;
+        toAmino: ({ connectionId, counterpartyConnectionId, version, clientState, proofHeight, proofTry, proofClient, proofConsensus, consensusHeight, signer }: MsgConnectionOpenAck) => AminoMsgConnectionOpenAck["value"];
+        fromAmino: ({ connection_id, counterparty_connection_id, version, client_state, proof_height, proof_try, proof_client, proof_consensus, consensus_height, signer }: AminoMsgConnectionOpenAck["value"]) => MsgConnectionOpenAck;
+    };
+    "/ibc.core.connection.v1.MsgConnectionOpenConfirm": {
+        aminoType: string;
+        toAmino: ({ connectionId, proofAck, proofHeight, signer }: MsgConnectionOpenConfirm) => AminoMsgConnectionOpenConfirm["value"];
+        fromAmino: ({ connection_id, proof_ack, proof_height, signer }: AminoMsgConnectionOpenConfirm["value"]) => MsgConnectionOpenConfirm;
+    };
+};

package/types/codegen/ibc/core/connection/v1/tx.d.ts

@@ -0,0 +1,225 @@
+import { Counterparty, CounterpartySDKType, Version, VersionSDKType } from "./connection";
+import { Any, AnySDKType } from "../../../../google/protobuf/any";
+import { Height, HeightSDKType } from "../../client/v1/client";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * MsgConnectionOpenInit defines the msg sent by an account on Chain A to
+ * initialize a connection with Chain B.
+ */
+export interface MsgConnectionOpenInit {
+    clientId: string;
+    counterparty: Counterparty;
+    version: Version;
+    delayPeriod: Long;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenInit defines the msg sent by an account on Chain A to
+ * initialize a connection with Chain B.
+ */
+export interface MsgConnectionOpenInitSDKType {
+    client_id: string;
+    counterparty: CounterpartySDKType;
+    version: VersionSDKType;
+    delay_period: Long;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response
+ * type.
+ */
+export interface MsgConnectionOpenInitResponse {
+}
+/**
+ * MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response
+ * type.
+ */
+export interface MsgConnectionOpenInitResponseSDKType {
+}
+/**
+ * MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a
+ * connection on Chain B.
+ */
+export interface MsgConnectionOpenTry {
+    clientId: string;
+    /**
+     * in the case of crossing hello's, when both chains call OpenInit, we need
+     * the connection identifier of the previous connection in state INIT
+     */
+    previousConnectionId: string;
+    clientState: Any;
+    counterparty: Counterparty;
+    delayPeriod: Long;
+    counterpartyVersions: Version[];
+    proofHeight: Height;
+    /**
+     * proof of the initialization the connection on Chain A: `UNITIALIZED ->
+     * INIT`
+     */
+    proofInit: Uint8Array;
+    /** proof of client state included in message */
+    proofClient: Uint8Array;
+    /** proof of client consensus state */
+    proofConsensus: Uint8Array;
+    consensusHeight: Height;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a
+ * connection on Chain B.
+ */
+export interface MsgConnectionOpenTrySDKType {
+    client_id: string;
+    /**
+     * in the case of crossing hello's, when both chains call OpenInit, we need
+     * the connection identifier of the previous connection in state INIT
+     */
+    previous_connection_id: string;
+    client_state: AnySDKType;
+    counterparty: CounterpartySDKType;
+    delay_period: Long;
+    counterparty_versions: VersionSDKType[];
+    proof_height: HeightSDKType;
+    /**
+     * proof of the initialization the connection on Chain A: `UNITIALIZED ->
+     * INIT`
+     */
+    proof_init: Uint8Array;
+    /** proof of client state included in message */
+    proof_client: Uint8Array;
+    /** proof of client consensus state */
+    proof_consensus: Uint8Array;
+    consensus_height: HeightSDKType;
+    signer: string;
+}
+/** MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type. */
+export interface MsgConnectionOpenTryResponse {
+}
+/** MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type. */
+export interface MsgConnectionOpenTryResponseSDKType {
+}
+/**
+ * MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to
+ * acknowledge the change of connection state to TRYOPEN on Chain B.
+ */
+export interface MsgConnectionOpenAck {
+    connectionId: string;
+    counterpartyConnectionId: string;
+    version: Version;
+    clientState: Any;
+    proofHeight: Height;
+    /**
+     * proof of the initialization the connection on Chain B: `UNITIALIZED ->
+     * TRYOPEN`
+     */
+    proofTry: Uint8Array;
+    /** proof of client state included in message */
+    proofClient: Uint8Array;
+    /** proof of client consensus state */
+    proofConsensus: Uint8Array;
+    consensusHeight: Height;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to
+ * acknowledge the change of connection state to TRYOPEN on Chain B.
+ */
+export interface MsgConnectionOpenAckSDKType {
+    connection_id: string;
+    counterparty_connection_id: string;
+    version: VersionSDKType;
+    client_state: AnySDKType;
+    proof_height: HeightSDKType;
+    /**
+     * proof of the initialization the connection on Chain B: `UNITIALIZED ->
+     * TRYOPEN`
+     */
+    proof_try: Uint8Array;
+    /** proof of client state included in message */
+    proof_client: Uint8Array;
+    /** proof of client consensus state */
+    proof_consensus: Uint8Array;
+    consensus_height: HeightSDKType;
+    signer: string;
+}
+/** MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type. */
+export interface MsgConnectionOpenAckResponse {
+}
+/** MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type. */
+export interface MsgConnectionOpenAckResponseSDKType {
+}
+/**
+ * MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to
+ * acknowledge the change of connection state to OPEN on Chain A.
+ */
+export interface MsgConnectionOpenConfirm {
+    connectionId: string;
+    /** proof for the change of the connection state on Chain A: `INIT -> OPEN` */
+    proofAck: Uint8Array;
+    proofHeight: Height;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to
+ * acknowledge the change of connection state to OPEN on Chain A.
+ */
+export interface MsgConnectionOpenConfirmSDKType {
+    connection_id: string;
+    /** proof for the change of the connection state on Chain A: `INIT -> OPEN` */
+    proof_ack: Uint8Array;
+    proof_height: HeightSDKType;
+    signer: string;
+}
+/**
+ * MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
+ * response type.
+ */
+export interface MsgConnectionOpenConfirmResponse {
+}
+/**
+ * MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
+ * response type.
+ */
+export interface MsgConnectionOpenConfirmResponseSDKType {
+}
+export declare const MsgConnectionOpenInit: {
+    encode(message: MsgConnectionOpenInit, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenInit;
+    fromPartial(object: DeepPartial<MsgConnectionOpenInit>): MsgConnectionOpenInit;
+};
+export declare const MsgConnectionOpenInitResponse: {
+    encode(_: MsgConnectionOpenInitResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenInitResponseSDKType;
+    fromPartial(_: DeepPartial<MsgConnectionOpenInitResponse>): MsgConnectionOpenInitResponse;
+};
+export declare const MsgConnectionOpenTry: {
+    encode(message: MsgConnectionOpenTry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenTry;
+    fromPartial(object: DeepPartial<MsgConnectionOpenTry>): MsgConnectionOpenTry;
+};
+export declare const MsgConnectionOpenTryResponse: {
+    encode(_: MsgConnectionOpenTryResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenTryResponseSDKType;
+    fromPartial(_: DeepPartial<MsgConnectionOpenTryResponse>): MsgConnectionOpenTryResponse;
+};
+export declare const MsgConnectionOpenAck: {
+    encode(message: MsgConnectionOpenAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenAck;
+    fromPartial(object: DeepPartial<MsgConnectionOpenAck>): MsgConnectionOpenAck;
+};
+export declare const MsgConnectionOpenAckResponse: {
+    encode(_: MsgConnectionOpenAckResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenAckResponseSDKType;
+    fromPartial(_: DeepPartial<MsgConnectionOpenAckResponse>): MsgConnectionOpenAckResponse;
+};
+export declare const MsgConnectionOpenConfirm: {
+    encode(message: MsgConnectionOpenConfirm, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenConfirm;
+    fromPartial(object: DeepPartial<MsgConnectionOpenConfirm>): MsgConnectionOpenConfirm;
+};
+export declare const MsgConnectionOpenConfirmResponse: {
+    encode(_: MsgConnectionOpenConfirmResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgConnectionOpenConfirmResponseSDKType;
+    fromPartial(_: DeepPartial<MsgConnectionOpenConfirmResponse>): MsgConnectionOpenConfirmResponse;
+};