Interface IbcExtension

Type declaration

• Readonly channel: {
      allChannels: (() => Promise<QueryChannelsResponse>);
      allConnectionChannels: ((connection) => Promise<QueryConnectionChannelsResponse>);
      allPacketAcknowledgements: ((portId, channelId) => Promise<QueryPacketAcknowledgementsResponse>);
      allPacketCommitments: ((portId, channelId) => Promise<QueryPacketCommitmentsResponse>);
      channel: ((portId, channelId) => Promise<QueryChannelResponse>);
      channels: ((paginationKey?) => Promise<QueryChannelsResponse>);
      clientState: ((portId, channelId) => Promise<QueryChannelClientStateResponse>);
      connectionChannels: ((connection, paginationKey?) => Promise<QueryConnectionChannelsResponse>);
      consensusState: ((portId, channelId, revisionNumber, revisionHeight) => Promise<QueryChannelConsensusStateResponse>);
      nextSequenceReceive: ((portId, channelId) => Promise<QueryNextSequenceReceiveResponse>);
      packetAcknowledgement: ((portId, channelId, sequence) => Promise<QueryPacketAcknowledgementResponse>);
      packetAcknowledgements: ((portId, channelId, paginationKey?) => Promise<QueryPacketAcknowledgementsResponse>);
      packetCommitment: ((portId, channelId, sequence) => Promise<QueryPacketCommitmentResponse>);
      packetCommitments: ((portId, channelId, paginationKey?) => Promise<QueryPacketCommitmentsResponse>);
      packetReceipt: ((portId, channelId, sequence) => Promise<QueryPacketReceiptResponse>);
      unreceivedAcks: ((portId, channelId, packetAckSequences) => Promise<QueryUnreceivedAcksResponse>);
      unreceivedPackets: ((portId, channelId, packetCommitmentSequences) => Promise<QueryUnreceivedPacketsResponse>);
  }

  • Readonly allChannels: (() => Promise<QueryChannelsResponse>)

    • • (): Promise<QueryChannelsResponse>

      • Returns Promise<QueryChannelsResponse>

  • Readonly allConnectionChannels: ((connection) => Promise<QueryConnectionChannelsResponse>)

    • • (connection): Promise<QueryConnectionChannelsResponse>

      • Parameters

        • connection: string

        Returns Promise<QueryConnectionChannelsResponse>

  • Readonly allPacketAcknowledgements: ((portId, channelId) => Promise<QueryPacketAcknowledgementsResponse>)

    • • (portId, channelId): Promise<QueryPacketAcknowledgementsResponse>

      • Parameters

        • portId: string

        • channelId: string

        Returns Promise<QueryPacketAcknowledgementsResponse>

  • Readonly allPacketCommitments: ((portId, channelId) => Promise<QueryPacketCommitmentsResponse>)

    • • (portId, channelId): Promise<QueryPacketCommitmentsResponse>

      • Parameters

        • portId: string

        • channelId: string

        Returns Promise<QueryPacketCommitmentsResponse>

  • Readonly channel: ((portId, channelId) => Promise<QueryChannelResponse>)

    • • (portId, channelId): Promise<QueryChannelResponse>

      • Parameters

        • portId: string

        • channelId: string

        Returns Promise<QueryChannelResponse>

  • Readonly channels: ((paginationKey?) => Promise<QueryChannelsResponse>)

    • • (paginationKey?): Promise<QueryChannelsResponse>

      • Parameters

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryChannelsResponse>

  • Readonly clientState: ((portId, channelId) => Promise<QueryChannelClientStateResponse>)

    • • (portId, channelId): Promise<QueryChannelClientStateResponse>

      • Parameters

        • portId: string

        • channelId: string

        Returns Promise<QueryChannelClientStateResponse>

  • Readonly connectionChannels: ((connection, paginationKey?) => Promise<QueryConnectionChannelsResponse>)

    • • (connection, paginationKey?): Promise<QueryConnectionChannelsResponse>

      • Parameters

        • connection: string

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryConnectionChannelsResponse>

  • Readonly consensusState: ((portId, channelId, revisionNumber, revisionHeight) => Promise<QueryChannelConsensusStateResponse>)

    • • (portId, channelId, revisionNumber, revisionHeight): Promise<QueryChannelConsensusStateResponse>

      • Parameters

        • portId: string

        • channelId: string

        • revisionNumber: number

        • revisionHeight: number

        Returns Promise<QueryChannelConsensusStateResponse>

  • Readonly nextSequenceReceive: ((portId, channelId) => Promise<QueryNextSequenceReceiveResponse>)

    • • (portId, channelId): Promise<QueryNextSequenceReceiveResponse>

      • Parameters

        • portId: string

        • channelId: string

        Returns Promise<QueryNextSequenceReceiveResponse>

  • Readonly packetAcknowledgement: ((portId, channelId, sequence) => Promise<QueryPacketAcknowledgementResponse>)

    • • (portId, channelId, sequence): Promise<QueryPacketAcknowledgementResponse>

      • Parameters

        • portId: string

        • channelId: string

        • sequence: number

        Returns Promise<QueryPacketAcknowledgementResponse>

  • Readonly packetAcknowledgements: ((portId, channelId, paginationKey?) => Promise<QueryPacketAcknowledgementsResponse>)

    • • (portId, channelId, paginationKey?): Promise<QueryPacketAcknowledgementsResponse>

      • Parameters

        • portId: string

        • channelId: string

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryPacketAcknowledgementsResponse>

  • Readonly packetCommitment: ((portId, channelId, sequence) => Promise<QueryPacketCommitmentResponse>)

    • • (portId, channelId, sequence): Promise<QueryPacketCommitmentResponse>

      • Parameters

        • portId: string

        • channelId: string

        • sequence: number

        Returns Promise<QueryPacketCommitmentResponse>

  • Readonly packetCommitments: ((portId, channelId, paginationKey?) => Promise<QueryPacketCommitmentsResponse>)

    • • (portId, channelId, paginationKey?): Promise<QueryPacketCommitmentsResponse>

      • Parameters

        • portId: string

        • channelId: string

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryPacketCommitmentsResponse>

  • Readonly packetReceipt: ((portId, channelId, sequence) => Promise<QueryPacketReceiptResponse>)

    • • (portId, channelId, sequence): Promise<QueryPacketReceiptResponse>

      • Parameters

        • portId: string

        • channelId: string

        • sequence: number

        Returns Promise<QueryPacketReceiptResponse>

  • Readonly unreceivedAcks: ((portId, channelId, packetAckSequences) => Promise<QueryUnreceivedAcksResponse>)

    • • (portId, channelId, packetAckSequences): Promise<QueryUnreceivedAcksResponse>

      • Parameters

        • portId: string

        • channelId: string

        • packetAckSequences: readonly number[]

        Returns Promise<QueryUnreceivedAcksResponse>

  • Readonly unreceivedPackets: ((portId, channelId, packetCommitmentSequences) => Promise<QueryUnreceivedPacketsResponse>)

    • • (portId, channelId, packetCommitmentSequences): Promise<QueryUnreceivedPacketsResponse>

      • Parameters

        • portId: string

        • channelId: string

        • packetCommitmentSequences: readonly number[]

        Returns Promise<QueryUnreceivedPacketsResponse>

