@xpla/xpla-react 1.7.0 → 1.8.0-rc.0

package/ibc/core/channel/v2/genesis.d.ts

@@ -0,0 +1,202 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * GenesisState defines the ibc channel/v2 submodule's genesis state.
+ * @name GenesisState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.GenesisState
+ */
+export interface GenesisState {
+    acknowledgements: PacketState[];
+    commitments: PacketState[];
+    receipts: PacketState[];
+    asyncPackets: PacketState[];
+    sendSequences: PacketSequence[];
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/ibc.core.channel.v2.GenesisState";
+    value: Uint8Array;
+}
+/**
+ * GenesisState defines the ibc channel/v2 submodule's genesis state.
+ * @name GenesisStateAmino
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.GenesisState
+ */
+export interface GenesisStateAmino {
+    acknowledgements: PacketStateAmino[];
+    commitments: PacketStateAmino[];
+    receipts: PacketStateAmino[];
+    async_packets: PacketStateAmino[];
+    send_sequences: PacketSequenceAmino[];
+}
+export interface GenesisStateAminoMsg {
+    type: "cosmos-sdk/GenesisState";
+    value: GenesisStateAmino;
+}
+/**
+ * PacketState defines the generic type necessary to retrieve and store
+ * packet commitments, acknowledgements, and receipts.
+ * Caller is responsible for knowing the context necessary to interpret this
+ * state as a commitment, acknowledgement, or a receipt.
+ * @name PacketState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketState
+ */
+export interface PacketState {
+    /**
+     * client unique identifier.
+     */
+    clientId: string;
+    /**
+     * packet sequence.
+     */
+    sequence: bigint;
+    /**
+     * embedded data that represents packet state.
+     */
+    data: Uint8Array;
+}
+export interface PacketStateProtoMsg {
+    typeUrl: "/ibc.core.channel.v2.PacketState";
+    value: Uint8Array;
+}
+/**
+ * PacketState defines the generic type necessary to retrieve and store
+ * packet commitments, acknowledgements, and receipts.
+ * Caller is responsible for knowing the context necessary to interpret this
+ * state as a commitment, acknowledgement, or a receipt.
+ * @name PacketStateAmino
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketState
+ */
+export interface PacketStateAmino {
+    /**
+     * client unique identifier.
+     */
+    client_id: string;
+    /**
+     * packet sequence.
+     */
+    sequence: string;
+    /**
+     * embedded data that represents packet state.
+     */
+    data: string;
+}
+export interface PacketStateAminoMsg {
+    type: "cosmos-sdk/PacketState";
+    value: PacketStateAmino;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store next send sequences.
+ * @name PacketSequence
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketSequence
+ */
+export interface PacketSequence {
+    /**
+     * client unique identifier.
+     */
+    clientId: string;
+    /**
+     * packet sequence
+     */
+    sequence: bigint;
+}
+export interface PacketSequenceProtoMsg {
+    typeUrl: "/ibc.core.channel.v2.PacketSequence";
+    value: Uint8Array;
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store next send sequences.
+ * @name PacketSequenceAmino
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketSequence
+ */
+export interface PacketSequenceAmino {
+    /**
+     * client unique identifier.
+     */
+    client_id: string;
+    /**
+     * packet sequence
+     */
+    sequence: string;
+}
+export interface PacketSequenceAminoMsg {
+    type: "cosmos-sdk/PacketSequence";
+    value: PacketSequenceAmino;
+}
+/**
+ * GenesisState defines the ibc channel/v2 submodule's genesis state.
+ * @name GenesisState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.GenesisState
+ */
+export declare const GenesisState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * PacketState defines the generic type necessary to retrieve and store
+ * packet commitments, acknowledgements, and receipts.
+ * Caller is responsible for knowing the context necessary to interpret this
+ * state as a commitment, acknowledgement, or a receipt.
+ * @name PacketState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketState
+ */
+export declare const PacketState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is PacketState;
+    isAmino(o: any): o is PacketStateAmino;
+    encode(message: PacketState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PacketState;
+    fromPartial(object: DeepPartial<PacketState>): PacketState;
+    fromAmino(object: PacketStateAmino): PacketState;
+    toAmino(message: PacketState): PacketStateAmino;
+    fromAminoMsg(object: PacketStateAminoMsg): PacketState;
+    toAminoMsg(message: PacketState): PacketStateAminoMsg;
+    fromProtoMsg(message: PacketStateProtoMsg): PacketState;
+    toProto(message: PacketState): Uint8Array;
+    toProtoMsg(message: PacketState): PacketStateProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store next send sequences.
+ * @name PacketSequence
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketSequence
+ */
+export declare const PacketSequence: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is PacketSequence;
+    isAmino(o: any): o is PacketSequenceAmino;
+    encode(message: PacketSequence, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PacketSequence;
+    fromPartial(object: DeepPartial<PacketSequence>): PacketSequence;
+    fromAmino(object: PacketSequenceAmino): PacketSequence;
+    toAmino(message: PacketSequence): PacketSequenceAmino;
+    fromAminoMsg(object: PacketSequenceAminoMsg): PacketSequence;
+    toAminoMsg(message: PacketSequence): PacketSequenceAminoMsg;
+    fromProtoMsg(message: PacketSequenceProtoMsg): PacketSequence;
+    toProto(message: PacketSequence): Uint8Array;
+    toProtoMsg(message: PacketSequence): PacketSequenceProtoMsg;
+    registerTypeUrl(): void;
+};

package/ibc/core/channel/v2/genesis.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketSequence = exports.PacketState = exports.GenesisState = void 0;
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+const registry_1 = require("../../../../registry");
+function createBaseGenesisState() {
+    return {
+        acknowledgements: [],
+        commitments: [],
+        receipts: [],
+        asyncPackets: [],
+        sendSequences: []
+    };
+}
+/**
+ * GenesisState defines the ibc channel/v2 submodule's genesis state.
+ * @name GenesisState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.GenesisState
+ */
+exports.GenesisState = {
+    typeUrl: "/ibc.core.channel.v2.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.acknowledgements) && (!o.acknowledgements.length || exports.PacketState.is(o.acknowledgements[0])) && Array.isArray(o.commitments) && (!o.commitments.length || exports.PacketState.is(o.commitments[0])) && Array.isArray(o.receipts) && (!o.receipts.length || exports.PacketState.is(o.receipts[0])) && Array.isArray(o.asyncPackets) && (!o.asyncPackets.length || exports.PacketState.is(o.asyncPackets[0])) && Array.isArray(o.sendSequences) && (!o.sendSequences.length || exports.PacketSequence.is(o.sendSequences[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.acknowledgements) && (!o.acknowledgements.length || exports.PacketState.isAmino(o.acknowledgements[0])) && Array.isArray(o.commitments) && (!o.commitments.length || exports.PacketState.isAmino(o.commitments[0])) && Array.isArray(o.receipts) && (!o.receipts.length || exports.PacketState.isAmino(o.receipts[0])) && Array.isArray(o.async_packets) && (!o.async_packets.length || exports.PacketState.isAmino(o.async_packets[0])) && Array.isArray(o.send_sequences) && (!o.send_sequences.length || exports.PacketSequence.isAmino(o.send_sequences[0])));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.acknowledgements) {
+            exports.PacketState.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.commitments) {
+            exports.PacketState.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.receipts) {
+            exports.PacketState.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.asyncPackets) {
+            exports.PacketState.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.sendSequences) {
+            exports.PacketSequence.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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 2:
+                    message.acknowledgements.push(exports.PacketState.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.commitments.push(exports.PacketState.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.receipts.push(exports.PacketState.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.asyncPackets.push(exports.PacketState.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.sendSequences.push(exports.PacketSequence.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.acknowledgements = object.acknowledgements?.map(e => exports.PacketState.fromPartial(e)) || [];
+        message.commitments = object.commitments?.map(e => exports.PacketState.fromPartial(e)) || [];
+        message.receipts = object.receipts?.map(e => exports.PacketState.fromPartial(e)) || [];
+        message.asyncPackets = object.asyncPackets?.map(e => exports.PacketState.fromPartial(e)) || [];
+        message.sendSequences = object.sendSequences?.map(e => exports.PacketSequence.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.acknowledgements = object.acknowledgements?.map(e => exports.PacketState.fromAmino(e)) || [];
+        message.commitments = object.commitments?.map(e => exports.PacketState.fromAmino(e)) || [];
+        message.receipts = object.receipts?.map(e => exports.PacketState.fromAmino(e)) || [];
+        message.asyncPackets = object.async_packets?.map(e => exports.PacketState.fromAmino(e)) || [];
+        message.sendSequences = object.send_sequences?.map(e => exports.PacketSequence.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.acknowledgements) {
+            obj.acknowledgements = message.acknowledgements.map(e => e ? exports.PacketState.toAmino(e) : undefined);
+        }
+        else {
+            obj.acknowledgements = message.acknowledgements;
+        }
+        if (message.commitments) {
+            obj.commitments = message.commitments.map(e => e ? exports.PacketState.toAmino(e) : undefined);
+        }
+        else {
+            obj.commitments = message.commitments;
+        }
+        if (message.receipts) {
+            obj.receipts = message.receipts.map(e => e ? exports.PacketState.toAmino(e) : undefined);
+        }
+        else {
+            obj.receipts = message.receipts;
+        }
+        if (message.asyncPackets) {
+            obj.async_packets = message.asyncPackets.map(e => e ? exports.PacketState.toAmino(e) : undefined);
+        }
+        else {
+            obj.async_packets = message.asyncPackets;
+        }
+        if (message.sendSequences) {
+            obj.send_sequences = message.sendSequences.map(e => e ? exports.PacketSequence.toAmino(e) : undefined);
+        }
+        else {
+            obj.send_sequences = message.sendSequences;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: exports.GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v2.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.GenesisState.typeUrl)) {
+            return;
+        }
+        exports.PacketState.registerTypeUrl();
+        exports.PacketSequence.registerTypeUrl();
+    }
+};
+function createBasePacketState() {
+    return {
+        clientId: "",
+        sequence: BigInt(0),
+        data: new Uint8Array()
+    };
+}
+/**
+ * PacketState defines the generic type necessary to retrieve and store
+ * packet commitments, acknowledgements, and receipts.
+ * Caller is responsible for knowing the context necessary to interpret this
+ * state as a commitment, acknowledgement, or a receipt.
+ * @name PacketState
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketState
+ */
+exports.PacketState = {
+    typeUrl: "/ibc.core.channel.v2.PacketState",
+    aminoType: "cosmos-sdk/PacketState",
+    is(o) {
+        return o && (o.$typeUrl === exports.PacketState.typeUrl || typeof o.clientId === "string" && typeof o.sequence === "bigint" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PacketState.typeUrl || typeof o.client_id === "string" && typeof o.sequence === "bigint" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.clientId !== "") {
+            writer.uint32(10).string(message.clientId);
+        }
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(16).uint64(message.sequence);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(26).bytes(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePacketState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.clientId = reader.string();
+                    break;
+                case 2:
+                    message.sequence = reader.uint64();
+                    break;
+                case 3:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePacketState();
+        message.clientId = object.clientId ?? "";
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePacketState();
+        if (object.client_id !== undefined && object.client_id !== null) {
+            message.clientId = object.client_id;
+        }
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = (0, helpers_1.bytesFromBase64)(object.data);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.client_id = message.clientId === "" ? undefined : message.clientId;
+        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+        obj.data = message.data ? (0, helpers_1.base64FromBytes)(message.data) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PacketState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PacketState",
+            value: exports.PacketState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PacketState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PacketState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v2.PacketState",
+            value: exports.PacketState.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBasePacketSequence() {
+    return {
+        clientId: "",
+        sequence: BigInt(0)
+    };
+}
+/**
+ * PacketSequence defines the genesis type necessary to retrieve and store next send sequences.
+ * @name PacketSequence
+ * @package ibc.core.channel.v2
+ * @see proto type: ibc.core.channel.v2.PacketSequence
+ */
+exports.PacketSequence = {
+    typeUrl: "/ibc.core.channel.v2.PacketSequence",
+    aminoType: "cosmos-sdk/PacketSequence",
+    is(o) {
+        return o && (o.$typeUrl === exports.PacketSequence.typeUrl || typeof o.clientId === "string" && typeof o.sequence === "bigint");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.PacketSequence.typeUrl || typeof o.client_id === "string" && typeof o.sequence === "bigint");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.clientId !== "") {
+            writer.uint32(10).string(message.clientId);
+        }
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(16).uint64(message.sequence);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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.clientId = reader.string();
+                    break;
+                case 2:
+                    message.sequence = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePacketSequence();
+        message.clientId = object.clientId ?? "";
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePacketSequence();
+        if (object.client_id !== undefined && object.client_id !== null) {
+            message.clientId = object.client_id;
+        }
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.client_id = message.clientId === "" ? undefined : message.clientId;
+        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PacketSequence.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PacketSequence",
+            value: exports.PacketSequence.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PacketSequence.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PacketSequence.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.core.channel.v2.PacketSequence",
+            value: exports.PacketSequence.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};