interchainjs/ibc/core/channel/v2/packet.d.ts

InterchainJS is a JavaScript library for interacting with Cosmos SDK based blockchains.

import { BinaryReader, BinaryWriter } from "../../../../binary";
import { DeepPartial } from "../../../../helpers";
/** PacketStatus specifies the status of a RecvPacketResult. */
export declare enum PacketStatus {
    /** PACKET_STATUS_UNSPECIFIED - PACKET_STATUS_UNSPECIFIED indicates an unknown packet status. */
    PACKET_STATUS_UNSPECIFIED = 0,
    /** PACKET_STATUS_SUCCESS - PACKET_STATUS_SUCCESS indicates a successful packet receipt. */
    PACKET_STATUS_SUCCESS = 1,
    /** PACKET_STATUS_FAILURE - PACKET_STATUS_FAILURE indicates a failed packet receipt. */
    PACKET_STATUS_FAILURE = 2,
    /** PACKET_STATUS_ASYNC - PACKET_STATUS_ASYNC indicates an async packet receipt. */
    PACKET_STATUS_ASYNC = 3,
    UNRECOGNIZED = -1
}
export declare const PacketStatusAmino: typeof PacketStatus;
export declare function packetStatusFromJSON(object: any): PacketStatus;
export declare function packetStatusToJSON(object: PacketStatus): string;
/**
 * Packet defines a type that carries data across different chains through IBC
 * @name Packet
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Packet
 */
export interface Packet {
    /**
     * number corresponds to the order of sends and receives, where a Packet
     * with an earlier sequence number must be sent and received before a Packet
     * with a later sequence number.
     */
    sequence: bigint;
    /**
     * identifies the sending client on the sending chain.
     */
    sourceClient: string;
    /**
     * identifies the receiving client on the receiving chain.
     */
    destinationClient: string;
    /**
     * timeout timestamp in seconds after which the packet times out.
     */
    timeoutTimestamp: bigint;
    /**
     * a list of payloads, each one for a specific application.
     */
    payloads: Payload[];
}
export interface PacketProtoMsg {
    typeUrl: "/ibc.core.channel.v2.Packet";
    value: Uint8Array;
}
/**
 * Packet defines a type that carries data across different chains through IBC
 * @name PacketAmino
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Packet
 */
export interface PacketAmino {
    /**
     * number corresponds to the order of sends and receives, where a Packet
     * with an earlier sequence number must be sent and received before a Packet
     * with a later sequence number.
     */
    sequence: string;
    /**
     * identifies the sending client on the sending chain.
     */
    source_client: string;
    /**
     * identifies the receiving client on the receiving chain.
     */
    destination_client: string;
    /**
     * timeout timestamp in seconds after which the packet times out.
     */
    timeout_timestamp: string;
    /**
     * a list of payloads, each one for a specific application.
     */
    payloads: PayloadAmino[];
}
export interface PacketAminoMsg {
    type: "cosmos-sdk/Packet";
    value: PacketAmino;
}
/**
 * Payload contains the source and destination ports and payload for the application (version, encoding, raw bytes)
 * @name Payload
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Payload
 */
export interface Payload {
    /**
     * specifies the source port of the packet.
     */
    sourcePort: string;
    /**
     * specifies the destination port of the packet.
     */
    destinationPort: string;
    /**
     * version of the specified application.
     */
    version: string;
    /**
     * the encoding used for the provided value.
     */
    encoding: string;
    /**
     * the raw bytes for the payload.
     */
    value: Uint8Array;
}
export interface PayloadProtoMsg {
    typeUrl: "/ibc.core.channel.v2.Payload";
    value: Uint8Array;
}
/**
 * Payload contains the source and destination ports and payload for the application (version, encoding, raw bytes)
 * @name PayloadAmino
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Payload
 */
export interface PayloadAmino {
    /**
     * specifies the source port of the packet.
     */
    source_port: string;
    /**
     * specifies the destination port of the packet.
     */
    destination_port: string;
    /**
     * version of the specified application.
     */
    version: string;
    /**
     * the encoding used for the provided value.
     */
    encoding: string;
    /**
     * the raw bytes for the payload.
     */
    value: string;
}
export interface PayloadAminoMsg {
    type: "cosmos-sdk/Payload";
    value: PayloadAmino;
}
/**
 * Acknowledgement contains a list of all ack results associated with a single packet.
 * In the case of a successful receive, the acknowledgement will contain an app acknowledgement
 * for each application that received a payload in the same order that the payloads were sent
 * in the packet.
 * If the receive is not successful, the acknowledgement will contain a single app acknowledgment
 * which will be a constant error acknowledgment as defined by the IBC v2 protocol.
 * @name Acknowledgement
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Acknowledgement
 */
export interface Acknowledgement {
    appAcknowledgements: Uint8Array[];
}
export interface AcknowledgementProtoMsg {
    typeUrl: "/ibc.core.channel.v2.Acknowledgement";
    value: Uint8Array;
}
/**
 * Acknowledgement contains a list of all ack results associated with a single packet.
 * In the case of a successful receive, the acknowledgement will contain an app acknowledgement
 * for each application that received a payload in the same order that the payloads were sent
 * in the packet.
 * If the receive is not successful, the acknowledgement will contain a single app acknowledgment
 * which will be a constant error acknowledgment as defined by the IBC v2 protocol.
 * @name AcknowledgementAmino
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Acknowledgement
 */