• Readonly client: {
      allConsensusStates: ((clientId) => Promise<QueryConsensusStatesResponse>);
      allStates: (() => Promise<QueryClientStatesResponse>);
      allStatesTm: (() => Promise<ClientState[]>);
      consensusState: ((clientId, height?) => Promise<QueryConsensusStateResponse>);
      consensusStateTm: ((clientId, height?) => Promise<ConsensusState>);
      consensusStates: ((clientId, paginationKey?) => Promise<QueryConsensusStatesResponse>);
      params: (() => Promise<QueryClientParamsResponse>);
      state: ((clientId) => Promise<QueryClientStateResponse>);
      stateTm: ((clientId) => Promise<ClientState>);
      states: ((paginationKey?) => Promise<QueryClientStatesResponse>);
      statesTm: ((paginationKey?) => Promise<ClientState[]>);
  }

  • Readonly allConsensusStates: ((clientId) => Promise<QueryConsensusStatesResponse>)

    • • (clientId): Promise<QueryConsensusStatesResponse>

      • Parameters

        • clientId: string

        Returns Promise<QueryConsensusStatesResponse>

  • Readonly allStates: (() => Promise<QueryClientStatesResponse>)

    • • (): Promise<QueryClientStatesResponse>

      • Returns Promise<QueryClientStatesResponse>

  • Readonly allStatesTm: (() => Promise<ClientState[]>)

    • • (): Promise<ClientState[]>

      • Returns Promise<ClientState[]>

  • Readonly consensusState: ((clientId, height?) => Promise<QueryConsensusStateResponse>)

    • • (clientId, height?): Promise<QueryConsensusStateResponse>

      • Parameters

        • clientId: string

        • Optional height: number

        Returns Promise<QueryConsensusStateResponse>

  • Readonly consensusStateTm: ((clientId, height?) => Promise<ConsensusState>)

    • • (clientId, height?): Promise<ConsensusState>

      • Parameters

        • clientId: string

        • Optional height: Height

        Returns Promise<ConsensusState>

  • Readonly consensusStates: ((clientId, paginationKey?) => Promise<QueryConsensusStatesResponse>)

    • • (clientId, paginationKey?): Promise<QueryConsensusStatesResponse>

      • Parameters

        • clientId: string

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryConsensusStatesResponse>

  • Readonly params: (() => Promise<QueryClientParamsResponse>)

    • • (): Promise<QueryClientParamsResponse>

      • Returns Promise<QueryClientParamsResponse>

  • Readonly state: ((clientId) => Promise<QueryClientStateResponse>)

    • • (clientId): Promise<QueryClientStateResponse>

      • Parameters

        • clientId: string

        Returns Promise<QueryClientStateResponse>

  • Readonly stateTm: ((clientId) => Promise<ClientState>)

    • • (clientId): Promise<ClientState>

      • Parameters

        • clientId: string

        Returns Promise<ClientState>

  • Readonly states: ((paginationKey?) => Promise<QueryClientStatesResponse>)

    • • (paginationKey?): Promise<QueryClientStatesResponse>

      • Parameters

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryClientStatesResponse>

  • Readonly statesTm: ((paginationKey?) => Promise<ClientState[]>)

    • • (paginationKey?): Promise<ClientState[]>

      • Parameters

        • Optional paginationKey: Uint8Array

        Returns Promise<ClientState[]>

