1.3.4

Get interaction commands using gateway

DOCUMENT.md

@@ -9,6 +9,7 @@
 - [<strong>Guild</strong>](https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/Guild.md)
 - [<strong>Message</strong>](https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/Message.md)
 - [<strong>User</strong>](https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/User.md)
+- [<strong>API</strong>](https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/API.md)
 
 ## More features
 

Document/API.md

@@ -0,0 +1,68 @@
+# Extending Discord.js-selfbot-v13
+> `credit: Discum`
+
+How to add extra API wraps to Discord.js-selfbot-v13?
+# Table of Contents
+- [HTTP APIs](#HTTP-APIs) 
+- [Gateway APIs](#Gateway-APIs)
+
+### HTTP APIs:
+
+```js
+URL example:
+'https://discord.com/api/v9/users/@me'
+const url = client.api.users['@me'];
+/* Method: GET | POST | PUT | PATCH | DELETE */
+```
+
+
+###### GET: 
+```js
+await client.api.users['@me'].get({ versioned: true });
+/* Request: https://discord.com/api/v9/users/@me */
+await client.api.users['@me'].get({ versioned: false });
+/* Request: https://discord.com/api/users/@me */
+```
+###### POST: 
+```js
+await client.api.channels[channel.id].messages.post({ versioned: true, data: {}, files: [] });
+/* Request: https://discord.com/api/v9/channels/{channel.id}/messages */
+```
+###### PUT: 
+```js
+await client.api
+      .guilds(guild.id)
+      .bans(user.id)
+      .put({
+        versioned: true,
+        data: {},
+      });
+/* Request: https://discord.com/api/guilds/{guild.id}/bans/{user.id} */
+```
+###### PATCH: 
+```js
+await client.api.users['@me'].patch({ versioned: true, data: {} });
+/* Request: https://discord.com/api/v9/users/@me */
+```
+###### DELETE: 
+```js
+await client.api.hypesquad.online.delete({ versioned: true });
+/* Request: https://discord.com/api/v9/hypesquad/online */
+```    
+### Gateway APIs
+You need to send data to the port and listen for an event. This is quite complicated but if you want to use an existing event, here are the instructions
+
+###### SEND:
+```js
+const { Constants } = require('discord.js-selfbot-v13');
+// Global gateway (example update presence)
+client.ws.broadcast({
+    op: Constants.Opcodes.STATUS_UPDATE,
+    d: {},
+});
+// Guild gateway (example get all members)
+guild.shard.send({
+    op: Constants.Opcodes.REQUEST_GUILD_MEMBERS,
+    d: {},
+});
+```

Document/Message.md

@@ -4,6 +4,30 @@
 
 ## Interaction
 <details>
+<summary>Fetch Commands data</summary>
+
+```js
+/* Save to cache */
+// In guild (Opcode 24)
+await guild.searchInteraction(
+	{
+		limit: 100, // default: 1
+		query: 'ping', // optional
+		type: 'CHAT_INPUT', // default: 'CHAT_INPUT'
+		offset: 0, // default: 0
+		botID: ['botid1', 'botid2'], // optional
+	}
+);
+// Fetch all commands (1 bot) Shouldn't be used
+await bot.applications.fetch(
+	{
+		guildId: 'guild id to search', // optional
+		force: false, // Using cache or createDMs to bot
+	}
+);
+```
+</details>
+<details>
 <summary>Button Click</summary>
 
 ```js
@@ -57,6 +81,7 @@ await message.contextMenu(botID, commandName);
 > In this way, all Slash commands can be obtained
 - I will try to find another way to not need to create DMs with Bot anymore
 - Credit: [Here](https://www.reddit.com/r/Discord_selfbots/comments/tczprx/discum_help_creating_a_selfbot_that_can_do_ping/)
+- <strong>Update: Now to get more secure interaction commands you need to use guild.searchInteraction() (using gateway)</strong>
 </details>
 
 ## MessageEmbed ?

package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord.js-selfbot-v13",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "A unofficial discord.js fork for creating selfbots [Based on discord.js v13]",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

src/client/actions/InteractionCreate.js

@@ -60,7 +60,7 @@ class InteractionCreateAction extends Action {
         InteractionType = AutocompleteInteraction;
         break;
       default:
-        client.emit(Events.DEBUG, `[INTERACTION] Received interaction with unknown type: ${data.type}`);
+        client.emit(Events.DEBUG, `[INTERACTION] Received [BOT] / Send (Selfbot) interactionID ${data.id} with unknown type: ${data.type}`);
         return;
     }
 

src/client/websocket/handlers/GUILD_APPLICATION_COMMANDS_UPDATE.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = (client, { d: data }) => {
+    if (!data.application_commands[0]) return;
+    for (const command of data.application_commands) {
+        const user = client.users.cache.get(command.application_id);
+        if (!user) continue;
+        user.applications._add(command, true);
+    };
+};

src/client/websocket/handlers/GUILD_MEMBER_LIST_UPDATE.js

@@ -9,6 +9,7 @@ module.exports = (client, { d: data }) => {
     const guild = client.guilds.cache.get(data.guild_id);
     if (!guild) return;
     const members = new Collection();
+    // Get Member from side Discord Channel (online counting if large server)
     for (const object of data.ops) {
         if (object.op == 'SYNC') {
             for (const member_ of object.items) {

src/client/websocket/handlers/INTERACTION_CREATE.js

@@ -1,5 +1,7 @@
 'use strict';
+const { Events } = require('../../../util/Constants');
 
 module.exports = (client, packet) => {
-  client.actions.InteractionCreate.handle(packet.d);
+	if (client.user.bot) client.actions.InteractionCreate.handle(packet.d);
+  else client.emit(Events.INTERACTION_CREATE, packet.d);
 };

src/client/websocket/handlers/INTERACTION_FAILED.js

@@ -0,0 +1,6 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+	client.emit(Events.INTERACTION_FAILED, data);
+};

src/client/websocket/handlers/INTERACTION_SUCCESS.js

@@ -0,0 +1,6 @@
+'use strict';
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+	client.emit(Events.INTERACTION_SUCCESS, data);
+};

src/client/websocket/handlers/index.js

@@ -18,6 +18,10 @@ const handlers = Object.fromEntries([
 	['GUILD_MEMBER_UPDATE', require('./GUILD_MEMBER_UPDATE')],
 	['GUILD_MEMBERS_CHUNK', require('./GUILD_MEMBERS_CHUNK')],
 	['GUILD_MEMBER_LIST_UPDATE', require('./GUILD_MEMBER_LIST_UPDATE.js')],
+	[
+		'GUILD_APPLICATION_COMMANDS_UPDATE',
+		require('./GUILD_APPLICATION_COMMANDS_UPDATE.js'),
+	],
 	['GUILD_INTEGRATIONS_UPDATE', require('./GUILD_INTEGRATIONS_UPDATE')],
 	['GUILD_ROLE_CREATE', require('./GUILD_ROLE_CREATE')],
 	['GUILD_ROLE_DELETE', require('./GUILD_ROLE_DELETE')],
@@ -50,6 +54,8 @@ const handlers = Object.fromEntries([
 	['VOICE_SERVER_UPDATE', require('./VOICE_SERVER_UPDATE')],
 	['WEBHOOKS_UPDATE', require('./WEBHOOKS_UPDATE')],
 	['INTERACTION_CREATE', require('./INTERACTION_CREATE')],
+	['INTERACTION_SUCCESS', require('./INTERACTION_SUCCESS')],
+	['INTERACTION_FAILED', require('./INTERACTION_FAILED')],
 	['STAGE_INSTANCE_CREATE', require('./STAGE_INSTANCE_CREATE')],
 	['STAGE_INSTANCE_UPDATE', require('./STAGE_INSTANCE_UPDATE')],
 	['STAGE_INSTANCE_DELETE', require('./STAGE_INSTANCE_DELETE')],

src/managers/ApplicationCommandManager.js

@@ -84,7 +84,7 @@ class ApplicationCommandManager extends CachedManager {
    *   .catch(console.error);
    */
   async fetch(id, { guildId, cache = true, force = false } = {}) {
-    await this.user.createDM().catch(() => {});
+    // change from user.createDM to opcode (risky action)
     if (typeof id === 'object') {
       ({ guildId, cache = true } = id);
     } else if (id) {
@@ -92,10 +92,11 @@ class ApplicationCommandManager extends CachedManager {
         const existing = this.cache.get(id);
         if (existing) return existing;
       }
+      await this.user.createDM().catch(() => {});
       const command = await this.commandPath({ id, guildId }).get();
       return this._add(command, cache);
     }
-
+    await this.user.createDM().catch(() => {});
     const data = await this.commandPath({ guildId }).get();
     return data.reduce((coll, command) => coll.set(command.id, this._add(command, cache, guildId)), new Collection());
   }

src/util/Constants.js

@@ -347,6 +347,8 @@ exports.Events = {
 	TYPING_START: 'typingStart',
 	WEBHOOKS_UPDATE: 'webhookUpdate',
 	INTERACTION_CREATE: 'interactionCreate',
+	INTERACTION_SUCCESS: 'interactionSuccess',
+	INTERACTION_FAILED: 'interactionFailed',
 	ERROR: 'error',
 	WARN: 'warn',
 	DEBUG: 'debug',

typings/index.d.ts

@@ -146,6 +146,7 @@ import {
   RawWidgetData,
   RawWidgetMemberData,
 } from './rawDataTypes';
+import { RelationshipType } from '../src/util/Constants';
 
 //#region Classes
 
@@ -975,6 +976,7 @@ export class Guild extends AnonymousGuild {
   public fetchAuditLogs<T extends GuildAuditLogsResolvable = 'ALL'>(
     options?: GuildAuditLogsFetchOptions<T>,
   ): Promise<GuildAuditLogs<T>>;
+  public searchInteraction(options?: guildSearchInteraction): Promise<void>;
   public fetchIntegrations(): Promise<Collection<Snowflake | string, Integration>>;
   public fetchOwner(options?: BaseFetchOptions): Promise<GuildMember>;
   public fetchPreview(): Promise<GuildPreview>;
@@ -3886,6 +3888,14 @@ export interface BaseFetchOptions {
   force?: boolean;
 }
 
+export interface guildSearchInteraction {
+  type?: ApplicationCommandTypes,
+  query?: String | void,
+  limit?: Number,
+  offset?: Number,
+  botID?: Array<User.id>,
+}
+
 export interface BaseMessageComponentOptions {
   type?: MessageComponentType | MessageComponentTypes;
 }
@@ -4052,6 +4062,11 @@ export interface ClientEvents extends BaseClientEvents {
     data: { count: number; index: number; nonce: string | undefined },
   ];
   guildMemberUpdate: [oldMember: GuildMember | PartialGuildMember, newMember: GuildMember];
+  guildMemberListUpdate: [
+    members: Collection<Snowflake, GuildMember>,
+    guild: Guild,
+    data: {}, // see: https://luna.gitlab.io/discord-unofficial-docs/lazy_guilds.html
+  ]
   guildUpdate: [oldGuild: Guild, newGuild: Guild];
   inviteCreate: [invite: Invite];
   inviteDelete: [invite: Invite];
@@ -4089,7 +4104,9 @@ export interface ClientEvents extends BaseClientEvents {
   webhookUpdate: [channel: TextChannel | NewsChannel];
   /** @deprecated Use interactionCreate instead */
   interaction: [interaction: Interaction];
-  interactionCreate: [interaction: Interaction];
+  interactionCreate: [interaction: Interaction | { nonce: Snowflake, id: Snowflake }];
+  interactionSuccess: [interaction: { nonce: Snowflake, id: Snowflake }];
+  interactionFailed: [interaction: { nonce: Snowflake, id: Snowflake }];
   shardDisconnect: [closeEvent: CloseEvent, shardId: number];
   shardError: [error: Error, shardId: number];
   shardReady: [shardId: number, unavailableGuilds: Set<Snowflake> | undefined];
@@ -4106,6 +4123,16 @@ export interface ClientEvents extends BaseClientEvents {
   guildScheduledEventDelete: [guildScheduledEvent: GuildScheduledEvent];
   guildScheduledEventUserAdd: [guildScheduledEvent: GuildScheduledEvent, user: User];
   guildScheduledEventUserRemove: [guildScheduledEvent: GuildScheduledEvent, user: User];
+  relationshipAdd: [
+    id: Snowflake,
+    type: RelationshipType,
+    user: User,
+  ]
+  relationshipRemove: [
+    id: Snowflake,
+    type: RelationshipType,
+    user: User,
+  ]
 }
 
 export interface ClientFetchInviteOptions {
@@ -4285,74 +4312,79 @@ export interface ConstantsEvents {
   /** @deprecated See [this issue](https://github.com/discord/discord-api-docs/issues/3690) for more information. */
   APPLICATION_COMMAND_DELETE: 'applicationCommandDelete';
   /** @deprecated See [this issue](https://github.com/discord/discord-api-docs/issues/3690) for more information. */
-  APPLICATION_COMMAND_UPDATE: 'applicationCommandUpdate';
+  APPLICATION_COMMAND_UPDATE: 'applicationCommandUpdate',
-  GUILD_CREATE: 'guildCreate';
+  GUILD_CREATE: 'guildCreate',
-  GUILD_DELETE: 'guildDelete';
+  GUILD_DELETE: 'guildDelete',
-  GUILD_UPDATE: 'guildUpdate';
+  GUILD_UPDATE: 'guildUpdate',
-  INVITE_CREATE: 'inviteCreate';
+  GUILD_UNAVAILABLE: 'guildUnavailable',
-  INVITE_DELETE: 'inviteDelete';
+  GUILD_MEMBER_ADD: 'guildMemberAdd',
-  GUILD_UNAVAILABLE: 'guildUnavailable';
+  GUILD_MEMBER_REMOVE: 'guildMemberRemove',
-  GUILD_MEMBER_ADD: 'guildMemberAdd';
+  GUILD_MEMBER_UPDATE: 'guildMemberUpdate',
-  GUILD_MEMBER_REMOVE: 'guildMemberRemove';
+  GUILD_MEMBER_AVAILABLE: 'guildMemberAvailable',
-  GUILD_MEMBER_UPDATE: 'guildMemberUpdate';
+  GUILD_MEMBERS_CHUNK: 'guildMembersChunk',
-  GUILD_MEMBER_AVAILABLE: 'guildMemberAvailable';
+  GUILD_MEMBER_LIST_UPDATE: 'guildMemberListUpdate',
-  GUILD_MEMBERS_CHUNK: 'guildMembersChunk';
+  GUILD_INTEGRATIONS_UPDATE: 'guildIntegrationsUpdate',
-  GUILD_INTEGRATIONS_UPDATE: 'guildIntegrationsUpdate';
+  GUILD_ROLE_CREATE: 'roleCreate',
-  GUILD_ROLE_CREATE: 'roleCreate';
+  GUILD_ROLE_DELETE: 'roleDelete',
-  GUILD_ROLE_DELETE: 'roleDelete';
+  INVITE_CREATE: 'inviteCreate',
-  GUILD_ROLE_UPDATE: 'roleUpdate';
+  INVITE_DELETE: 'inviteDelete',
-  GUILD_EMOJI_CREATE: 'emojiCreate';
+  GUILD_ROLE_UPDATE: 'roleUpdate',
-  GUILD_EMOJI_DELETE: 'emojiDelete';
+  GUILD_EMOJI_CREATE: 'emojiCreate',
-  GUILD_EMOJI_UPDATE: 'emojiUpdate';
+  GUILD_EMOJI_DELETE: 'emojiDelete',
-  GUILD_BAN_ADD: 'guildBanAdd';
+  GUILD_EMOJI_UPDATE: 'emojiUpdate',
-  GUILD_BAN_REMOVE: 'guildBanRemove';
+  GUILD_BAN_ADD: 'guildBanAdd',
-  CHANNEL_CREATE: 'channelCreate';
+  GUILD_BAN_REMOVE: 'guildBanRemove',
-  CHANNEL_DELETE: 'channelDelete';
+  CHANNEL_CREATE: 'channelCreate',
-  CHANNEL_UPDATE: 'channelUpdate';
+  CHANNEL_DELETE: 'channelDelete',
-  CHANNEL_PINS_UPDATE: 'channelPinsUpdate';
+  CHANNEL_UPDATE: 'channelUpdate',
-  MESSAGE_CREATE: 'messageCreate';
+  CHANNEL_PINS_UPDATE: 'channelPinsUpdate',
-  MESSAGE_DELETE: 'messageDelete';
+  MESSAGE_CREATE: 'messageCreate',
-  MESSAGE_UPDATE: 'messageUpdate';
+  MESSAGE_DELETE: 'messageDelete',
-  MESSAGE_BULK_DELETE: 'messageDeleteBulk';
+  MESSAGE_UPDATE: 'messageUpdate',
-  MESSAGE_REACTION_ADD: 'messageReactionAdd';
+  MESSAGE_BULK_DELETE: 'messageDeleteBulk',
-  MESSAGE_REACTION_REMOVE: 'messageReactionRemove';
+  MESSAGE_REACTION_ADD: 'messageReactionAdd',
-  MESSAGE_REACTION_REMOVE_ALL: 'messageReactionRemoveAll';
+  MESSAGE_REACTION_REMOVE: 'messageReactionRemove',
-  MESSAGE_REACTION_REMOVE_EMOJI: 'messageReactionRemoveEmoji';
+  MESSAGE_REACTION_REMOVE_ALL: 'messageReactionRemoveAll',
-  THREAD_CREATE: 'threadCreate';
+  MESSAGE_REACTION_REMOVE_EMOJI: 'messageReactionRemoveEmoji',
-  THREAD_DELETE: 'threadDelete';
+  THREAD_CREATE: 'threadCreate',
-  THREAD_UPDATE: 'threadUpdate';
+  THREAD_DELETE: 'threadDelete',
-  THREAD_LIST_SYNC: 'threadListSync';
+  THREAD_UPDATE: 'threadUpdate',
-  THREAD_MEMBER_UPDATE: 'threadMemberUpdate';
+  THREAD_LIST_SYNC: 'threadListSync',
-  THREAD_MEMBERS_UPDATE: 'threadMembersUpdate';
+  THREAD_MEMBER_UPDATE: 'threadMemberUpdate',
-  USER_UPDATE: 'userUpdate';
+  THREAD_MEMBERS_UPDATE: 'threadMembersUpdate',
-  PRESENCE_UPDATE: 'presenceUpdate';
+  USER_UPDATE: 'userUpdate',
-  VOICE_SERVER_UPDATE: 'voiceServerUpdate';
+  PRESENCE_UPDATE: 'presenceUpdate',
-  VOICE_STATE_UPDATE: 'voiceStateUpdate';
+  VOICE_SERVER_UPDATE: 'voiceServerUpdate',
-  TYPING_START: 'typingStart';
+  VOICE_STATE_UPDATE: 'voiceStateUpdate',
-  WEBHOOKS_UPDATE: 'webhookUpdate';
+  TYPING_START: 'typingStart',
-  INTERACTION_CREATE: 'interactionCreate';
+  WEBHOOKS_UPDATE: 'webhookUpdate',
-  ERROR: 'error';
+  INTERACTION_CREATE: 'interactionCreate',
-  WARN: 'warn';
+  INTERACTION_SUCCESS: 'interactionSuccess',
-  DEBUG: 'debug';
+  INTERACTION_FAILED: 'interactionFailed',
-  CACHE_SWEEP: 'cacheSweep';
+  ERROR: 'error',
-  SHARD_DISCONNECT: 'shardDisconnect';
+  WARN: 'warn',
-  SHARD_ERROR: 'shardError';
+  DEBUG: 'debug',
-  SHARD_RECONNECTING: 'shardReconnecting';
+  CACHE_SWEEP: 'cacheSweep',
-  SHARD_READY: 'shardReady';
+  SHARD_DISCONNECT: 'shardDisconnect',
-  SHARD_RESUME: 'shardResume';
+  SHARD_ERROR: 'shardError',
-  INVALIDATED: 'invalidated';
+  SHARD_RECONNECTING: 'shardReconnecting',
-  RAW: 'raw';
+  SHARD_READY: 'shardReady',
-  STAGE_INSTANCE_CREATE: 'stageInstanceCreate';
+  SHARD_RESUME: 'shardResume',
-  STAGE_INSTANCE_UPDATE: 'stageInstanceUpdate';
+  INVALIDATED: 'invalidated',
-  STAGE_INSTANCE_DELETE: 'stageInstanceDelete';
+  RAW: 'raw',
-  GUILD_STICKER_CREATE: 'stickerCreate';
+  STAGE_INSTANCE_CREATE: 'stageInstanceCreate',
-  GUILD_STICKER_DELETE: 'stickerDelete';
+  STAGE_INSTANCE_UPDATE: 'stageInstanceUpdate',
-  GUILD_STICKER_UPDATE: 'stickerUpdate';
+  STAGE_INSTANCE_DELETE: 'stageInstanceDelete',
-  GUILD_SCHEDULED_EVENT_CREATE: 'guildScheduledEventCreate';
+  GUILD_STICKER_CREATE: 'stickerCreate',
-  GUILD_SCHEDULED_EVENT_UPDATE: 'guildScheduledEventUpdate';
+  GUILD_STICKER_DELETE: 'stickerDelete',
-  GUILD_SCHEDULED_EVENT_DELETE: 'guildScheduledEventDelete';
+  GUILD_STICKER_UPDATE: 'stickerUpdate',
-  GUILD_SCHEDULED_EVENT_USER_ADD: 'guildScheduledEventUserAdd';
+  GUILD_SCHEDULED_EVENT_CREATE: 'guildScheduledEventCreate',
-  GUILD_SCHEDULED_EVENT_USER_REMOVE: 'guildScheduledEventUserRemove';
+  GUILD_SCHEDULED_EVENT_UPDATE: 'guildScheduledEventUpdate',
+  GUILD_SCHEDULED_EVENT_DELETE: 'guildScheduledEventDelete',
+  GUILD_SCHEDULED_EVENT_USER_ADD: 'guildScheduledEventUserAdd',
+  GUILD_SCHEDULED_EVENT_USER_REMOVE: 'guildScheduledEventUserRemove',
+  RELATIONSHIP_ADD: 'relationshipAdd',
+  RELATIONSHIP_REMOVE: 'relationshipRemove',
 }
 
 export interface ConstantsOpcodes {