export interface AcknowledgementAmino {
    app_acknowledgements: string[];
}
export interface AcknowledgementAminoMsg {
    type: "cosmos-sdk/Acknowledgement";
    value: AcknowledgementAmino;
}
/**
 * RecvPacketResult speecifies the status of a packet as well as the acknowledgement bytes.
 * @name RecvPacketResult
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.RecvPacketResult
 */
export interface RecvPacketResult {
    /**
     * status of the packet
     */
    status: PacketStatus;
    /**
     * acknowledgement of the packet
     */
    acknowledgement: Uint8Array;
}
export interface RecvPacketResultProtoMsg {
    typeUrl: "/ibc.core.channel.v2.RecvPacketResult";
    value: Uint8Array;
}
/**
 * RecvPacketResult speecifies the status of a packet as well as the acknowledgement bytes.
 * @name RecvPacketResultAmino
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.RecvPacketResult
 */
export interface RecvPacketResultAmino {
    /**
     * status of the packet
     */
    status: PacketStatus;
    /**
     * acknowledgement of the packet
     */
    acknowledgement: string;
}
export interface RecvPacketResultAminoMsg {
    type: "cosmos-sdk/RecvPacketResult";
    value: RecvPacketResultAmino;
}
/**
 * Packet defines a type that carries data across different chains through IBC
 * @name Packet
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Packet
 */
export declare const Packet: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Packet;
    isAmino(o: any): o is PacketAmino;
    encode(message: Packet, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Packet;
    fromPartial(object: DeepPartial<Packet>): Packet;
    fromAmino(object: PacketAmino): Packet;
    toAmino(message: Packet): PacketAmino;
    fromAminoMsg(object: PacketAminoMsg): Packet;
    toAminoMsg(message: Packet): PacketAminoMsg;
    fromProtoMsg(message: PacketProtoMsg): Packet;
    toProto(message: Packet): Uint8Array;
    toProtoMsg(message: Packet): PacketProtoMsg;
    registerTypeUrl(): void;
};
/**
 * Payload contains the source and destination ports and payload for the application (version, encoding, raw bytes)
 * @name Payload
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Payload
 */
export declare const Payload: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Payload;
    isAmino(o: any): o is PayloadAmino;
    encode(message: Payload, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Payload;
    fromPartial(object: DeepPartial<Payload>): Payload;
    fromAmino(object: PayloadAmino): Payload;
    toAmino(message: Payload): PayloadAmino;
    fromAminoMsg(object: PayloadAminoMsg): Payload;
    toAminoMsg(message: Payload): PayloadAminoMsg;
    fromProtoMsg(message: PayloadProtoMsg): Payload;
    toProto(message: Payload): Uint8Array;
    toProtoMsg(message: Payload): PayloadProtoMsg;
    registerTypeUrl(): void;
};
/**
 * Acknowledgement contains a list of all ack results associated with a single packet.
 * In the case of a successful receive, the acknowledgement will contain an app acknowledgement
 * for each application that received a payload in the same order that the payloads were sent
 * in the packet.
 * If the receive is not successful, the acknowledgement will contain a single app acknowledgment
 * which will be a constant error acknowledgment as defined by the IBC v2 protocol.
 * @name Acknowledgement
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.Acknowledgement
 */
export declare const Acknowledgement: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is Acknowledgement;
    isAmino(o: any): o is AcknowledgementAmino;
    encode(message: Acknowledgement, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Acknowledgement;
    fromPartial(object: DeepPartial<Acknowledgement>): Acknowledgement;
    fromAmino(object: AcknowledgementAmino): Acknowledgement;
    toAmino(message: Acknowledgement): AcknowledgementAmino;
    fromAminoMsg(object: AcknowledgementAminoMsg): Acknowledgement;
    toAminoMsg(message: Acknowledgement): AcknowledgementAminoMsg;
    fromProtoMsg(message: AcknowledgementProtoMsg): Acknowledgement;
    toProto(message: Acknowledgement): Uint8Array;
    toProtoMsg(message: Acknowledgement): AcknowledgementProtoMsg;
    registerTypeUrl(): void;
};
/**
 * RecvPacketResult speecifies the status of a packet as well as the acknowledgement bytes.
 * @name RecvPacketResult
 * @package ibc.core.channel.v2
 * @see proto type: ibc.core.channel.v2.RecvPacketResult
 */
export declare const RecvPacketResult: {
    typeUrl: string;
    aminoType: string;
    is(o: any): o is RecvPacketResult;
    isAmino(o: any): o is RecvPacketResultAmino;
    encode(message: RecvPacketResult, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RecvPacketResult;
    fromPartial(object: DeepPartial<RecvPacketResult>): RecvPacketResult;
    fromAmino(object: RecvPacketResultAmino): RecvPacketResult;
    toAmino(message: RecvPacketResult): RecvPacketResultAmino;
    fromAminoMsg(object: RecvPacketResultAminoMsg): RecvPacketResult;
    toAminoMsg(message: RecvPacketResult): RecvPacketResultAminoMsg;
    fromProtoMsg(message: RecvPacketResultProtoMsg): RecvPacketResult;
    toProto(message: RecvPacketResult): Uint8Array;
    toProtoMsg(message: RecvPacketResult): RecvPacketResultProtoMsg;
    registerTypeUrl(): void;
};