@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/sparkdream/season/v1/guild.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guild = void 0;
+const binary_1 = require("../../../binary");
+function createBaseGuild() {
+    return {
+        id: BigInt(0),
+        name: "",
+        description: "",
+        founder: "",
+        createdBlock: BigInt(0),
+        inviteOnly: false,
+        status: 0,
+        officers: [],
+        pendingInvites: []
+    };
+}
+/**
+ * Guild represents a member-created social group.
+ * @name Guild
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Guild
+ */
+exports.Guild = {
+    typeUrl: "/sparkdream.season.v1.Guild",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.founder !== "") {
+            writer.uint32(34).string(message.founder);
+        }
+        if (message.createdBlock !== BigInt(0)) {
+            writer.uint32(40).int64(message.createdBlock);
+        }
+        if (message.inviteOnly === true) {
+            writer.uint32(48).bool(message.inviteOnly);
+        }
+        if (message.status !== 0) {
+            writer.uint32(56).int32(message.status);
+        }
+        for (const v of message.officers) {
+            writer.uint32(66).string(v);
+        }
+        for (const v of message.pendingInvites) {
+            writer.uint32(74).string(v);
+        }
+        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 = createBaseGuild();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                case 2:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                case 4:
+                    message.founder = reader.string();
+                    break;
+                case 5:
+                    message.createdBlock = reader.int64();
+                    break;
+                case 6:
+                    message.inviteOnly = reader.bool();
+                    break;
+                case 7:
+                    message.status = reader.int32();
+                    break;
+                case 8:
+                    message.officers.push(reader.string());
+                    break;
+                case 9:
+                    message.pendingInvites.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGuild();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.name = object.name ?? "";
+        message.description = object.description ?? "";
+        message.founder = object.founder ?? "";
+        message.createdBlock = object.createdBlock !== undefined && object.createdBlock !== null ? BigInt(object.createdBlock.toString()) : BigInt(0);
+        message.inviteOnly = object.inviteOnly ?? false;
+        message.status = object.status ?? 0;
+        message.officers = object.officers?.map(e => e) || [];
+        message.pendingInvites = object.pendingInvites?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGuild();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.founder !== undefined && object.founder !== null) {
+            message.founder = object.founder;
+        }
+        if (object.created_block !== undefined && object.created_block !== null) {
+            message.createdBlock = BigInt(object.created_block);
+        }
+        if (object.invite_only !== undefined && object.invite_only !== null) {
+            message.inviteOnly = object.invite_only;
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        message.officers = object.officers?.map(e => e) || [];
+        message.pendingInvites = object.pending_invites?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.founder = message.founder === "" ? undefined : message.founder;
+        obj.created_block = message.createdBlock !== BigInt(0) ? message.createdBlock?.toString() : undefined;
+        obj.invite_only = message.inviteOnly === false ? undefined : message.inviteOnly;
+        obj.status = message.status === 0 ? undefined : message.status;
+        if (message.officers) {
+            obj.officers = message.officers.map(e => e);
+        }
+        else {
+            obj.officers = message.officers;
+        }
+        if (message.pendingInvites) {
+            obj.pending_invites = message.pendingInvites.map(e => e);
+        }
+        else {
+            obj.pending_invites = message.pendingInvites;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Guild.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Guild.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Guild.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.Guild",
+            value: exports.Guild.encode(message).finish()
+        };
+    }
+};

package/sparkdream/season/v1/guild_invite.d.ts

