djs-selfbot-v13 3.7.29 → 3.7.32

package/src/managers/QuestManager.js

@@ -1,8 +1,21 @@
 'use strict';
 
+const { randomUUID } = require('node:crypto');
+const { fetch } = require('undici');
 const { Collection } = require('@discordjs/collection');
 const BaseManager = require('./BaseManager');
 
+const TASK_TYPES = [
+  'WATCH_VIDEO',
+  'PLAY_ON_DESKTOP',
+  'PLAY_ON_XBOX',
+  'PLAY_ON_PLAYSTATION',
+  'STREAM_ON_DESKTOP',
+  'PLAY_ACTIVITY',
+  'WATCH_VIDEO_ON_MOBILE',
+  'ACHIEVEMENT_IN_ACTIVITY',
+];
+
 /**
  * Represents a single quest
  */
@@ -11,6 +24,15 @@ class Quest {
     this.id = data.id;
     this.config = data.config;
     this.userStatus = data.user_status;
+    this._raw = data;
+  }
+
+  /**
+   * Raw quest data from the API
+   * @returns {Object}
+   */
+  get raw() {
+    return this._raw;
   }
 
   /**
@@ -52,7 +74,24 @@ class Quest {
    * @param {Object} status New status data
    */
   updateUserStatus(status) {
-    this.userStatus = { ...this.userStatus, ...status };
+      if (!status) return;
+
+    if (status.user_status) {
+      this.updateUserStatus(status.user_status);
+      return;
+    }
+
+    const previous = this.userStatus ?? {};
+    this.userStatus = { ...previous, ...status };
+
+    if (status.progress) {
+      this.userStatus.progress = { ...previous.progress };
+      for (const [task, data] of Object.entries(status.progress)) {
+        this.userStatus.progress[task] = { ...previous.progress?.[task], ...data };
+      }
+    }
+
+    this._raw.user_status = this.userStatus;
   }
 }
 
