juno-network 0.15.0 → 0.17.0

package/src/codegen/ibc/core/channel/v1/genesis.ts

@@ -1,8 +1,6 @@
-import { IdentifiedChannel, IdentifiedChannelSDKType, PacketState, PacketStateSDKType } from "./channel";
-import * as _m0 from "protobufjs/minimal";
-import { Long, DeepPartial } from "../../../../helpers";
+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[];
@@ -12,11 +10,29 @@ export interface GenesisState {
   recvSequences: PacketSequence[];
   ackSequences: PacketSequence[];
   /** the sequence for the next generated channel identifier */
-
-  nextChannelSequence: Long;
+  nextChannelSequence: bigint;
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/ibc.core.channel.v1.GenesisState";
+  value: Uint8Array;
+}
+/** GenesisState defines the ibc channel submodule's genesis state. */
+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[];
@@ -25,31 +41,43 @@ export interface GenesisStateSDKType {
   send_sequences: PacketSequenceSDKType[];
   recv_sequences: PacketSequenceSDKType[];
   ack_sequences: PacketSequenceSDKType[];
-  /** the sequence for the next generated channel identifier */
-
-  next_channel_sequence: Long;
+  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: Long;
+  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.
+ */
+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: Long;
+  sequence: bigint;
 }
-
 function createBaseGenesisState(): GenesisState {
   return {
     channels: [],
@@ -59,98 +87,77 @@ function createBaseGenesisState(): GenesisState {
     sendSequences: [],
     recvSequences: [],
     ackSequences: [],
-    nextChannelSequence: Long.UZERO
+    nextChannelSequence: BigInt(0)
   };
 }
-
 export const GenesisState = {
-  encode(message: GenesisState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  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.isZero()) {
+    if (message.nextChannelSequence !== BigInt(0)) {
       writer.uint32(64).uint64(message.nextChannelSequence);
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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() as Long);
+          message.nextChannelSequence = reader.uint64();
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<GenesisState>): GenesisState {
+  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)) || [];
@@ -159,73 +166,175 @@ export const GenesisState = {
     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 ? Long.fromValue(object.nextChannelSequence) : Long.UZERO;
+    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 = [];
+    }
+    if (message.acknowledgements) {
+      obj.acknowledgements = message.acknowledgements.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.acknowledgements = [];
+    }
+    if (message.commitments) {
+      obj.commitments = message.commitments.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.commitments = [];
+    }
+    if (message.receipts) {
+      obj.receipts = message.receipts.map(e => e ? PacketState.toAmino(e) : undefined);
+    } else {
+      obj.receipts = [];
+    }
+    if (message.sendSequences) {
+      obj.send_sequences = message.sendSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.send_sequences = [];
+    }
+    if (message.recvSequences) {
+      obj.recv_sequences = message.recvSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.recv_sequences = [];
+    }
+    if (message.ackSequences) {
+      obj.ack_sequences = message.ackSequences.map(e => e ? PacketSequence.toAmino(e) : undefined);
+    } else {
+      obj.ack_sequences = [];
+    }
+    obj.next_channel_sequence = message.nextChannelSequence ? 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: Long.UZERO
+    sequence: BigInt(0)
   };
 }
-
 export const PacketSequence = {
-  encode(message: PacketSequence, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  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.isZero()) {
+    if (message.sequence !== BigInt(0)) {
       writer.uint32(24).uint64(message.sequence);
     }
-
     return writer;
   },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): PacketSequence {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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() as Long);
+          message.sequence = reader.uint64();
           break;
-
         default:
           reader.skipType(tag & 7);
           break;
       }
     }
-
     return message;
   },
-
-  fromPartial(object: DeepPartial<PacketSequence>): PacketSequence {
+  fromPartial(object: Partial<PacketSequence>): PacketSequence {
     const message = createBasePacketSequence();
     message.portId = object.portId ?? "";
     message.channelId = object.channelId ?? "";
-    message.sequence = object.sequence !== undefined && object.sequence !== null ? Long.fromValue(object.sequence) : Long.UZERO;
+    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;
+    obj.channel_id = message.channelId;
+    obj.sequence = message.sequence ? 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/src/codegen/ibc/core/channel/v1/query.lcd.ts

@@ -1,9 +1,8 @@
 import { setPaginationParams } from "../../../../helpers";
-import { LCDClient } from "@osmonauts/lcd";
+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 } from "./query";
 export class LCDQueryClient {
   req: LCDClient;
-
   constructor({
     requestClient
   }: {
@@ -25,141 +24,105 @@ export class LCDQueryClient {
     this.nextSequenceReceive = this.nextSequenceReceive.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);
   }
-
 }