• Readonly connection: {
      allConnections: (() => Promise<QueryConnectionsResponse>);
      clientConnections: ((clientId) => Promise<QueryClientConnectionsResponse>);
      clientState: ((connectionId) => Promise<QueryConnectionClientStateResponse>);
      connection: ((connectionId) => Promise<QueryConnectionResponse>);
      connections: ((paginationKey?) => Promise<QueryConnectionsResponse>);
      consensusState: ((connectionId, revisionNumber, revisionHeight) => Promise<QueryConnectionConsensusStateResponse>);
  }

  • Readonly allConnections: (() => Promise<QueryConnectionsResponse>)

    • • (): Promise<QueryConnectionsResponse>

      • Returns Promise<QueryConnectionsResponse>

  • Readonly clientConnections: ((clientId) => Promise<QueryClientConnectionsResponse>)

    • • (clientId): Promise<QueryClientConnectionsResponse>

      • Parameters

        • clientId: string

        Returns Promise<QueryClientConnectionsResponse>

  • Readonly clientState: ((connectionId) => Promise<QueryConnectionClientStateResponse>)

    • • (connectionId): Promise<QueryConnectionClientStateResponse>

      • Parameters

        • connectionId: string

        Returns Promise<QueryConnectionClientStateResponse>

  • Readonly connection: ((connectionId) => Promise<QueryConnectionResponse>)

    • • (connectionId): Promise<QueryConnectionResponse>

      • Parameters

        • connectionId: string

        Returns Promise<QueryConnectionResponse>

  • Readonly connections: ((paginationKey?) => Promise<QueryConnectionsResponse>)

    • • (paginationKey?): Promise<QueryConnectionsResponse>

      • Parameters

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryConnectionsResponse>

  • Readonly consensusState: ((connectionId, revisionNumber, revisionHeight) => Promise<QueryConnectionConsensusStateResponse>)

    • • (connectionId, revisionNumber, revisionHeight): Promise<QueryConnectionConsensusStateResponse>

      • Parameters

        • connectionId: string

        • revisionNumber: number

        • revisionHeight: number

        Returns Promise<QueryConnectionConsensusStateResponse>