@@ -63,7 +102,7 @@ class Quest {
 class QuestManager extends BaseManager {
   constructor(client) {
     super(client);
-    
+
     /**
      * Collection of cached quests
      * @type {Collection<string, Quest>}
@@ -71,14 +110,118 @@ class QuestManager extends BaseManager {
     this.cache = new Collection();
   }
 
+  /**
+   * Get task configuration (prefers v2)
+   * @param {Quest} quest Quest instance
+   * @returns {Object|undefined}
+   * @private
+   */
+  _getTaskConfig(quest) {
+    return quest.config.task_config_v2 ?? quest.config.task_config;
+  }
+
+  /**
+   * Find the active task type for a quest
+   * @param {Object} taskConfig Task configuration
+   * @returns {string|null}
+   * @private
+   */
+  _findTaskName(taskConfig) {
+    if (!taskConfig?.tasks) return null;
+    return TASK_TYPES.find(taskName => taskConfig.tasks[taskName] != null) ?? null;
+  }
+
+  /**
+   * Check if a quest task has reached its target
+   * @param {Quest} quest Quest instance
+   * @param {string} taskName Task type
+   * @param {number} target Target value in seconds
+   * @returns {boolean}
+   * @private
+   */
+  _isTaskComplete(quest, taskName, target) {
+    if (quest.isCompleted()) return true;
+    const value = quest.userStatus?.progress?.[taskName]?.value ?? 0;
+    return value >= target;
+  }
+
+  /**
+   * Resolve a stream key for PLAY_ACTIVITY quests
+   * @returns {string|null}
+   * @private
+   */
+  _getActivityStreamKey() {
+    const { client } = this;
+
+    const dmChannel = client.channels.cache.find(c => c.type === 'DM' || c.type === 'GROUP_DM');
+    if (dmChannel) {
+      return `call:${dmChannel.id}:${client.user.id}`;
+    }
+
+    for (const guild of client.guilds.cache.values()) {
+      const voiceChannel = guild.channels.cache.find(
+        c => c.type === 'GUILD_VOICE' || c.type === 'GUILD_STAGE_VOICE',
+      );
+      if (voiceChannel) {
+        return `guild:${guild.id}:${voiceChannel.id}:${client.user.id}`;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if quest requires Android enrollment
+   * @param {Quest} quest Quest instance
+   * @returns {boolean}
+   * @private
+   */
+  _isAndroidQuest(quest) {
+    const taskConfig = this._getTaskConfig(quest);
+    return Boolean(taskConfig?.tasks?.WATCH_VIDEO_ON_MOBILE) && !Boolean(taskConfig?.tasks?.WATCH_VIDEO);
+  }
+
+  /**
+   * Build Android-specific request headers
+   * @returns {Object}
+   * @private
+   */
+  _getAndroidHeaders() {
+    const androidProperties = {
+      os: 'Android',
+      browser: 'Discord Android',
+      device: 'b0q',
+      system_locale: 'en-US',
+      has_client_mods: false,
+      client_version: '316.11 - rn',
+      release_channel: 'googleRelease',
+      device_vendor_id: randomUUID(),
+      design_id: 2,
+      browser_user_agent: '',
+      browser_version: '',
+      os_version: '28',
+      client_build_number: 5169,
+      client_event_source: null,
+      client_launch_id: randomUUID(),
+      launch_signature: Date.now().toString(),
+      client_app_state: 'active',
+      client_heartbeat_session_id: randomUUID(),
+    };
+
+    return {
+      'User-Agent': 'Discord-Android/316011;RNA',
+      'x-super-properties': Buffer.from(JSON.stringify(androidProperties)).toString('base64'),
+      'sec-ch-ua-mobile': '?1',
+    };
+  }
+
   /**
    * Get all available quests for the user
    * @returns {Promise<Object>} Quest data
    */
   async get() {
     const data = await this.client.api.quests('@me').get();
-    
-    // Cache quests
+
     if (data.quests) {
       this.cache.clear();
       data.quests.forEach(questData => {
@@ -86,7 +229,7 @@ class QuestManager extends BaseManager {
         this.cache.set(quest.id, quest);
       });
     }
-    
+
     return data;
   }
 
@@ -95,8 +238,7 @@ class QuestManager extends BaseManager {
    * @returns {Promise<Object>} Balance data
    */
   async orbs() {
-    const data = await this.client.api.users['@me']['virtual-currency'].balance.get();
-    return data;
+    return this.client.api.users['@me']['virtual-currency'].balance.get();
   }
 
   /**
@@ -142,15 +284,19 @@ class QuestManager extends BaseManager {
   }
 
   /**
-   * Get valid quests (not completed, not expired, not blacklisted)
+   * Get valid quests (not completed, not expired)
    * @returns {Quest[]}
    */
   filterQuestsValid() {
-    return this.list().filter(quest =>
-      quest.id !== '1412491570820812933' &&
-      !quest.isCompleted() &&
-      !quest.isExpired()
-    );
+    return this.list().filter(quest => !quest.isCompleted() && !quest.isExpired());
+  }
+
+  /**
+   * Get quests ready to redeem
+   * @returns {Quest[]}
+   */
+  filterQuestsValidToRedeem() {
+    return this.getClaimable();
   }
 
   /**
@@ -170,7 +316,7 @@ class QuestManager extends BaseManager {
   async getApplicationData(ids) {
     const query = new URLSearchParams();
     ids.forEach(id => query.append('application_ids', id));
-    
+
     return this.client.api.applications.public.get({ query: query.toString() });
   }
 
@@ -178,27 +324,39 @@ class QuestManager extends BaseManager {
    * Enroll in a specific quest
    * @param {string} questId The quest ID to enroll in
    * @param {Object} [options] Enrollment options
-   * @param {number} [options.location=11] Location parameter
+   * @param {number} [options.location] Location parameter
    * @param {boolean} [options.isTargeted=false] Whether the quest is targeted
-   * @param {*} [options.metadataRaw=null] Raw metadata
+   * @param {boolean} [options.isAndroid] Whether to enroll as Android client
    * @returns {Promise<Quest|undefined>} Updated quest or undefined
    */
   async acceptQuest(questId, options = {}) {
-    const { location = 11, isTargeted = false, metadataRaw = null } = options;
-    
-    const data = await this.client.api.quests(questId).enroll.post({
-      data: { 
-        location, 
+    let quest = this.getQuest(questId);
+    const isAndroid = options.isAndroid ?? (quest ? this._isAndroidQuest(quest) : false);
+    const { isTargeted = false } = options;
+    const location = options.location ?? (isAndroid ? 12 : 11);
+
+    const requestOptions = {
+      data: {
+        location,
         is_targeted: isTargeted,
-        metadata_raw: metadataRaw
-      }
-    });
-    
-    const quest = this.getQuest(questId);
-    if (quest) {
-      quest.updateUserStatus(data);
+        metadata_sealed: null,
+        traffic_metadata_raw: quest?.raw?.traffic_metadata_raw ?? null,
+        traffic_metadata_sealed: quest?.raw?.traffic_metadata_sealed ?? null,
+      },
+    };
+
+    if (isAndroid) {
+      requestOptions.headers = this._getAndroidHeaders();
     }
-    
+
+    const data = await this.client.api.quests(questId).enroll.post(requestOptions);
+
+    if (!quest) {
+      quest = new Quest({ id: questId, config: {}, user_status: data });
+      this.cache.set(questId, quest);
+    }
+
+    quest.updateUserStatus(data);
     return quest;
   }
 
@@ -206,30 +364,80 @@ class QuestManager extends BaseManager {
    * Update progress for a video quest
    * @param {string} questId The quest ID
    * @param {number} timestamp Current progress timestamp
+   * @param {Object} [options] Request options
+   * @param {boolean} [options.isAndroid=false] Whether to send as Android client
    * @returns {Promise<Object>} Progress update result
    */
-  async videoProgress(questId, timestamp) {
-    const data = await this.client.api.quests(questId)['video-progress'].post({
-      data: { timestamp }
-    });
-    return data;
+  async videoProgress(questId, timestamp, options = {}) {
+    const requestOptions = {
+      data: { timestamp },
+    };
+
+    if (options.isAndroid) {
+      requestOptions.headers = this._getAndroidHeaders();
+    }
+
+    return this.client.api.quests(questId)['video-progress'].post(requestOptions);
   }
 
   /**
-   * Send heartbeat for desktop quests
+   * Send heartbeat for desktop/activity quests
    * @param {string} questId The quest ID
-   * @param {string} applicationId Application ID
+   * @param {string|Object} applicationIdOrOptions Application ID or heartbeat options
    * @param {boolean} [terminal=false] Whether this is a terminal heartbeat
    * @returns {Promise<Object>} Heartbeat result
    */
-  async heartbeat(questId, applicationId, terminal = false) {
-    const data = await this.client.api.quests(questId).heartbeat.post({
+  async heartbeat(questId, applicationIdOrOptions, terminal = false) {
+    let body = { terminal };
+
+    if (typeof applicationIdOrOptions === 'object' && applicationIdOrOptions !== null) {
+      const { applicationId, streamKey, terminal: isTerminal = false } = applicationIdOrOptions;
+      body.terminal = isTerminal;
+      if (applicationId) body.application_id = applicationId;
+      if (streamKey) body.stream_key = streamKey;
+    } else {
+      body.application_id = applicationIdOrOptions;
+      body.terminal = terminal;
+    }
+
+    return this.client.api.quests(questId).heartbeat.post({ data: body });
+  }
+
+  /**
+   * Claim rewards for a completed quest
+   * @param {Quest|string} quest Quest instance or quest ID
+   * @returns {Promise<Quest|undefined>}
+   */
+  async redeemQuest(quest) {
+    if (typeof quest === 'string') {
+      quest = this.getQuest(quest);
+    }
+
+    if (!quest) return undefined;
+
+    if (!quest.isCompleted()) {
+      throw new Error('Cannot redeem rewards for an incomplete quest.');
+    }
+
+    if (quest.hasClaimedRewards()) {
+      throw new Error('Rewards for this quest have already been claimed.');
+    }
+
+    const platform = quest.config.rewards_config?.platforms?.[0] ?? null;
+    const data = await this.client.api.quests(quest.id)['claim-reward'].post({
       data: {
-        application_id: applicationId,
-        terminal
-      }
+        platform,
+        location: 11,
+        is_targeted: false,
+        metadata_raw: null,
+        metadata_sealed: null,
+        traffic_metadata_raw: quest.raw?.traffic_metadata_raw ?? null,
+        traffic_metadata_sealed: quest.raw?.traffic_metadata_sealed ?? null,
+      },
     });
-    return data;
+
+    quest.updateUserStatus(data);
+    return quest;
   }
 
   /**
@@ -242,92 +450,260 @@ class QuestManager extends BaseManager {
     return new Promise(resolve => setTimeout(resolve, ms));
   }
 
+  /**
+   * Complete a watch video quest
+   * @param {Quest} quest Quest instance
+   * @param {string} taskName Task type
+   * @param {number} secondsNeeded Target seconds
+   * @param {number} secondsDone Current progress
+   * @param {boolean} isAndroid Whether this is a mobile quest
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _doingWatchVideoQuest(quest, taskName, secondsNeeded, secondsDone, isAndroid) {
+    const maxFuture = 10;
+    const speed = 7;
+    const interval = 7;
+    const enrolledAt = new Date(quest.userStatus?.enrolled_at).getTime();
+    let completed = false;
+
+    while (true) {
+      const maxAllowed = Math.floor((Date.now() - enrolledAt) / 1000) + maxFuture;
+      const diff = maxAllowed - secondsDone;
+      const timestamp = secondsDone + speed;
+
+      if (diff >= speed) {
+        const res = await this.videoProgress(
+          quest.id,
+          Math.min(secondsNeeded, timestamp + Math.random()),
+          { isAndroid },
+        );
+        completed = res.completed_at != null;
+        quest.updateUserStatus(res);
+        secondsDone = Math.min(secondsNeeded, timestamp);
+      }
+
+      if (timestamp >= secondsNeeded) break;
+
+      await this.timeout(interval * 1000);
+    }
+
+    if (!completed) {
+      const res = await this.videoProgress(quest.id, secondsNeeded, { isAndroid });
+      quest.updateUserStatus(res);
+    }
+  }
+
+  /**
+   * Complete a play-on-platform quest
+   * @param {Quest} quest Quest instance
+   * @param {string} taskName Task type
+   * @param {number} secondsNeeded Target seconds
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _doingPlayOnPlatformQuest(quest, taskName, secondsNeeded) {
+    const interval = 20;
+    const applicationId = quest.config.application?.id;
+
+    if (!applicationId) {
+      throw new Error(`Missing application ID for quest "${quest.config.messages?.quest_name ?? quest.id}".`);
+    }
+
+    while (!this._isTaskComplete(quest, taskName, secondsNeeded)) {
+      const res = await this.heartbeat(quest.id, { applicationId, terminal: false });
+      quest.updateUserStatus(res);
+
+      if (!this._isTaskComplete(quest, taskName, secondsNeeded)) {
+        await this.timeout(interval * 1000);
+      }
+    }
+
+    const res = await this.heartbeat(quest.id, { applicationId, terminal: true });
+    quest.updateUserStatus(res);
+  }
+
+  /**
+   * Complete a play activity quest
+   * @param {Quest} quest Quest instance
+   * @param {string} taskName Task type
+   * @param {number} secondsNeeded Target seconds
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _doingPlayActivityQuest(quest, taskName, secondsNeeded) {
+    const interval = 20;
+    const streamKey = this._getActivityStreamKey();
+
+    if (!streamKey) {
+      throw new Error(
+        `No voice or DM channel available for PLAY_ACTIVITY quest "${quest.config.messages?.quest_name ?? quest.id}".`,
+      );
+    }
+
+    while (!this._isTaskComplete(quest, taskName, secondsNeeded)) {
+      const res = await this.heartbeat(quest.id, { streamKey, terminal: false });
+      quest.updateUserStatus(res);
+
+      if (!this._isTaskComplete(quest, taskName, secondsNeeded)) {
+        await this.timeout(interval * 1000);
+      }
+    }
+
+    const res = await this.heartbeat(quest.id, { streamKey, terminal: true });
+    quest.updateUserStatus(res);
+  }
+
+  /**
+   * Complete an achievement in activity quest
+   * @param {Quest} quest Quest instance
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _doingAchievementInActivityQuest(quest) {
+    const applicationId = quest.config.application?.id;
+    const applicationName = quest.config.application?.name ?? applicationId;
+    const questTarget = this._getTaskConfig(quest)?.tasks?.ACHIEVEMENT_IN_ACTIVITY?.target;
+
+    if (!applicationId || !questTarget) {
+      throw new Error(`Invalid achievement quest configuration for "${applicationName}".`);
+    }
+
+    const query = new URLSearchParams({
+      response_type: 'code',
+      client_id: applicationId,
+      scope: 'identify applications.commands applications.entitlements',
+      state: '',
+    });
+
+    const authResponse = await this.client.api.oauth2.authorize.post({
+      query: Object.fromEntries(query),
+      data: {
+        permissions: '0',
+        authorize: true,
+        integration_type: 1,
+        location_context: {
+          guild_id: '10000',
+          channel_id: '10000',
+          channel_type: 10000,
+        },
+      },
+    });
+
+    let authCode = null;
+    if (authResponse?.location) {
+      authCode = new URL(authResponse.location).searchParams.get('code');
+    }
+
+    if (!authCode) {
+      throw new Error(`No auth code received for application ${applicationName}.`);
+    }
+
+    const tokenResponse = await fetch(`https://${applicationId}.discordsays.com/.proxy/acf/authorize`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ code: authCode }),
+    }).then(res => res.json());
+
+    if (!tokenResponse?.token) {
+      throw new Error(`Failed to authorize with Discord Says for application ${applicationName}.`);
+    }
+
+    const progressResponse = await fetch(`https://${applicationId}.discordsays.com/.proxy/acf/quest/progress`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-auth-token': tokenResponse.token,
+      },
+      body: JSON.stringify({ progress: questTarget }),
+    });
+
+    if (!progressResponse.ok) {
+      throw new Error(`Failed to progress quest with Discord Says for application ${applicationName}.`);
+    }
+
+    const tokens = await this.client.api.oauth2.tokens.get();
+    const tokenInfo = tokens.find(token => token.application?.id === applicationId);
+
+    if (tokenInfo) {
+      await this.client.api.oauth2.tokens(tokenInfo.id).delete().catch(() => {});
+    }
+
+    await this.get();
+  }
+
   /**
    * Complete a quest automatically
    * @param {Quest} quest Quest to complete
    * @returns {Promise<void>}
    */
   async doingQuest(quest) {
-    // Ensure quest is a proper Quest instance
     if (!(quest instanceof Quest)) {
       quest = new Quest(quest);
     }
-    
-    const questName = quest.config.messages?.quest_name || 'Unknown Quest';
-    
-    if (!quest.isEnrolledQuest()) 
-      await this.acceptQuest(quest.id);
 
-    const taskConfig = quest.config.task_config;
-    
-    const taskName = [
-      'WATCH_VIDEO',
-      'PLAY_ON_DESKTOP', 
-      'STREAM_ON_DESKTOP',
-      'PLAY_ACTIVITY',
-      'WATCH_VIDEO_ON_MOBILE'
-    ].find(x => taskConfig?.tasks?.[x] != null);
+    const questName = quest.config.messages?.quest_name || 'Unknown Quest';
+    const isAndroid = this._isAndroidQuest(quest);
+    const taskConfig = this._getTaskConfig(quest);
+    const taskName = this._findTaskName(taskConfig);
 
-    if (!taskName)
-      return console.log(`Unknown task type for quest "${questName}"`);
+    if (!taskName) {
+      console.log(`Unknown task type for quest "${questName}"`);
+      return;
+    }
 
+    if (!quest.isEnrolledQuest()) {
+      try {
+        const enrolledQuest = await this.acceptQuest(quest.id, { isAndroid });
+        if (enrolledQuest) quest = enrolledQuest;
+      } catch (error) {
+        console.error(`Failed to enroll in quest "${questName}":`, error);
+        return;
+      }
+    }
 
     const secondsNeeded = taskConfig.tasks[taskName].target;
     let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;
 
-    if (taskName === 'WATCH_VIDEO' || taskName === 'WATCH_VIDEO_ON_MOBILE') {
-      const maxFuture = 10;
-      const speed = 7;
-      const interval = 1;
-      const enrolledAt = new Date(quest.userStatus?.enrolled_at).getTime();
-      let completed = false;
-
-      while (true) {
-        const maxAllowed = Math.floor((Date.now() - enrolledAt) / 1000) + maxFuture;
-        const diff = maxAllowed - secondsDone;
-        const timestamp = secondsDone + speed;
-
-        if (diff >= speed) {
-          const res = await this.videoProgress(quest.id, Math.min(secondsNeeded, timestamp + Math.random()));
-          completed = res.completed_at != null;
-          secondsDone = Math.min(secondsNeeded, timestamp);
-        }
+    switch (taskName) {
+      case 'WATCH_VIDEO':
+      case 'WATCH_VIDEO_ON_MOBILE':
+        await this._doingWatchVideoQuest(quest, taskName, secondsNeeded, secondsDone, isAndroid);
+        break;
 
-        if (timestamp >= secondsNeeded) {
-          break;
-        }
+      case 'PLAY_ON_XBOX':
+      case 'PLAY_ON_PLAYSTATION':
+      case 'PLAY_ON_DESKTOP':
+        await this._doingPlayOnPlatformQuest(quest, taskName, secondsNeeded);
+        break;
 
-        await this.timeout(interval * 1000);
-      }
+      case 'PLAY_ACTIVITY':
+        await this._doingPlayActivityQuest(quest, taskName, secondsNeeded);
+        break;
 
-      if (!completed) {
-        await this.videoProgress(quest.id, secondsNeeded);
-      }
+      case 'ACHIEVEMENT_IN_ACTIVITY':
+        await this._doingAchievementInActivityQuest(quest);
+        break;
 
-    } else if (taskName === 'PLAY_ON_DESKTOP') {
-      const interval = 60;
+      case 'STREAM_ON_DESKTOP':
+        console.log(`Quest "${questName}" requires the Discord desktop app to complete streaming tasks.`);
+        break;
 
-      while (!quest.isCompleted()) {
-        const secondsDone = quest.userStatus?.progress?.[taskName]?.value || 0;
-        const res = await this.heartbeat(quest.id, quest.config.application.id, false);
-        quest.updateUserStatus(res);
-
-        await this.timeout(interval * 1000);
-      }
-
-      const res = await this.heartbeat(quest.id, quest.config.application.id, true);
-      quest.updateUserStatus(res);
+      default:
+        console.log(`Unsupported task type "${taskName}" for quest "${questName}".`);
     }
   }
 
   /**
    * Auto-complete all valid quests
+   * @param {Object} [options] Options
+   * @param {boolean} [options.redeem=false] Whether to redeem rewards after completion
    * @returns {Promise<void>}
    */
-  async autoCompleteAll() {
-    await this.get(); // Refresh quest data
+  async autoCompleteAll(options = {}) {
+    await this.get();
     const validQuests = this.filterQuestsValid();
-    
+
     for (const quest of validQuests) {
       try {
         await this.doingQuest(quest);
@@ -335,6 +711,17 @@ class QuestManager extends BaseManager {
         console.error(`Failed to complete quest ${quest.id}:`, error);
       }
     }
+
+    if (options.redeem) {
+      await this.get();
+      for (const quest of this.filterQuestsValidToRedeem()) {
+        try {
+          await this.redeemQuest(quest);
+        } catch (error) {
+          console.error(`Failed to redeem quest ${quest.id}:`, error);
+        }
+      }
+    }
   }
 
   /**
@@ -362,4 +749,5 @@ class QuestManager extends BaseManager {
   }
 }
 
-module.exports = QuestManager;
+module.exports = QuestManager;
+module.exports.Quest = Quest;