djs-selfbot-v13 3.1.7 → 3.2.2

package/src/managers/ReactionUserManager.js

@@ -3,15 +3,15 @@
 const { Collection } = require('@discordjs/collection');
 const CachedManager = require('./CachedManager');
 const { Error } = require('../errors');
-const { lazy } = require('../util/Util');
-const User = lazy(() => require('../structures/User'));
+const User = require('../structures/User');
+
 /**
  * Manages API methods for users who reacted to a reaction and stores their cache.
  * @extends {CachedManager}
  */
 class ReactionUserManager extends CachedManager {
   constructor(reaction, iterable) {
-    super(reaction.client, User(), iterable);
+    super(reaction.client, User, iterable);
 
     /**
      * The reaction that this manager belongs to
@@ -22,7 +22,7 @@ class ReactionUserManager extends CachedManager {
 
   /**
    * The cache of this manager
-   * @type {Collection<Snowflake, Discord.User>}
+   * @type {Collection<Snowflake, User>}
    * @name ReactionUserManager#cache
    */
 
@@ -36,7 +36,7 @@ class ReactionUserManager extends CachedManager {
   /**
    * Fetches all the users that gave this reaction. Resolves with a collection of users, mapped by their ids.
    * @param {FetchReactionUsersOptions} [options] Options for fetching the users
-   * @returns {Promise<Collection<Snowflake, Discord.User>>}
+   * @returns {Promise<Collection<Snowflake, User>>}
    */
   async fetch({ limit = 100, after } = {}) {
     const message = this.reaction.message;

package/src/managers/RelationshipManager.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const Buffer = require('node:buffer').Buffer;
 const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
 const { GuildMember } = require('../structures/GuildMember');
 const { Message } = require('../structures/Message');
 const ThreadMember = require('../structures/ThreadMember');
@@ -11,19 +11,22 @@ const { RelationshipTypes } = require('../util/Constants');
 /**
  * Manages API methods for Relationships and stores their cache.
  */
-class RelationshipManager {
+class RelationshipManager extends BaseManager {
   constructor(client, users) {
-    /**
-     * The client that instantiated this manager.
-     * @type {Client}
-     */
-    this.client = client;
+    super(client);
     /**
      * A collection of users this manager is caching. (Type: Number)
-     * @type {Collection<Snowflake, RelationshipTypes>}
-     * @readonly
+     * @type {Collection<Snowflake, RelationshipType>}
      */
     this.cache = new Collection();
+    /**
+     * @type {Collection<Snowflake, string>}
+     */
+    this.friendNicknames = new Collection();
+    /**
+     * @type {Collection<Snowflake, Date>}
+     */
+    this.sinceCache = new Collection();
     this._setup(users);
   }
 
@@ -35,7 +38,7 @@ class RelationshipManager {
   get friendCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.FRIEND)
-      .map((value, key) => [key, this.client.users.cache.get(key)]);
+      .map((_, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -47,7 +50,7 @@ class RelationshipManager {
   get blockedCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.BLOCKED)
-      .map((value, key) => [key, this.client.users.cache.get(key)]);
+      .map((_, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -59,7 +62,7 @@ class RelationshipManager {
   get incomingCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.PENDING_INCOMING)
-      .map((value, key) => [key, this.client.users.cache.get(key)]);
+      .map((_, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
@@ -71,16 +74,29 @@ class RelationshipManager {
   get outgoingCache() {
     const users = this.cache
       .filter(value => value === RelationshipTypes.PENDING_OUTGOING)
-      .map((value, key) => [key, this.client.users.cache.get(key)]);
+      .map((_, key) => [key, this.client.users.cache.get(key)]);
     return new Collection(users);
   }
 
+  /**
+   * @typedef {Object} RelationshipJSONData
+   * @property {Snowflake} id The ID of the target user
+   * @property {RelationshipType} type The type of relationship
+   * @property {string | null} nickname The nickname of the user in this relationship (1-32 characters)
+   * @property {string} since When the user requested a relationship (ISO8601 timestamp)
+   */
+
   /**
    * Return array of cache
-   * @returns {Array<{id: Snowflake, type: RelationshipTypes}>}
+   * @returns {RelationshipJSONData[]}
    */
-  toArray() {
-    return this.cache.map((value, key) => ({ id: key, type: RelationshipTypes[value] }));
+  toJSON() {
+    return this.cache.map((value, key) => ({
+      id: key,
+      type: RelationshipTypes[value],
+      nickname: this.friendNicknames.get(key),
+      since: this.sinceCache.get(key).toISOString(),
+    }));
   }
 
   /**
@@ -91,8 +107,9 @@ class RelationshipManager {
   _setup(users) {
     if (!Array.isArray(users)) return;
     for (const relationShip of users) {
-      this.client.user.friendNicknames.set(relationShip.id, relationShip.nickname);
+      this.friendNicknames.set(relationShip.id, relationShip.nickname);
       this.cache.set(relationShip.id, relationShip.type);
+      this.sinceCache.set(relationShip.id, new Date(relationShip.since || 0));
     }
   }
 
@@ -113,7 +130,7 @@ class RelationshipManager {
    * Obtains a user from Discord, or the user cache if it's already available.
    * @param {UserResolvable} [user] The user to fetch
    * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<RelationshipTypes|RelationshipManager>}
+   * @returns {Promise<RelationshipType|RelationshipManager>}
    */
   async fetch(user, { force = false } = {}) {
     if (user) {
@@ -133,66 +150,55 @@ class RelationshipManager {
   }
 
   /**
-   * Deletes a friend relationship with a client user.
+   * Deletes a friend / blocked relationship with a client user or cancels a friend request.
    * @param {UserResolvable} user Target
    * @returns {Promise<boolean>}
    */
-  deleteFriend(user) {
+  async deleteRelationship(user) {
     const id = this.resolveId(user);
-    // Check if already friends
-    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return false;
-    return this.__cancel(id);
+    if (
+      ![RelationshipTypes.FRIEND, RelationshipTypes.BLOCKED, RelationshipTypes.PENDING_OUTGOING].includes(
+        this.cache.get(id),
+      )
+    ) {
+      return Promise.resolve(false);
+    }
+    await this.client.api.users['@me'].relationships[id].delete({
+      DiscordContext: { location: 'Friends' },
+    });
+    return true;
   }
 
   /**
-   * Deletes a blocked relationship with a client user.
-   * @param {UserResolvable} user Target
-   * @returns {Promise<boolean>}
+   * @typedef {Object} FriendRequestOptions
+   * @property {UserResolvable} [user] Target
+   * @property {string} [username] Discord username
+   * @property {number | null} [discriminator] Discord discriminator
    */
-  deleteBlocked(user) {
-    const id = this.resolveId(user);
-    // Check if already blocked
-    if (this.cache.get(id) !== RelationshipTypes.BLOCKED) return false;
-    return this.__cancel(id);
-  }
 
   /**
    * Sends a friend request.
-   * @param {string} username Username of the user to send the request to
-   * @param {?number} discriminator Discriminator of the user to send the request to
+   * @param {FriendRequestOptions} options Target
    * @returns {Promise<boolean>}
    */
-  async sendFriendRequest(username, discriminator) {
-    await this.client.api.users('@me').relationships.post({
-      data: {
-        username,
-        discriminator: discriminator == 0 ? null : parseInt(discriminator),
-      },
-      headers: {
-        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Add Friend' }), 'utf8').toString('base64'),
-      },
-    });
-    return true;
-  }
-
-  /**
-   * Cancels a friend request.
-   * @param {UserResolvable} user  the user you want to delete
-   * @returns {Promise<boolean>}
-   */
-  cancelFriendRequest(user) {
-    const id = this.resolveId(user);
-    if (this.cache.get(id) !== RelationshipTypes.PENDING_OUTGOING) return false;
-    return this.__cancel(id);
-  }
-
-  async __cancel(id) {
-    await this.client.api.users['@me'].relationships[id].delete({
-      headers: {
-        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Friends' }), 'utf8').toString('base64'),
-      },
-    });
-    return true;
+  async sendFriendRequest(options) {
+    if (options?.user) {
+      const id = this.resolveId(options.user);
+      await this.client.api.users['@me'].relationships[id].put({
+        data: {},
+        DiscordContext: { location: 'ContextMenu' },
+      });
+      return true;
+    } else {
+      await this.client.api.users['@me'].relationships.post({
+        data: {
+          username: options.username,
+          discriminator: options.discriminator,
+        },
+        DiscordContext: { location: 'Add Friend' },
+      });
+      return true;
+    }
   }
 
   /**
@@ -203,16 +209,14 @@ class RelationshipManager {
   async addFriend(user) {
     const id = this.resolveId(user);
     // Check if already friends
-    if (this.cache.get(id) === RelationshipTypes.FRIEND) return false;
+    if (this.cache.get(id) === RelationshipTypes.FRIEND) return Promise.resolve(false);
     // Check if outgoing request
-    if (this.cache.get(id) === RelationshipTypes.PENDING_OUTGOING) return false;
+    if (this.cache.get(id) === RelationshipTypes.PENDING_OUTGOING) return Promise.resolve(false);
     await this.client.api.users['@me'].relationships[id].put({
       data: {
         type: RelationshipTypes.FRIEND,
       },
-      headers: {
-        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'Friends' }), 'utf8').toString('base64'),
-      },
+      DiscordContext: { location: 'Friends' },
     });
     return true;
   }
@@ -223,14 +227,19 @@ class RelationshipManager {
    * @param {?string} nickname New nickname
    * @returns {Promise<boolean>}
    */
-  async setNickname(user, nickname) {
+  async setNickname(user, nickname = null) {
     const id = this.resolveId(user);
-    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return false;
+    if (this.cache.get(id) !== RelationshipTypes.FRIEND) return Promise.resolve(false);
     await this.client.api.users['@me'].relationships[id].patch({
       data: {
         nickname: typeof nickname === 'string' ? nickname : null,
       },
     });
+    if (nickname) {
+      this.friendNicknames.set(id, nickname);
+    } else {
+      this.friendNicknames.delete(id);
+    }
     return true;
   }
 
@@ -242,14 +251,12 @@ class RelationshipManager {
   async addBlocked(user) {
     const id = this.resolveId(user);
     // Check
-    if (this.cache.get(id) === RelationshipTypes.BLOCKED) return false;
+    if (this.cache.get(id) === RelationshipTypes.BLOCKED) return Promise.resolve(false);
     await this.client.api.users['@me'].relationships[id].put({
       data: {
         type: RelationshipTypes.BLOCKED,
       },
-      headers: {
-        'X-Context-Properties': Buffer.from(JSON.stringify({ location: 'ContextMenu' }), 'utf8').toString('base64'),
-      },
+      DiscordContext: { location: 'ContextMenu' },
     });
     return true;
   }

package/src/managers/ThreadManager.js

@@ -2,7 +2,6 @@
 
 const { Collection } = require('@discordjs/collection');
 const CachedManager = require('./CachedManager');
-const { TypeError } = require('../errors');
 const ThreadChannel = require('../structures/ThreadChannel');
 
 /**
@@ -119,34 +118,8 @@ class ThreadManager extends CachedManager {
    * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
    * @returns {Promise<FetchedThreads>}
    */
-  async fetchArchived(options = {}, cache = true) {
-    if (this.client.user.bot) {
-      let { type = 'public', fetchAll = false, before, limit } = options;
-      let path = this.client.api.channels(this.channel.id);
-      if (type === 'private' && !fetchAll) {
-        path = path.users('@me');
-      }
-      let timestamp;
-      let id;
-      if (typeof before !== 'undefined') {
-        if (before instanceof ThreadChannel || /^\d{17,19}$/.test(String(before))) {
-          id = this.resolveId(before);
-          timestamp = this.resolve(before)?.archivedAt?.toISOString();
-        } else {
-          try {
-            timestamp = new Date(before).toISOString();
-          } catch {
-            throw new TypeError('INVALID_TYPE', 'before', 'DateResolvable or ThreadChannelResolvable');
-          }
-        }
-      }
-      const raw = await path.threads
-        .archived(type)
-        .get({ query: { before: type === 'private' && !fetchAll ? id : timestamp, limit } });
-      return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
-    } else {
-      return this.fetchActive(cache, { archived: true, ...options });
-    }
+  fetchArchived(options = {}, cache = true) {
+    return this.fetchActive(cache, { archived: true, ...options });
   }
 
   /**
@@ -165,22 +138,16 @@ class ThreadManager extends CachedManager {
    * @param {FetchChannelThreadsOptions} [options] Options for self-bots where advanced users can specify further options
    * @returns {Promise<FetchedThreads>}
    */
-  async fetchActive(cache = true, options = null) {
-    if (options && this.client.user.bot) {
-      throw new Error('INVALID_BOT_OPTIONS: Options can only be specified for user accounts.');
-    }
-
-    const raw = this.client.user.bot
-      ? await this.client.api.guilds(this.channel.guild.id).threads.active.get()
-      : await this.client.api.channels(this.channel.id).threads.search.get({
-          query: {
-            archived: options?.archived ?? false,
-            limit: options?.limit ?? 25,
-            offset: options?.offset ?? 0,
-            sort_by: options?.sortBy ?? 'last_message_time',
-            sort_order: options?.sortOrder ?? 'desc',
-          },
-        });
+  async fetchActive(cache = true, options = {}) {
+    const raw = await this.client.api.channels(this.channel.id).threads.search.get({
+      query: {
+        archived: options?.archived ?? false,
+        limit: options?.limit ?? 25,
+        offset: options?.offset ?? 0,
+        sort_by: options?.sortBy ?? 'last_message_time',
+        sort_order: options?.sortOrder ?? 'desc',
+      },
+    });
 
     return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
   }

package/src/managers/ThreadMemberManager.js

@@ -179,7 +179,7 @@ class ThreadMemberManager extends CachedManager {
     const id = this.resolveId(member);
     return id
       ? this._fetchOne(id, options)
-      : this._fetchMany(typeof member !== 'boolean' ? member : { ...options, cache: member });
+      : this._fetchMany(typeof member === 'boolean' ? { ...options, cache: member } : options);
   }
 }
 

package/src/managers/UserManager.js

@@ -56,16 +56,15 @@ class UserManager extends CachedManager {
       if (dmChannel && !dmChannel.partial) return dmChannel;
     }
 
-    const data = await this.client.api.users(this.client.user.id).channels.post({
+    const data = await this.client.api.users['@me'].channels.post({
       data: {
         recipients: [id],
       },
-      headers: {
-        'X-Context-Properties': 'e30=', // {}
-      },
+      DiscordContext: {},
     });
+
     const dm_channel = await this.client.channels._add(data, null, { cache });
-    await dm_channel.sync();
+    dm_channel.sync();
     return dm_channel;
   }
 
@@ -87,10 +86,9 @@ class UserManager extends CachedManager {
    * Obtains a user from Discord, or the user cache if it's already available.
    * @param {UserResolvable} user The user to fetch
    * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @param {?Snowflake} [options.guildId] The guild ID to fetch the member for
    * @returns {Promise<User>}
    */
-  async fetch(user, { cache = true, force = false, guildId = null } = {}) {
+  async fetch(user, { cache = true, force = false } = {}) {
     const id = this.resolveId(user);
     if (!force) {
       const existing = this.cache.get(id);
@@ -98,9 +96,7 @@ class UserManager extends CachedManager {
     }
 
     const data = await this.client.api.users(id).get();
-    const userObject = this._add(data, cache);
-    await userObject.getProfile(guildId ?? null).catch(() => {});
-    return userObject;
+    return this._add(data, cache);
   }
 
   /**

package/src/managers/UserNoteManager.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+
+/**
+ * Manages API methods for Client and stores their cache.
+ * @extends {BaseManager}
+ */
+class UserNoteManager extends BaseManager {
+  constructor(client, data = {}) {
+    super(client);
+    /**
+     * Cache User Note
+     * @type {Collection<Snowflake, string>}
+     */
+    this.cache = new Collection(Object.entries(data));
+  }
+
+  _reload(data = {}) {
+    this.cache = new Collection(Object.entries(data));
+    return this;
+  }
+
+  async updateNote(id, note = null) {
+    await this.client.api.users['@me'].notes(id).put({ data: { note } });
+    if (!note) this.cache.delete(id, note);
+    else this.cache.set(id, note);
+    return this;
+  }
+
+  /**
+   * Obtains a user from Discord, or the user cache if it's already available.
+   * @param {UserResolvable} user The user to fetch
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<string>}
+   */
+  async fetch(user, { cache = true, force = false } = {}) {
+    const id = this.resolveId(user);
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing) return existing;
+    }
+    const data = await this.client.api.users['@me'].notes[id]
+      .get()
+      .then(d => d.note)
+      .catch(() => '');
+    if (cache) this.cache.set(id, data);
+    return data;
+  }
+}
+
+module.exports = UserNoteManager;

package/src/rest/APIRequest.js

@@ -7,6 +7,8 @@ const makeFetchCookie = require('fetch-cookie');
 const FormData = require('form-data');
 const fetchOriginal = require('node-fetch');
 const { CookieJar } = require('tough-cookie');
+const { ciphers } = require('../util/Constants');
+const Util = require('../util/Util');
 
 const cookieJar = new CookieJar();
 const fetch = makeFetchCookie(fetchOriginal, cookieJar);
@@ -22,6 +24,10 @@ class APIRequest {
     this.options = options;
     this.retries = 0;
 
+    this.fullUserAgent = this.client.options.http.headers['User-Agent'];
+
+    this.client.options.ws.properties.browser_user_agent = this.fullUserAgent;
+
     let queryString = '';
     if (options.query) {
       const query = Object.entries(options.query)
@@ -32,16 +38,28 @@ class APIRequest {
     this.path = `${path}${queryString && `?${queryString}`}`;
   }
 
-  make(captchaKey = undefined, captchaRqtoken = undefined) {
-    if (agent === null) {
-      if (typeof this.client.options.proxy === 'string' && this.client.options.proxy.length > 0) {
-        const proxy = require('proxy-agent');
-        agent = new proxy(this.client.options.proxy);
-      } else if (this.client.options.http.agent instanceof https.Agent) {
+  make(captchaKey, captchaRqToken) {
+    if (!agent) {
+      if (Util.verifyProxyAgent(this.client.options.http.agent)) {
+        // Bad code
+        for (const [k, v] of Object.entries({
+          keepAlive: true,
+          honorCipherOrder: true,
+          secureProtocol: 'TLSv1_2_method',
+          ciphers: ciphers.join(':'),
+        })) {
+          this.client.options.http.agent.options[k] = v;
+          this.client.options.http.agent.httpsAgent.options.options[k] = v;
+        }
         agent = this.client.options.http.agent;
-        agent.keepAlive = true;
       } else {
-        agent = new https.Agent({ ...this.client.options.http.agent, keepAlive: true });
+        agent = new https.Agent({
+          ...this.client.options.http.agent,
+          keepAlive: true,
+          honorCipherOrder: true,
+          secureProtocol: 'TLSv1_2_method',
+          ciphers: ciphers.join(':'),
+        });
       }
     }
 
@@ -52,10 +70,10 @@ class APIRequest {
     const url = API + this.path;
 
     let headers = {
-      ...this.client.options.http.headers,
+      authority: 'discord.com',
       accept: '*/*',
       'accept-language': 'en-US',
-      'sec-ch-ua': `"Not?A_Brand";v="8", "Chromium";v="108"`,
+      'sec-ch-ua': '"Not?A_Brand";v="8", "Chromium";v="108"',
       'sec-ch-ua-mobile': '?0',
       'sec-ch-ua-platform': '"Windows"',
       'sec-fetch-dest': 'empty',
@@ -64,18 +82,20 @@ class APIRequest {
       'x-debug-options': 'bugReporterEnabled',
       'x-discord-locale': 'en-US',
       'x-discord-timezone': 'Asia/Saigon',
-      'x-super-properties': `${Buffer.from(
-        this.client.options.jsonTransformer(this.client.options.ws.properties),
-        'ascii',
-      ).toString('base64')}`,
+      'x-super-properties': `${Buffer.from(JSON.stringify(this.client.options.ws.properties), 'ascii').toString(
+        'base64',
+      )}`,
       Referer: 'https://discord.com/channels/@me',
       origin: 'https://discord.com',
       'Referrer-Policy': 'strict-origin-when-cross-origin',
+      ...this.client.options.http.headers,
+      'User-Agent': this.fullUserAgent,
     };
 
     if (this.options.auth !== false) headers.Authorization = this.rest.getAuth();
     if (this.options.reason) headers['X-Audit-Log-Reason'] = encodeURIComponent(this.options.reason);
     if (this.options.headers) headers = Object.assign(headers, this.options.headers);
+
     // Delete all headers if undefined
     for (const [key, value] of Object.entries(headers)) {
       if (value === undefined) delete headers[key];
@@ -85,9 +105,15 @@ class APIRequest {
         'User-Agent': this.client.options.http.headers['User-Agent'],
       };
     }
-    if (captchaKey && typeof captchaKey == 'string') {
-      headers['x-captcha-key'] = captchaKey;
-      if (captchaRqtoken) headers['x-captcha-rqtoken'] = captchaRqtoken;
+
+    // Some options
+    if (this.options.DiscordContext) {
+      headers['X-Context-Properties'] = Buffer.from(JSON.stringify(this.options.DiscordContext), 'utf8').toString(
+        'base64',
+      );
+    }
+    if (this.options.mfaToken) {
+      headers['X-Discord-Mfa-Authorization'] = this.options.mfaToken;
     }
 
     let body;
@@ -106,19 +132,21 @@ class APIRequest {
       headers = Object.assign(headers, body.getHeaders());
       // eslint-disable-next-line eqeqeq
     } else if (this.options.data != null) {
-      if (this.options.useFormDataPayloadJSON) {
+      if (this.options.usePayloadJSON) {
         body = new FormData();
         body.append('payload_json', JSON.stringify(this.options.data));
-        headers = Object.assign(headers, body.getHeaders());
       } else {
         body = JSON.stringify(this.options.data);
         headers['Content-Type'] = 'application/json';
       }
     }
 
+    // Captcha
+    if (captchaKey && typeof captchaKey == 'string') headers['X-Captcha-Key'] = captchaKey;
+    if (captchaRqToken && typeof captchaRqToken == 'string') headers['X-Captcha-Rqtoken'] = captchaRqToken;
+
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
-
     return fetch(url, {
       method: this.method,
       headers,