@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/ibc/core/channel/v1/genesis.ts

@@ -0,0 +1,351 @@
+//@ts-nocheck
+import { IdentifiedChannel, IdentifiedChannelAmino, IdentifiedChannelSDKType, PacketState, PacketStateAmino, PacketStateSDKType } from "./channel";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** GenesisState defines the ibc channel submodule's genesis state. */
+export interface GenesisState {
+  channels: IdentifiedChannel[];
+  acknowledgements: PacketState[];
+  commitments: PacketState[];
+  receipts: PacketState[];
+  sendSequences: PacketSequence[];
+  recvSequences: PacketSequence[];
+  ackSequences: PacketSequence[];
+  /** the sequence for the next generated channel identifier */
+  nextChannelSequence: bigint;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/ibc.core.channel.v1.GenesisState";
+  value: Uint8Array;
+}
+/**
+ * GenesisState defines the ibc channel submodule's genesis state.
+ * @name GenesisStateAmino
+ * @package ibc.core.channel.v1
+ * @see proto type: ibc.core.channel.v1.GenesisState
+ */
+export interface GenesisStateAmino {
+  channels?: IdentifiedChannelAmino[];
+  acknowledgements?: PacketStateAmino[];
+  commitments?: PacketStateAmino[];
+  receipts?: PacketStateAmino[];
+  send_sequences?: PacketSequenceAmino[];
+  recv_sequences?: PacketSequenceAmino[];
+  ack_sequences?: PacketSequenceAmino[];
+  /**
+   * the sequence for the next generated channel identifier
+   */
+  next_channel_sequence?: string;
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the ibc channel submodule's genesis state. */
+export interface GenesisStateSDKType {
+  channels: IdentifiedChannelSDKType[];
+  acknowledgements: PacketStateSDKType[];
+  commitments: PacketStateSDKType[];
+  receipts: PacketStateSDKType[];
+  send_sequences: PacketSequenceSDKType[];
+  recv_sequences: PacketSequenceSDKType[];
+  ack_sequences: PacketSequenceSDKType[];
+  next_channel_sequence: bigint;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+export interface PacketSequence {
+  portId: string;
+  channelId: string;
+  sequence: bigint;
+}
+export interface PacketSequenceProtoMsg {
+  typeUrl: "/ibc.core.channel.v1.PacketSequence";
+  value: Uint8Array;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ * @name PacketSequenceAmino
+ * @package ibc.core.channel.v1
+ * @see proto type: ibc.core.channel.v1.PacketSequence
+ */
+export interface PacketSequenceAmino {
+  port_id?: string;
+  channel_id?: string;
+  sequence?: string;
+}
+export interface PacketSequenceAminoMsg {
+  type: "cosmos-sdk/PacketSequence";
+  value: PacketSequenceAmino;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store
+ * next send and receive sequences.
+ */
+export interface PacketSequenceSDKType {
+  port_id: string;
+  channel_id: string;
+  sequence: bigint;
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    channels: [],
+    acknowledgements: [],
+    commitments: [],
+    receipts: [],
+    sendSequences: [],
+    recvSequences: [],
+    ackSequences: [],
+    nextChannelSequence: BigInt(0)
+  };
+}
+export const GenesisState = {
+  typeUrl: "/ibc.core.channel.v1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.channels) {
+      IdentifiedChannel.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.acknowledgements) {
+      PacketState.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.commitments) {
+      PacketState.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.receipts) {
+      PacketState.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.sendSequences) {
+      PacketSequence.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+    for (const v of message.recvSequences) {
+      PacketSequence.encode(v!, writer.uint32(50).fork()).ldelim();
+    }
+    for (const v of message.ackSequences) {
+      PacketSequence.encode(v!, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.nextChannelSequence !== BigInt(0)) {
+      writer.uint32(64).uint64(message.nextChannelSequence);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.channels.push(IdentifiedChannel.decode(reader, reader.uint32()));
+          break;
+        case 2:
+          message.acknowledgements.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.commitments.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.receipts.push(PacketState.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.sendSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 6:
+          message.recvSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 7:
+          message.ackSequences.push(PacketSequence.decode(reader, reader.uint32()));
+          break;
+        case 8:
+          message.nextChannelSequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.channels = object.channels?.map(e => IdentifiedChannel.fromPartial(e)) || [];
+    message.acknowledgements = object.acknowledgements?.map(e => PacketState.fromPartial(e)) || [];
+    message.commitments = object.commitments?.map(e => PacketState.fromPartial(e)) || [];
+    message.receipts = object.receipts?.map(e => PacketState.fromPartial(e)) || [];
+    message.sendSequences = object.sendSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.recvSequences = object.recvSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.ackSequences = object.ackSequences?.map(e => PacketSequence.fromPartial(e)) || [];
+    message.nextChannelSequence = object.nextChannelSequence !== undefined && object.nextChannelSequence !== null ? BigInt(object.nextChannelSequence.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.channels = object.channels?.map(e => IdentifiedChannel.fromAmino(e)) || [];
+    message.acknowledgements = object.acknowledgements?.map(e => PacketState.fromAmino(e)) || [];
+    message.commitments = object.commitments?.map(e => PacketState.fromAmino(e)) || [];
+    message.receipts = object.receipts?.map(e => PacketState.fromAmino(e)) || [];
+    message.sendSequences = object.send_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    message.recvSequences = object.recv_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    message.ackSequences = object.ack_sequences?.map(e => PacketSequence.fromAmino(e)) || [];
+    if (object.next_channel_sequence !== undefined && object.next_channel_sequence !== null) {
+      message.nextChannelSequence = BigInt(object.next_channel_sequence);
+    }
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.channels) {
+      obj.channels = message.channels.map(e => e ? IdentifiedChannel.toAmino(e) : undefined);
+    } else {
+      obj.channels = message.channels;
+    }
+    if (message.acknowledgements) {
+      obj.acknowledgements = message.acknowledgements.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.acknowledgements = message.acknowledgements;
+    }
+    if (message.commitments) {
+      obj.commitments = message.commitments.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.commitments = message.commitments;
+    }
+    if (message.receipts) {
+      obj.receipts = message.receipts.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.receipts = message.receipts;
+    }
+    if (message.sendSequences) {
+      obj.send_sequences = message.sendSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.send_sequences = message.sendSequences;
+    }
+    if (message.recvSequences) {
+      obj.recv_sequences = message.recvSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.recv_sequences = message.recvSequences;
+    }
+    if (message.ackSequences) {
+      obj.ack_sequences = message.ackSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.ack_sequences = message.ackSequences;
+    }
+    obj.next_channel_sequence = message.nextChannelSequence !== BigInt(0) ? message.nextChannelSequence?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/ibc.core.channel.v1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+function createBasePacketSequence(): PacketSequence {
+  return {
+    portId: "",
+    channelId: "",
+    sequence: BigInt(0)
+  };
+}
+export const PacketSequence = {
+  typeUrl: "/ibc.core.channel.v1.PacketSequence",
+  encode(message: PacketSequence, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.portId !== "") {
+      writer.uint32(10).string(message.portId);
+    }
+    if (message.channelId !== "") {
+      writer.uint32(18).string(message.channelId);
+    }
+    if (message.sequence !== BigInt(0)) {
+      writer.uint32(24).uint64(message.sequence);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): PacketSequence {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePacketSequence();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.portId = reader.string();
+          break;
+        case 2:
+          message.channelId = reader.string();
+          break;
+        case 3:
+          message.sequence = reader.uint64();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<PacketSequence>): PacketSequence {
+    const message = createBasePacketSequence();
+    message.portId = object.portId ?? "";
+    message.channelId = object.channelId ?? "";
+    message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+    return message;
+  },
+  fromAmino(object: PacketSequenceAmino): PacketSequence {
+    const message = createBasePacketSequence();
+    if (object.port_id !== undefined && object.port_id !== null) {
+      message.portId = object.port_id;
+    }
+    if (object.channel_id !== undefined && object.channel_id !== null) {
+      message.channelId = object.channel_id;
+    }
+    if (object.sequence !== undefined && object.sequence !== null) {
+      message.sequence = BigInt(object.sequence);
+    }
+    return message;
+  },
+  toAmino(message: PacketSequence): PacketSequenceAmino {
+    const obj: any = {};
+    obj.port_id = message.portId === "" ? undefined : message.portId;
+    obj.channel_id = message.channelId === "" ? undefined : message.channelId;
+    obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: PacketSequenceAminoMsg): PacketSequence {
+    return PacketSequence.fromAmino(object.value);
+  },
+  toAminoMsg(message: PacketSequence): PacketSequenceAminoMsg {
+    return {
+      type: "cosmos-sdk/PacketSequence",
+      value: PacketSequence.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: PacketSequenceProtoMsg): PacketSequence {
+    return PacketSequence.decode(message.value);
+  },
+  toProto(message: PacketSequence): Uint8Array {
+    return PacketSequence.encode(message).finish();
+  },
+  toProtoMsg(message: PacketSequence): PacketSequenceProtoMsg {
+    return {
+      typeUrl: "/ibc.core.channel.v1.PacketSequence",
+      value: PacketSequence.encode(message).finish()
+    };
+  }
+};

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

@@ -0,0 +1,135 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../../helpers";
+import { LCDClient } from "@cosmology/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, QueryNextSequenceSendRequest, QueryNextSequenceSendResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.channel = this.channel.bind(this);
+    this.channels = this.channels.bind(this);
+    this.connectionChannels = this.connectionChannels.bind(this);
+    this.channelClientState = this.channelClientState.bind(this);
+    this.channelConsensusState = this.channelConsensusState.bind(this);
+    this.packetCommitment = this.packetCommitment.bind(this);
+    this.packetCommitments = this.packetCommitments.bind(this);
+    this.packetReceipt = this.packetReceipt.bind(this);
+    this.packetAcknowledgement = this.packetAcknowledgement.bind(this);
+    this.packetAcknowledgements = this.packetAcknowledgements.bind(this);
+    this.unreceivedPackets = this.unreceivedPackets.bind(this);
+    this.unreceivedAcks = this.unreceivedAcks.bind(this);
+    this.nextSequenceReceive = this.nextSequenceReceive.bind(this);
+    this.nextSequenceSend = this.nextSequenceSend.bind(this);
+  }
+  /* Channel queries an IBC Channel. */
+  async channel(params: QueryChannelRequest): Promise<QueryChannelResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}`;
+    return await this.req.get<QueryChannelResponseSDKType>(endpoint);
+  }
+  /* Channels queries all the IBC channels of a chain. */
+  async channels(params: QueryChannelsRequest = {
+    pagination: undefined
+  }): Promise<QueryChannelsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/channels`;
+    return await this.req.get<QueryChannelsResponseSDKType>(endpoint, options);
+  }
+  /* ConnectionChannels queries all the channels associated with a connection
+   end. */
+  async connectionChannels(params: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/connections/${params.connection}/channels`;
+    return await this.req.get<QueryConnectionChannelsResponseSDKType>(endpoint, options);
+  }
+  /* ChannelClientState queries for the client state for the channel associated
+   with the provided channel identifiers. */
+  async channelClientState(params: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/client_state`;
+    return await this.req.get<QueryChannelClientStateResponseSDKType>(endpoint);
+  }
+  /* ChannelConsensusState queries for the consensus state for the channel
+   associated with the provided channel identifiers. */
+  async channelConsensusState(params: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/consensus_state/revision/${params.revisionNumber}/height/${params.revisionHeight}`;
+    return await this.req.get<QueryChannelConsensusStateResponseSDKType>(endpoint);
+  }
+  /* PacketCommitment queries a stored packet commitment hash. */
+  async packetCommitment(params: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.sequence}`;
+    return await this.req.get<QueryPacketCommitmentResponseSDKType>(endpoint);
+  }
+  /* PacketCommitments returns all the packet commitments hashes associated
+   with a channel. */
+  async packetCommitments(params: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments`;
+    return await this.req.get<QueryPacketCommitmentsResponseSDKType>(endpoint, options);
+  }
+  /* PacketReceipt queries if a given packet sequence has been received on the
+   queried chain */
+  async packetReceipt(params: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_receipts/${params.sequence}`;
+    return await this.req.get<QueryPacketReceiptResponseSDKType>(endpoint);
+  }
+  /* PacketAcknowledgement queries a stored packet acknowledgement hash. */
+  async packetAcknowledgement(params: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_acks/${params.sequence}`;
+    return await this.req.get<QueryPacketAcknowledgementResponseSDKType>(endpoint);
+  }
+  /* PacketAcknowledgements returns all the packet acknowledgements associated
+   with a channel. */
+  async packetAcknowledgements(params: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.packetCommitmentSequences !== "undefined") {
+      options.params.packet_commitment_sequences = params.packetCommitmentSequences;
+    }
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_acknowledgements`;
+    return await this.req.get<QueryPacketAcknowledgementsResponseSDKType>(endpoint, options);
+  }
+  /* UnreceivedPackets returns all the unreceived IBC packets associated with a
+   channel and sequences. */
+  async unreceivedPackets(params: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetCommitmentSequences}/unreceived_packets`;
+    return await this.req.get<QueryUnreceivedPacketsResponseSDKType>(endpoint);
+  }
+  /* UnreceivedAcks returns all the unreceived IBC acknowledgements associated
+   with a channel and sequences. */
+  async unreceivedAcks(params: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/packet_commitments/${params.packetAckSequences}/unreceived_acks`;
+    return await this.req.get<QueryUnreceivedAcksResponseSDKType>(endpoint);
+  }
+  /* NextSequenceReceive returns the next receive sequence for a given channel. */
+  async nextSequenceReceive(params: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/next_sequence`;
+    return await this.req.get<QueryNextSequenceReceiveResponseSDKType>(endpoint);
+  }
+  /* NextSequenceSend returns the next send sequence for a given channel. */
+  async nextSequenceSend(params: QueryNextSequenceSendRequest): Promise<QueryNextSequenceSendResponseSDKType> {
+    const endpoint = `ibc/core/channel/v1/channels/${params.channelId}/ports/${params.portId}/next_sequence_send`;
+    return await this.req.get<QueryNextSequenceSendResponseSDKType>(endpoint);
+  }
+}