juno-network 0.0.2

package/types/codegen/ibc/core/commitment/v1/commitment.d.ts

@@ -0,0 +1,64 @@
+import { CommitmentProof } from "../../../../confio/proofs";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * MerkleRoot defines a merkle root hash.
+ * In the Cosmos SDK, the AppHash of a block header becomes the root.
+ */
+export interface MerkleRoot {
+    hash: Uint8Array;
+}
+/**
+ * MerklePrefix is merkle path prefixed to the key.
+ * The constructed key from the Path and the key will be append(Path.KeyPath,
+ * append(Path.KeyPrefix, key...))
+ */
+export interface MerklePrefix {
+    keyPrefix: Uint8Array;
+}
+/**
+ * MerklePath is the path used to verify commitment proofs, which can be an
+ * arbitrary structured object (defined by a commitment type).
+ * MerklePath is represented from root-to-leaf
+ */
+export interface MerklePath {
+    keyPath: string[];
+}
+/**
+ * MerkleProof is a wrapper type over a chain of CommitmentProofs.
+ * It demonstrates membership or non-membership for an element or set of
+ * elements, verifiable in conjunction with a known commitment root. Proofs
+ * should be succinct.
+ * MerkleProofs are ordered from leaf-to-root
+ */
+export interface MerkleProof {
+    proofs: CommitmentProof[];
+}
+export declare const MerkleRoot: {
+    encode(message: MerkleRoot, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MerkleRoot;
+    fromJSON(object: any): MerkleRoot;
+    toJSON(message: MerkleRoot): unknown;
+    fromPartial(object: DeepPartial<MerkleRoot>): MerkleRoot;
+};
+export declare const MerklePrefix: {
+    encode(message: MerklePrefix, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MerklePrefix;
+    fromJSON(object: any): MerklePrefix;
+    toJSON(message: MerklePrefix): unknown;
+    fromPartial(object: DeepPartial<MerklePrefix>): MerklePrefix;
+};
+export declare const MerklePath: {
+    encode(message: MerklePath, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MerklePath;
+    fromJSON(object: any): MerklePath;
+    toJSON(message: MerklePath): unknown;
+    fromPartial(object: DeepPartial<MerklePath>): MerklePath;
+};
+export declare const MerkleProof: {
+    encode(message: MerkleProof, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MerkleProof;
+    fromJSON(object: any): MerkleProof;
+    toJSON(message: MerkleProof): unknown;
+    fromPartial(object: DeepPartial<MerkleProof>): MerkleProof;
+};

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

@@ -0,0 +1,164 @@
+import { MerklePrefix } from "../../commitment/v1/commitment";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * State defines if a connection is in one of the following states:
+ * INIT, TRYOPEN, OPEN or UNINITIALIZED.
+ */
+export declare enum State {
+    /** STATE_UNINITIALIZED_UNSPECIFIED - Default State */
+    STATE_UNINITIALIZED_UNSPECIFIED = 0,
+    /** STATE_INIT - A connection end has just started the opening handshake. */
+    STATE_INIT = 1,
+    /**
+     * STATE_TRYOPEN - A connection end has acknowledged the handshake step on the counterparty
+     * chain.
+     */
+    STATE_TRYOPEN = 2,
+    /** STATE_OPEN - A connection end has completed the handshake. */
+    STATE_OPEN = 3,
+    UNRECOGNIZED = -1
+}
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;
+/**
+ * ConnectionEnd defines a stateful object on a chain connected to another
+ * separate one.
+ * NOTE: there must only be 2 defined ConnectionEnds to establish
+ * a connection between two chains.
+ */
+export interface ConnectionEnd {
+    /** client associated with this connection. */
+    clientId: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection.
+     */
+    versions: Version[];
+    /** current state of the connection end. */
+    state: State;
+    /** counterparty chain associated with this connection. */
+    counterparty: Counterparty;
+    /**
+     * delay period that must pass before a consensus state can be used for
+     * packet-verification NOTE: delay period logic is only implemented by some
+     * clients.
+     */
+    delayPeriod: Long;
+}
+/**
+ * IdentifiedConnection defines a connection with additional connection
+ * identifier field.
+ */
+export interface IdentifiedConnection {
+    /** connection identifier. */
+    id: string;
+    /** client associated with this connection. */
+    clientId: string;
+    /**
+     * IBC version which can be utilised to determine encodings or protocols for
+     * channels or packets utilising this connection
+     */
+    versions: Version[];
+    /** current state of the connection end. */
+    state: State;
+    /** counterparty chain associated with this connection. */
+    counterparty: Counterparty;
+    /** delay period associated with this connection. */
+    delayPeriod: Long;
+}
+/** Counterparty defines the counterparty chain associated with a connection end. */
+export interface Counterparty {
+    /**
+     * identifies the client on the counterparty chain associated with a given
+     * connection.
+     */
+    clientId: string;
+    /**
+     * identifies the connection end on the counterparty chain associated with a
+     * given connection.
+     */
+    connectionId: string;
+    /** commitment merkle prefix of the counterparty chain. */
+    prefix: MerklePrefix;
+}
+/** ClientPaths define all the connection paths for a client state. */
+export interface ClientPaths {
+    /** list of connection paths */
+    paths: string[];
+}
+/** ConnectionPaths define all the connection paths for a given client state. */
+export interface ConnectionPaths {
+    /** client state unique identifier */
+    clientId: string;
+    /** list of connection paths */
+    paths: string[];
+}
+/**
+ * Version defines the versioning scheme used to negotiate the IBC verison in
+ * the connection handshake.
+ */
+export interface Version {
+    /** unique version identifier */
+    identifier: string;
+    /** list of features compatible with the specified identifier */
+    features: string[];
+}
+/** Params defines the set of Connection parameters. */
+export interface Params {
+    /**
+     * maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the
+     * largest amount of time that the chain might reasonably take to produce the next block under normal operating
+     * conditions. A safe choice is 3-5x the expected time per block.
+     */
+    maxExpectedTimePerBlock: Long;
+}
+export declare const ConnectionEnd: {
+    encode(message: ConnectionEnd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionEnd;
+    fromJSON(object: any): ConnectionEnd;
+    toJSON(message: ConnectionEnd): unknown;
+    fromPartial(object: DeepPartial<ConnectionEnd>): ConnectionEnd;
+};
+export declare const IdentifiedConnection: {
+    encode(message: IdentifiedConnection, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): IdentifiedConnection;
+    fromJSON(object: any): IdentifiedConnection;
+    toJSON(message: IdentifiedConnection): unknown;
+    fromPartial(object: DeepPartial<IdentifiedConnection>): IdentifiedConnection;
+};
+export declare const Counterparty: {
+    encode(message: Counterparty, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Counterparty;
+    fromJSON(object: any): Counterparty;
+    toJSON(message: Counterparty): unknown;
+    fromPartial(object: DeepPartial<Counterparty>): Counterparty;
+};
+export declare const ClientPaths: {
+    encode(message: ClientPaths, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ClientPaths;
+    fromJSON(object: any): ClientPaths;
+    toJSON(message: ClientPaths): unknown;
+    fromPartial(object: DeepPartial<ClientPaths>): ClientPaths;
+};
+export declare const ConnectionPaths: {
+    encode(message: ConnectionPaths, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionPaths;
+    fromJSON(object: any): ConnectionPaths;
+    toJSON(message: ConnectionPaths): unknown;
+    fromPartial(object: DeepPartial<ConnectionPaths>): ConnectionPaths;
+};
+export declare const Version: {
+    encode(message: Version, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Version;
+    fromJSON(object: any): Version;
+    toJSON(message: Version): unknown;
+    fromPartial(object: DeepPartial<Version>): Version;
+};
+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/core/connection/v1/genesis.d.ts

@@ -0,0 +1,18 @@
+import { IdentifiedConnection, ConnectionPaths, Params } from "./connection";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the ibc connection submodule's genesis state. */
+export interface GenesisState {
+    connections: IdentifiedConnection[];
+    clientConnectionPaths: ConnectionPaths[];
+    /** the sequence for the next generated connection identifier */
+    nextConnectionSequence: Long;
+    params: Params;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};

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

@@ -0,0 +1,180 @@
+import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination";
+import { ConnectionEnd, IdentifiedConnection } from "./connection";
+import { Height, IdentifiedClientState } from "../../client/v1/client";
+import { Any } 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;
+}
+/**
+ * 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;
+}
+/**
+ * QueryConnectionsRequest is the request type for the Query/Connections RPC
+ * method
+ */
+export interface QueryConnectionsRequest {
+    pagination: PageRequest;
+}
+/**
+ * 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;
+}
+/**
+ * QueryClientConnectionsRequest is the request type for the
+ * Query/ClientConnections RPC method
+ */
+export interface QueryClientConnectionsRequest {
+    /** client identifier associated with a connection */
+    clientId: 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;
+}
+/**
+ * QueryConnectionClientStateRequest is the request type for the
+ * Query/ConnectionClientState RPC method
+ */
+export interface QueryConnectionClientStateRequest {
+    /** connection identifier */
+    connectionId: 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;
+}
+/**
+ * QueryConnectionConsensusStateRequest is the request type for the
+ * Query/ConnectionConsensusState RPC method
+ */
+export interface QueryConnectionConsensusStateRequest {
+    /** connection identifier */
+    connectionId: string;
+    revisionNumber: Long;
+    revisionHeight: 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;
+}
+export declare const QueryConnectionRequest: {
+    encode(message: QueryConnectionRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionRequest;
+    fromJSON(object: any): QueryConnectionRequest;
+    toJSON(message: QueryConnectionRequest): unknown;
+    fromPartial(object: DeepPartial<QueryConnectionRequest>): QueryConnectionRequest;
+};
+export declare const QueryConnectionResponse: {
+    encode(message: QueryConnectionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionResponse;
+    fromJSON(object: any): QueryConnectionResponse;
+    toJSON(message: QueryConnectionResponse): unknown;
+    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;
+    fromJSON(object: any): QueryConnectionsRequest;
+    toJSON(message: QueryConnectionsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryConnectionsRequest>): QueryConnectionsRequest;
+};
+export declare const QueryConnectionsResponse: {
+    encode(message: QueryConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionsResponse;
+    fromJSON(object: any): QueryConnectionsResponse;
+    toJSON(message: QueryConnectionsResponse): unknown;
+    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;
+    fromJSON(object: any): QueryClientConnectionsRequest;
+    toJSON(message: QueryClientConnectionsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryClientConnectionsRequest>): QueryClientConnectionsRequest;
+};
+export declare const QueryClientConnectionsResponse: {
+    encode(message: QueryClientConnectionsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientConnectionsResponse;
+    fromJSON(object: any): QueryClientConnectionsResponse;
+    toJSON(message: QueryClientConnectionsResponse): unknown;
+    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;
+    fromJSON(object: any): QueryConnectionClientStateRequest;
+    toJSON(message: QueryConnectionClientStateRequest): unknown;
+    fromPartial(object: DeepPartial<QueryConnectionClientStateRequest>): QueryConnectionClientStateRequest;
+};
+export declare const QueryConnectionClientStateResponse: {
+    encode(message: QueryConnectionClientStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionClientStateResponse;
+    fromJSON(object: any): QueryConnectionClientStateResponse;
+    toJSON(message: QueryConnectionClientStateResponse): unknown;
+    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;
+    fromJSON(object: any): QueryConnectionConsensusStateRequest;
+    toJSON(message: QueryConnectionConsensusStateRequest): unknown;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateRequest>): QueryConnectionConsensusStateRequest;
+};
+export declare const QueryConnectionConsensusStateResponse: {
+    encode(message: QueryConnectionConsensusStateResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConnectionConsensusStateResponse;
+    fromJSON(object: any): QueryConnectionConsensusStateResponse;
+    toJSON(message: QueryConnectionConsensusStateResponse): unknown;
+    fromPartial(object: DeepPartial<QueryConnectionConsensusStateResponse>): QueryConnectionConsensusStateResponse;
+};

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

@@ -0,0 +1,12 @@
+import { LCDClient } from "@osmonauts/lcd";
+import { QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse, QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse } from "./query";
+export declare class LCDQueryClient extends LCDClient {
+    constructor({ restEndpoint }: {
+        restEndpoint: any;
+    });
+    connection(params: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    connections(params: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    clientConnections(params: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    connectionClientState(params: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    connectionConsensusState(params: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+}

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

@@ -0,0 +1,19 @@
+import { Rpc } from "@osmonauts/helpers";
+import { QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse, QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse } from "./query";
+/** Query defines the RPC service */
+export interface Query {
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    connections(request: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
+    connections(request: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
+    clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
+    connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
+    connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
+}

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;
+    };
+};