@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

package/esm/ibc/applications/rate_limiting/v1/rate_limiting.js

@@ -0,0 +1,632 @@
+//@ts-nocheck
+import { Duration } from "../../../../google/protobuf/duration";
+import { Timestamp } from "../../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../../helpers";
+/**
+ * PacketDirection defines whether the transfer packet is being sent from
+ * this chain or is being received on this chain
+ */
+export var PacketDirection;
+(function (PacketDirection) {
+    PacketDirection[PacketDirection["PACKET_SEND"] = 0] = "PACKET_SEND";
+    PacketDirection[PacketDirection["PACKET_RECV"] = 1] = "PACKET_RECV";
+    PacketDirection[PacketDirection["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(PacketDirection || (PacketDirection = {}));
+export const PacketDirectionAmino = PacketDirection;
+export function packetDirectionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "PACKET_SEND":
+            return PacketDirection.PACKET_SEND;
+        case 1:
+        case "PACKET_RECV":
+            return PacketDirection.PACKET_RECV;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return PacketDirection.UNRECOGNIZED;
+    }
+}
+export function packetDirectionToJSON(object) {
+    switch (object) {
+        case PacketDirection.PACKET_SEND:
+            return "PACKET_SEND";
+        case PacketDirection.PACKET_RECV:
+            return "PACKET_RECV";
+        case PacketDirection.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBasePath() {
+    return {
+        denom: "",
+        channelOrClientId: ""
+    };
+}
+/**
+ * Path holds the denom and channelID that define the rate limited route
+ * @name Path
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Path
+ */
+export const Path = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Path",
+    aminoType: "cosmos-sdk/Path",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.denom !== "") {
+            writer.uint32(10).string(message.denom);
+        }
+        if (message.channelOrClientId !== "") {
+            writer.uint32(18).string(message.channelOrClientId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePath();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.denom = reader.string();
+                    break;
+                case 2:
+                    message.channelOrClientId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePath();
+        message.denom = object.denom ?? "";
+        message.channelOrClientId = object.channelOrClientId ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePath();
+        if (object.denom !== undefined && object.denom !== null) {
+            message.denom = object.denom;
+        }
+        if (object.channel_or_client_id !== undefined && object.channel_or_client_id !== null) {
+            message.channelOrClientId = object.channel_or_client_id;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.denom = message.denom === "" ? undefined : message.denom;
+        obj.channel_or_client_id = message.channelOrClientId === "" ? undefined : message.channelOrClientId;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Path.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Path",
+            value: Path.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Path.decode(message.value);
+    },
+    toProto(message) {
+        return Path.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.Path",
+            value: Path.encode(message).finish()
+        };
+    }
+};
+function createBaseQuota() {
+    return {
+        maxPercentSend: "",
+        maxPercentRecv: "",
+        durationHours: BigInt(0)
+    };
+}
+/**
+ * Quota defines the rate limit thresholds for transfer packets
+ * @name Quota
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Quota
+ */
+export const Quota = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Quota",
+    aminoType: "cosmos-sdk/Quota",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.maxPercentSend !== "") {
+            writer.uint32(10).string(message.maxPercentSend);
+        }
+        if (message.maxPercentRecv !== "") {
+            writer.uint32(18).string(message.maxPercentRecv);
+        }
+        if (message.durationHours !== BigInt(0)) {
+            writer.uint32(24).uint64(message.durationHours);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuota();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.maxPercentSend = reader.string();
+                    break;
+                case 2:
+                    message.maxPercentRecv = reader.string();
+                    break;
+                case 3:
+                    message.durationHours = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuota();
+        message.maxPercentSend = object.maxPercentSend ?? "";
+        message.maxPercentRecv = object.maxPercentRecv ?? "";
+        message.durationHours = object.durationHours !== undefined && object.durationHours !== null ? BigInt(object.durationHours.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuota();
+        if (object.max_percent_send !== undefined && object.max_percent_send !== null) {
+            message.maxPercentSend = object.max_percent_send;
+        }
+        if (object.max_percent_recv !== undefined && object.max_percent_recv !== null) {
+            message.maxPercentRecv = object.max_percent_recv;
+        }
+        if (object.duration_hours !== undefined && object.duration_hours !== null) {
+            message.durationHours = BigInt(object.duration_hours);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.max_percent_send = message.maxPercentSend === "" ? undefined : message.maxPercentSend;
+        obj.max_percent_recv = message.maxPercentRecv === "" ? undefined : message.maxPercentRecv;
+        obj.duration_hours = message.durationHours !== BigInt(0) ? message.durationHours?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Quota.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Quota",
+            value: Quota.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Quota.decode(message.value);
+    },
+    toProto(message) {
+        return Quota.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.Quota",
+            value: Quota.encode(message).finish()
+        };
+    }
+};
+function createBaseFlow() {
+    return {
+        inflow: "",
+        outflow: "",
+        channelValue: ""
+    };
+}
+/**
+ * Flow tracks all the inflows and outflows of a channel.
+ * @name Flow
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Flow
+ */
+export const Flow = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Flow",
+    aminoType: "cosmos-sdk/Flow",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.inflow !== "") {
+            writer.uint32(10).string(message.inflow);
+        }
+        if (message.outflow !== "") {
+            writer.uint32(18).string(message.outflow);
+        }
+        if (message.channelValue !== "") {
+            writer.uint32(26).string(message.channelValue);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFlow();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.inflow = reader.string();
+                    break;
+                case 2:
+                    message.outflow = reader.string();
+                    break;
+                case 3:
+                    message.channelValue = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseFlow();
+        message.inflow = object.inflow ?? "";
+        message.outflow = object.outflow ?? "";
+        message.channelValue = object.channelValue ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseFlow();
+        if (object.inflow !== undefined && object.inflow !== null) {
+            message.inflow = object.inflow;
+        }
+        if (object.outflow !== undefined && object.outflow !== null) {
+            message.outflow = object.outflow;
+        }
+        if (object.channel_value !== undefined && object.channel_value !== null) {
+            message.channelValue = object.channel_value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.inflow = message.inflow === "" ? undefined : message.inflow;
+        obj.outflow = message.outflow === "" ? undefined : message.outflow;
+        obj.channel_value = message.channelValue === "" ? undefined : message.channelValue;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Flow.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Flow",
+            value: Flow.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Flow.decode(message.value);
+    },
+    toProto(message) {
+        return Flow.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.Flow",
+            value: Flow.encode(message).finish()
+        };
+    }
+};
+function createBaseRateLimit() {
+    return {
+        path: undefined,
+        quota: undefined,
+        flow: undefined
+    };
+}
+/**
+ * RateLimit stores all the context about a given rate limit, including
+ * the relevant denom and channel, rate limit thresholds, and current
+ * progress towards the limits
+ * @name RateLimit
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.RateLimit
+ */
+export const RateLimit = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.RateLimit",
+    aminoType: "cosmos-sdk/RateLimit",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.path !== undefined) {
+            Path.encode(message.path, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.quota !== undefined) {
+            Quota.encode(message.quota, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.flow !== undefined) {
+            Flow.encode(message.flow, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRateLimit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.path = Path.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.quota = Quota.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.flow = Flow.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRateLimit();
+        message.path = object.path !== undefined && object.path !== null ? Path.fromPartial(object.path) : undefined;
+        message.quota = object.quota !== undefined && object.quota !== null ? Quota.fromPartial(object.quota) : undefined;
+        message.flow = object.flow !== undefined && object.flow !== null ? Flow.fromPartial(object.flow) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRateLimit();
+        if (object.path !== undefined && object.path !== null) {
+            message.path = Path.fromAmino(object.path);
+        }
+        if (object.quota !== undefined && object.quota !== null) {
+            message.quota = Quota.fromAmino(object.quota);
+        }
+        if (object.flow !== undefined && object.flow !== null) {
+            message.flow = Flow.fromAmino(object.flow);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.path = message.path ? Path.toAmino(message.path) : undefined;
+        obj.quota = message.quota ? Quota.toAmino(message.quota) : undefined;
+        obj.flow = message.flow ? Flow.toAmino(message.flow) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RateLimit.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/RateLimit",
+            value: RateLimit.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return RateLimit.decode(message.value);
+    },
+    toProto(message) {
+        return RateLimit.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.RateLimit",
+            value: RateLimit.encode(message).finish()
+        };
+    }
+};
+function createBaseWhitelistedAddressPair() {
+    return {
+        sender: "",
+        receiver: ""
+    };
+}
+/**
+ * WhitelistedAddressPair represents a sender-receiver combo that is
+ * not subject to rate limit restrictions
+ * @name WhitelistedAddressPair
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.WhitelistedAddressPair
+ */
+export const WhitelistedAddressPair = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.WhitelistedAddressPair",
+    aminoType: "cosmos-sdk/WhitelistedAddressPair",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.receiver !== "") {
+            writer.uint32(18).string(message.receiver);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWhitelistedAddressPair();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.receiver = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseWhitelistedAddressPair();
+        message.sender = object.sender ?? "";
+        message.receiver = object.receiver ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseWhitelistedAddressPair();
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.receiver !== undefined && object.receiver !== null) {
+            message.receiver = object.receiver;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.receiver = message.receiver === "" ? undefined : message.receiver;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return WhitelistedAddressPair.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/WhitelistedAddressPair",
+            value: WhitelistedAddressPair.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return WhitelistedAddressPair.decode(message.value);
+    },
+    toProto(message) {
+        return WhitelistedAddressPair.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.WhitelistedAddressPair",
+            value: WhitelistedAddressPair.encode(message).finish()
+        };
+    }
+};
+function createBaseHourEpoch() {
+    return {
+        epochNumber: BigInt(0),
+        duration: Duration.fromPartial({}),
+        epochStartTime: new Date(),
+        epochStartHeight: BigInt(0)
+    };
+}
+/**
+ * HourEpoch is the epoch type.
+ * @name HourEpoch
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.HourEpoch
+ */
+export const HourEpoch = {
+    typeUrl: "/ibc.applications.rate_limiting.v1.HourEpoch",
+    aminoType: "cosmos-sdk/HourEpoch",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epochNumber !== BigInt(0)) {
+            writer.uint32(8).uint64(message.epochNumber);
+        }
+        if (message.duration !== undefined) {
+            Duration.encode(message.duration, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.epochStartTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.epochStartTime), writer.uint32(26).fork()).ldelim();
+        }
+        if (message.epochStartHeight !== BigInt(0)) {
+            writer.uint32(32).int64(message.epochStartHeight);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHourEpoch();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epochNumber = reader.uint64();
+                    break;
+                case 2:
+                    message.duration = Duration.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.epochStartTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.epochStartHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseHourEpoch();
+        message.epochNumber = object.epochNumber !== undefined && object.epochNumber !== null ? BigInt(object.epochNumber.toString()) : BigInt(0);
+        message.duration = object.duration !== undefined && object.duration !== null ? Duration.fromPartial(object.duration) : undefined;
+        message.epochStartTime = object.epochStartTime ?? undefined;
+        message.epochStartHeight = object.epochStartHeight !== undefined && object.epochStartHeight !== null ? BigInt(object.epochStartHeight.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseHourEpoch();
+        if (object.epoch_number !== undefined && object.epoch_number !== null) {
+            message.epochNumber = BigInt(object.epoch_number);
+        }
+        if (object.duration !== undefined && object.duration !== null) {
+            message.duration = Duration.fromAmino(object.duration);
+        }
+        if (object.epoch_start_time !== undefined && object.epoch_start_time !== null) {
+            message.epochStartTime = fromTimestamp(Timestamp.fromAmino(object.epoch_start_time));
+        }
+        if (object.epoch_start_height !== undefined && object.epoch_start_height !== null) {
+            message.epochStartHeight = BigInt(object.epoch_start_height);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch_number = message.epochNumber !== BigInt(0) ? message.epochNumber?.toString() : undefined;
+        obj.duration = message.duration ? Duration.toAmino(message.duration) : undefined;
+        obj.epoch_start_time = message.epochStartTime ? Timestamp.toAmino(toTimestamp(message.epochStartTime)) : undefined;
+        obj.epoch_start_height = message.epochStartHeight !== BigInt(0) ? message.epochStartHeight?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return HourEpoch.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/HourEpoch",
+            value: HourEpoch.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return HourEpoch.decode(message.value);
+    },
+    toProto(message) {
+        return HourEpoch.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.rate_limiting.v1.HourEpoch",
+            value: HourEpoch.encode(message).finish()
+        };
+    }
+};