@@ -0,0 +1,52 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GuildInvite defines the GuildInvite message.
+ * @name GuildInvite
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildInvite
+ */
+export interface GuildInvite {
+    guildInvitee: string;
+    inviter: string;
+    createdEpoch: bigint;
+    expiresEpoch: bigint;
+}
+export interface GuildInviteProtoMsg {
+    typeUrl: "/sparkdream.season.v1.GuildInvite";
+    value: Uint8Array;
+}
+/**
+ * GuildInvite defines the GuildInvite message.
+ * @name GuildInviteAmino
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildInvite
+ */
+export interface GuildInviteAmino {
+    guild_invitee?: string;
+    inviter?: string;
+    created_epoch?: string;
+    expires_epoch?: string;
+}
+export interface GuildInviteAminoMsg {
+    type: "/sparkdream.season.v1.GuildInvite";
+    value: GuildInviteAmino;
+}
+/**
+ * GuildInvite defines the GuildInvite message.
+ * @name GuildInvite
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildInvite
+ */
+export declare const GuildInvite: {
+    typeUrl: string;
+    encode(message: GuildInvite, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GuildInvite;
+    fromPartial(object: DeepPartial<GuildInvite>): GuildInvite;
+    fromAmino(object: GuildInviteAmino): GuildInvite;
+    toAmino(message: GuildInvite): GuildInviteAmino;
+    fromAminoMsg(object: GuildInviteAminoMsg): GuildInvite;
+    fromProtoMsg(message: GuildInviteProtoMsg): GuildInvite;
+    toProto(message: GuildInvite): Uint8Array;
+    toProtoMsg(message: GuildInvite): GuildInviteProtoMsg;
+};

package/sparkdream/season/v1/guild_invite.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildInvite = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseGuildInvite() {
+    return {
+        guildInvitee: "",
+        inviter: "",
+        createdEpoch: BigInt(0),
+        expiresEpoch: BigInt(0)
+    };
+}
+/**
+ * GuildInvite defines the GuildInvite message.
+ * @name GuildInvite
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildInvite
+ */
+exports.GuildInvite = {
+    typeUrl: "/sparkdream.season.v1.GuildInvite",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.guildInvitee !== "") {
+            writer.uint32(10).string(message.guildInvitee);
+        }
+        if (message.inviter !== "") {
+            writer.uint32(18).string(message.inviter);
+        }
+        if (message.createdEpoch !== BigInt(0)) {
+            writer.uint32(24).int64(message.createdEpoch);
+        }
+        if (message.expiresEpoch !== BigInt(0)) {
+            writer.uint32(32).int64(message.expiresEpoch);
+        }
+        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 = createBaseGuildInvite();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.guildInvitee = reader.string();
+                    break;
+                case 2:
+                    message.inviter = reader.string();
+                    break;
+                case 3:
+                    message.createdEpoch = reader.int64();
+                    break;
+                case 4:
+                    message.expiresEpoch = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGuildInvite();
+        message.guildInvitee = object.guildInvitee ?? "";
+        message.inviter = object.inviter ?? "";
+        message.createdEpoch = object.createdEpoch !== undefined && object.createdEpoch !== null ? BigInt(object.createdEpoch.toString()) : BigInt(0);
+        message.expiresEpoch = object.expiresEpoch !== undefined && object.expiresEpoch !== null ? BigInt(object.expiresEpoch.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGuildInvite();
+        if (object.guild_invitee !== undefined && object.guild_invitee !== null) {
+            message.guildInvitee = object.guild_invitee;
+        }
+        if (object.inviter !== undefined && object.inviter !== null) {
+            message.inviter = object.inviter;
+        }
+        if (object.created_epoch !== undefined && object.created_epoch !== null) {
+            message.createdEpoch = BigInt(object.created_epoch);
+        }
+        if (object.expires_epoch !== undefined && object.expires_epoch !== null) {
+            message.expiresEpoch = BigInt(object.expires_epoch);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.guild_invitee = message.guildInvitee === "" ? undefined : message.guildInvitee;
+        obj.inviter = message.inviter === "" ? undefined : message.inviter;
+        obj.created_epoch = message.createdEpoch !== BigInt(0) ? message.createdEpoch?.toString() : undefined;
+        obj.expires_epoch = message.expiresEpoch !== BigInt(0) ? message.expiresEpoch?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GuildInvite.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GuildInvite.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GuildInvite.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.GuildInvite",
+            value: exports.GuildInvite.encode(message).finish()
+        };
+    }
+};

package/sparkdream/season/v1/guild_membership.d.ts