• Readonly transfer: {
      allDenomTraces: (() => Promise<QueryDenomTracesResponse>);
      denomTrace: ((hash) => Promise<QueryDenomTraceResponse>);
      denomTraces: ((paginationKey?) => Promise<QueryDenomTracesResponse>);
      params: (() => Promise<QueryParamsResponse>);
  }

  • Readonly allDenomTraces: (() => Promise<QueryDenomTracesResponse>)

    • • (): Promise<QueryDenomTracesResponse>

      • Returns Promise<QueryDenomTracesResponse>

  • Readonly denomTrace: ((hash) => Promise<QueryDenomTraceResponse>)

    • • (hash): Promise<QueryDenomTraceResponse>

      • Parameters

        • hash: string

        Returns Promise<QueryDenomTraceResponse>

  • Readonly denomTraces: ((paginationKey?) => Promise<QueryDenomTracesResponse>)

    • • (paginationKey?): Promise<QueryDenomTracesResponse>

      • Parameters

        • Optional paginationKey: Uint8Array

        Returns Promise<QueryDenomTracesResponse>

  • Readonly params: (() => Promise<QueryParamsResponse>)

    • • (): Promise<QueryParamsResponse>

      • Returns Promise<QueryParamsResponse>

• Readonly verified: {
      channel: {
          channel: ((portId, channelId) => Promise<null | Channel>);
          nextSequenceReceive: ((portId, channelId) => Promise<null | number>);
          packetAcknowledgement: ((portId, channelId, sequence) => Promise<Uint8Array>);
          packetCommitment: ((portId, channelId, sequence) => Promise<Uint8Array>);
      };
  }

  • Readonly channel: {
        channel: ((portId, channelId) => Promise<null | Channel>);
        nextSequenceReceive: ((portId, channelId) => Promise<null | number>);
        packetAcknowledgement: ((portId, channelId, sequence) => Promise<Uint8Array>);
        packetCommitment: ((portId, channelId, sequence) => Promise<Uint8Array>);
    }

    • Readonly channel: ((portId, channelId) => Promise<null | Channel>)

      • • (portId, channelId): Promise<null | Channel>

        • Parameters

          • portId: string

          • channelId: string

          Returns Promise<null | Channel>

    • Readonly nextSequenceReceive: ((portId, channelId) => Promise<null | number>)

      • • (portId, channelId): Promise<null | number>

        • Parameters

          • portId: string

          • channelId: string

          Returns Promise<null | number>

    • Readonly packetAcknowledgement: ((portId, channelId, sequence) => Promise<Uint8Array>)

      • • (portId, channelId, sequence): Promise<Uint8Array>

        • Parameters

          • portId: string

          • channelId: string

          • sequence: number

          Returns Promise<Uint8Array>

    • Readonly packetCommitment: ((portId, channelId, sequence) => Promise<Uint8Array>)

      • • (portId, channelId, sequence): Promise<Uint8Array>

        • Parameters

          • portId: string

          • channelId: string

          • sequence: number

          Returns Promise<Uint8Array>