package/esm/ibc/applications/rate_limiting/v1/tx.amino.js

@@ -0,0 +1,24 @@
+//@ts-nocheck
+import { MsgAddRateLimit, MsgUpdateRateLimit, MsgRemoveRateLimit, MsgResetRateLimit } from "./tx";
+export const AminoConverter = {
+    "/ibc.applications.rate_limiting.v1.MsgAddRateLimit": {
+        aminoType: "ratelimit/MsgAddRateLimit",
+        toAmino: MsgAddRateLimit.toAmino,
+        fromAmino: MsgAddRateLimit.fromAmino
+    },
+    "/ibc.applications.rate_limiting.v1.MsgUpdateRateLimit": {
+        aminoType: "ratelimit/MsgUpdateRateLimit",
+        toAmino: MsgUpdateRateLimit.toAmino,
+        fromAmino: MsgUpdateRateLimit.fromAmino
+    },
+    "/ibc.applications.rate_limiting.v1.MsgRemoveRateLimit": {
+        aminoType: "ratelimit/MsgRemoveRateLimit",
+        toAmino: MsgRemoveRateLimit.toAmino,
+        fromAmino: MsgRemoveRateLimit.fromAmino
+    },
+    "/ibc.applications.rate_limiting.v1.MsgResetRateLimit": {
+        aminoType: "ratelimit/MsgResetRateLimit",
+        toAmino: MsgResetRateLimit.toAmino,
+        fromAmino: MsgResetRateLimit.fromAmino
+    }
+};