@@ -0,0 +1,54 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * GuildMembership defines the GuildMembership message.
+ * @name GuildMembership
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildMembership
+ */
+export interface GuildMembership {
+    member: string;
+    guildId: bigint;
+    joinedEpoch: bigint;
+    leftEpoch: bigint;
+    guildsJoinedThisSeason: bigint;
+}
+export interface GuildMembershipProtoMsg {
+    typeUrl: "/sparkdream.season.v1.GuildMembership";
+    value: Uint8Array;
+}
+/**
+ * GuildMembership defines the GuildMembership message.
+ * @name GuildMembershipAmino
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildMembership
+ */
+export interface GuildMembershipAmino {
+    member?: string;
+    guild_id?: string;
+    joined_epoch?: string;
+    left_epoch?: string;
+    guilds_joined_this_season?: string;
+}
+export interface GuildMembershipAminoMsg {
+    type: "/sparkdream.season.v1.GuildMembership";
+    value: GuildMembershipAmino;
+}
+/**
+ * GuildMembership defines the GuildMembership message.
+ * @name GuildMembership
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildMembership
+ */
+export declare const GuildMembership: {
+    typeUrl: string;
+    encode(message: GuildMembership, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GuildMembership;
+    fromPartial(object: DeepPartial<GuildMembership>): GuildMembership;
+    fromAmino(object: GuildMembershipAmino): GuildMembership;
+    toAmino(message: GuildMembership): GuildMembershipAmino;
+    fromAminoMsg(object: GuildMembershipAminoMsg): GuildMembership;
+    fromProtoMsg(message: GuildMembershipProtoMsg): GuildMembership;
+    toProto(message: GuildMembership): Uint8Array;
+    toProtoMsg(message: GuildMembership): GuildMembershipProtoMsg;
+};

package/sparkdream/season/v1/guild_membership.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMembership = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseGuildMembership() {
+    return {
+        member: "",
+        guildId: BigInt(0),
+        joinedEpoch: BigInt(0),
+        leftEpoch: BigInt(0),
+        guildsJoinedThisSeason: BigInt(0)
+    };
+}
+/**
+ * GuildMembership defines the GuildMembership message.
+ * @name GuildMembership
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.GuildMembership
+ */
+exports.GuildMembership = {
+    typeUrl: "/sparkdream.season.v1.GuildMembership",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.member !== "") {
+            writer.uint32(10).string(message.member);
+        }
+        if (message.guildId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.guildId);
+        }
+        if (message.joinedEpoch !== BigInt(0)) {
+            writer.uint32(24).int64(message.joinedEpoch);
+        }
+        if (message.leftEpoch !== BigInt(0)) {
+            writer.uint32(32).int64(message.leftEpoch);
+        }
+        if (message.guildsJoinedThisSeason !== BigInt(0)) {
+            writer.uint32(40).uint64(message.guildsJoinedThisSeason);
+        }
+        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 = createBaseGuildMembership();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.member = reader.string();
+                    break;
+                case 2:
+                    message.guildId = reader.uint64();
+                    break;
+                case 3:
+                    message.joinedEpoch = reader.int64();
+                    break;
+                case 4:
+                    message.leftEpoch = reader.int64();
+                    break;
+                case 5:
+                    message.guildsJoinedThisSeason = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGuildMembership();
+        message.member = object.member ?? "";
+        message.guildId = object.guildId !== undefined && object.guildId !== null ? BigInt(object.guildId.toString()) : BigInt(0);
+        message.joinedEpoch = object.joinedEpoch !== undefined && object.joinedEpoch !== null ? BigInt(object.joinedEpoch.toString()) : BigInt(0);
+        message.leftEpoch = object.leftEpoch !== undefined && object.leftEpoch !== null ? BigInt(object.leftEpoch.toString()) : BigInt(0);
+        message.guildsJoinedThisSeason = object.guildsJoinedThisSeason !== undefined && object.guildsJoinedThisSeason !== null ? BigInt(object.guildsJoinedThisSeason.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGuildMembership();
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.guild_id !== undefined && object.guild_id !== null) {
+            message.guildId = BigInt(object.guild_id);
+        }
+        if (object.joined_epoch !== undefined && object.joined_epoch !== null) {
+            message.joinedEpoch = BigInt(object.joined_epoch);
+        }
+        if (object.left_epoch !== undefined && object.left_epoch !== null) {
+            message.leftEpoch = BigInt(object.left_epoch);
+        }
+        if (object.guilds_joined_this_season !== undefined && object.guilds_joined_this_season !== null) {
+            message.guildsJoinedThisSeason = BigInt(object.guilds_joined_this_season);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.guild_id = message.guildId !== BigInt(0) ? message.guildId?.toString() : undefined;
+        obj.joined_epoch = message.joinedEpoch !== BigInt(0) ? message.joinedEpoch?.toString() : undefined;
+        obj.left_epoch = message.leftEpoch !== BigInt(0) ? message.leftEpoch?.toString() : undefined;
+        obj.guilds_joined_this_season = message.guildsJoinedThisSeason !== BigInt(0) ? message.guildsJoinedThisSeason?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GuildMembership.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GuildMembership.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GuildMembership.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.GuildMembership",
+            value: exports.GuildMembership.encode(message).finish()
+        };
+    }
+};