nodejs-insta-private-api-mqt 1.3.70

package/dist/sendmedia/sendRavenPhoto.js

@@ -0,0 +1,153 @@
+const { v4: uuidv4 } = require('uuid');
+const axios = require('axios');
+
+function buildRavenPhotoRuploadParams(uploadId) {
+  return {
+    retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+    media_type: '1',
+    upload_id: uploadId.toString(),
+    image_compression: JSON.stringify({ lib_name: 'moz', lib_version: '3.1.m', quality: '95' }),
+    xsharing_user_ids: JSON.stringify([]),
+    direct_v2: '1',
+    is_optimistic_upload: 'false',
+  };
+}
+
+async function sendRavenPhoto(session, photoBuffer, options = {}) {
+  const {
+    threadId,
+    viewMode = 'replayable',
+    mimeType = 'image/jpeg',
+  } = options;
+
+  if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+    throw new Error('sendRavenPhoto: photoBuffer must be a non-empty Buffer.');
+  }
+  if (!threadId) {
+    throw new Error('sendRavenPhoto: threadId is required.');
+  }
+
+  const uploadId = Date.now().toString();
+  const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+  const name = `${uploadId}_0_${randomSuffix}`;
+  const waterfallId = uuidv4();
+  const ruploadParams = buildRavenPhotoRuploadParams(uploadId);
+
+  const defaultHeaders = session.request.getDefaultHeaders();
+
+  const messengerUploadHeaders = {
+    ...defaultHeaders,
+    'X_FB_PHOTO_WATERFALL_ID': waterfallId,
+    'X-Entity-Type': mimeType,
+    'Offset': '0',
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'X-Entity-Name': name,
+    'X-Entity-Length': String(photoBuffer.length),
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': String(photoBuffer.length),
+    'ephemeral_media_view_mode': viewMode === 'replayable' ? '1' : '0',
+    'ig_raven_metadata': '{}',
+    'image_type': 'FILE_ATTACHMENT',
+    'Host': 'rupload.facebook.com',
+  };
+
+  const uploadResp = await axios({
+    url: `https://rupload.facebook.com/messenger_image/${name}`,
+    method: 'POST',
+    headers: messengerUploadHeaders,
+    data: photoBuffer,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+    transformRequest: [(d) => d],
+  });
+
+  const uploadParsed = uploadResp.data;
+  const serverUploadId = (uploadParsed.upload_id || uploadId).toString();
+  const attachmentFbid = uploadParsed.media_id
+    || (uploadParsed.media && uploadParsed.media.pk)
+    || (uploadParsed.media && uploadParsed.media.id)
+    || null;
+
+  const clientContext = BigInt(Math.floor(Math.random() * 2**62)).toString();
+  const compositionId = uuidv4();
+  const cameraSessionId = uuidv4();
+  const now = Math.floor(Date.now() / 1000);
+
+  const form = {
+    allow_multi_configures: '1',
+    recipient_users: '[]',
+    view_mode: viewMode,
+    is_shh_mode: '0',
+    camera_entry_point: '3',
+    thread_ids: JSON.stringify([String(threadId)]),
+    reshare_mode: 'allow_reshare',
+    original_media_type: '1',
+    send_attribution: 'direct_thread_camera',
+    client_context: clientContext,
+    camera_session_id: cameraSessionId,
+    include_e2ee_mentioned_user_list: '1',
+    hide_from_profile_grid: 'false',
+    scene_capture_type: '',
+    timezone_offset: String(new Date().getTimezoneOffset() * -60),
+    client_shared_at: String(now),
+    configure_mode: '2',
+    source_type: '4',
+    camera_position: 'unknown',
+    _uid: String(session.state.cookieUserId || session.state.igUserId),
+    device_id: session.state.deviceId,
+    composition_id: compositionId,
+    mutation_token: clientContext,
+    _uuid: session.state.uuid,
+    creation_tool_info: '[]',
+    creation_surface: 'camera',
+    capture_type: 'normal',
+    audience: 'default',
+    upload_id: serverUploadId,
+    client_timestamp: String(now),
+    sampled: 'true',
+    media_transformation_info: JSON.stringify({
+      width: '720', height: '1280',
+      x_transform: '0', y_transform: '0',
+      zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+    }),
+    edits: JSON.stringify({ filter_type: 0, filter_strength: 0.5, crop_original_size: [720.0, 1280.0] }),
+    extra: JSON.stringify({ source_width: 720, source_height: 1280 }),
+    device: JSON.stringify({
+      manufacturer: session.state.devicePayload?.manufacturer || 'samsung',
+      model: session.state.devicePayload?.model || 'SM-S938B',
+      android_version: session.state.devicePayload?.android_version || 35,
+      android_release: session.state.devicePayload?.android_release || '15',
+    }),
+  };
+
+  if (attachmentFbid) {
+    form.attachment_fbid = String(attachmentFbid);
+  }
+
+  const signedForm = (session.request && typeof session.request.sign === 'function')
+    ? session.request.sign(form)
+    : form;
+
+  const broadcastResponse = await session.request.send({
+    url: '/api/v1/direct_v2/threads/broadcast/raven_attachment/',
+    method: 'POST',
+    form: signedForm,
+    qs: { use_unified_inbox: true },
+  });
+
+  const body = broadcastResponse && (broadcastResponse.body || broadcastResponse.data || broadcastResponse);
+  return typeof body === 'string' ? JSON.parse(body) : body;
+}
+
+async function sendRavenPhotoOnce(session, photoBuffer, options = {}) {
+  return sendRavenPhoto(session, photoBuffer, { ...options, viewMode: 'once' });
+}
+
+async function sendRavenPhotoReplayable(session, photoBuffer, options = {}) {
+  return sendRavenPhoto(session, photoBuffer, { ...options, viewMode: 'replayable' });
+}
+
+module.exports = sendRavenPhoto;
+module.exports.sendRavenPhoto = sendRavenPhoto;
+module.exports.sendRavenPhotoOnce = sendRavenPhotoOnce;
+module.exports.sendRavenPhotoReplayable = sendRavenPhotoReplayable;

package/dist/sendmedia/sendRavenVideo.js

@@ -0,0 +1,158 @@
+const { v4: uuidv4 } = require('uuid');
+const axios = require('axios');
+
+function buildRavenVideoRuploadParams(uploadId, options = {}) {
+  return {
+    retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+    media_type: '2',
+    upload_id: uploadId.toString(),
+    upload_media_duration_ms: String(Math.round((options.duration || 0) * 1000)),
+    upload_media_width: String(options.width || 720),
+    upload_media_height: String(options.height || 1280),
+    xsharing_user_ids: JSON.stringify([]),
+    direct_v2: '1',
+  };
+}
+
+async function sendRavenVideo(session, videoBuffer, options = {}) {
+  const {
+    threadId,
+    viewMode = 'replayable',
+    duration = 0,
+    width = 720,
+    height = 1280,
+  } = options;
+
+  if (!videoBuffer || !Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
+    throw new Error('sendRavenVideo: videoBuffer must be a non-empty Buffer.');
+  }
+  if (!threadId) {
+    throw new Error('sendRavenVideo: threadId is required.');
+  }
+
+  const uploadId = Date.now().toString();
+  const randomSuffix = Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000);
+  const name = `${uploadId}_0_${randomSuffix}`;
+  const waterfallId = uuidv4();
+  const ruploadParams = buildRavenVideoRuploadParams(uploadId, { duration, width, height });
+
+  const defaultHeaders = session.request.getDefaultHeaders();
+
+  const messengerUploadHeaders = {
+    ...defaultHeaders,
+    'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+    'X-Entity-Type': 'video/mp4',
+    'Offset': '0',
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'X-Entity-Name': name,
+    'X-Entity-Length': String(videoBuffer.length),
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': String(videoBuffer.length),
+    'ephemeral_media_view_mode': '1',
+    'ig_raven_metadata': '{}',
+    'video_type': 'FILE_ATTACHMENT',
+    'x-fb-congestion-signal': '1',
+    'Host': 'rupload.facebook.com',
+  };
+
+  const uploadResp = await axios({
+    url: `https://rupload.facebook.com/messenger_video/${name}`,
+    method: 'POST',
+    headers: messengerUploadHeaders,
+    data: videoBuffer,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+    transformRequest: [(d) => d],
+  });
+
+  const uploadParsed = uploadResp.data;
+  const serverUploadId = (uploadParsed.upload_id || uploadId).toString();
+  const attachmentFbid = uploadParsed.media_id
+    || (uploadParsed.media && uploadParsed.media.pk)
+    || (uploadParsed.media && uploadParsed.media.id)
+    || null;
+
+  const clientContext = BigInt(Math.floor(Math.random() * 2**62)).toString();
+  const compositionId = uuidv4();
+  const cameraSessionId = uuidv4();
+  const now = Math.floor(Date.now() / 1000);
+
+  const form = {
+    allow_multi_configures: '1',
+    recipient_users: '[]',
+    view_mode: viewMode,
+    is_shh_mode: '0',
+    camera_entry_point: '3',
+    thread_ids: JSON.stringify([String(threadId)]),
+    reshare_mode: 'allow_reshare',
+    original_media_type: '1',
+    send_attribution: 'direct_thread_camera',
+    client_context: clientContext,
+    camera_session_id: cameraSessionId,
+    include_e2ee_mentioned_user_list: '1',
+    hide_from_profile_grid: 'false',
+    scene_capture_type: '',
+    timezone_offset: String(new Date().getTimezoneOffset() * -60),
+    client_shared_at: String(now),
+    configure_mode: '2',
+    source_type: '4',
+    camera_position: 'unknown',
+    _uid: String(session.state.cookieUserId || session.state.igUserId),
+    device_id: session.state.deviceId,
+    composition_id: compositionId,
+    mutation_token: clientContext,
+    _uuid: session.state.uuid,
+    creation_tool_info: '[]',
+    creation_surface: 'camera',
+    capture_type: 'normal',
+    audience: 'default',
+    upload_id: serverUploadId,
+    client_timestamp: String(now),
+    sampled: 'true',
+    video_result: '',
+    media_type: '1',
+    media_transformation_info: JSON.stringify({
+      width: String(width), height: String(height),
+      x_transform: '0', y_transform: '0',
+      zoom: '1.0', rotation: '0.0', background_coverage: '0.0',
+    }),
+    extra: JSON.stringify({ source_width: width, source_height: height }),
+    device: JSON.stringify({
+      manufacturer: session.state.devicePayload?.manufacturer || 'samsung',
+      model: session.state.devicePayload?.model || 'SM-S938B',
+      android_version: session.state.devicePayload?.android_version || 35,
+      android_release: session.state.devicePayload?.android_release || '15',
+    }),
+  };
+
+  if (attachmentFbid) {
+    form.attachment_fbid = String(attachmentFbid);
+  }
+
+  const signedForm = (session.request && typeof session.request.sign === 'function')
+    ? session.request.sign(form)
+    : form;
+
+  const broadcastResponse = await session.request.send({
+    url: '/api/v1/direct_v2/threads/broadcast/raven_attachment/',
+    method: 'POST',
+    form: signedForm,
+    qs: { use_unified_inbox: true },
+  });
+
+  const body = broadcastResponse && (broadcastResponse.body || broadcastResponse.data || broadcastResponse);
+  return typeof body === 'string' ? JSON.parse(body) : body;
+}
+
+async function sendRavenVideoOnce(session, videoBuffer, options = {}) {
+  return sendRavenVideo(session, videoBuffer, { ...options, viewMode: 'once' });
+}
+
+async function sendRavenVideoReplayable(session, videoBuffer, options = {}) {
+  return sendRavenVideo(session, videoBuffer, { ...options, viewMode: 'replayable' });
+}
+
+module.exports = sendRavenVideo;
+module.exports.sendRavenVideo = sendRavenVideo;
+module.exports.sendRavenVideoOnce = sendRavenVideoOnce;
+module.exports.sendRavenVideoReplayable = sendRavenVideoReplayable;

package/dist/sendmedia/uploadPhoto.js

@@ -0,0 +1,107 @@
+/**
+ * uploadPhoto.js - FIXED version based on instagram-private-api
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * Validate buffer and mime type
+ */
+function validateImageInput(photoBuffer, mimeType) {
+  if (!photoBuffer || !Buffer.isBuffer(photoBuffer) || photoBuffer.length === 0) {
+    throw new Error('uploadPhoto: photoBuffer must be a non-empty Buffer.');
+  }
+  const allowed = ['image/jpeg', 'image/jpg', 'image/png'];
+  if (!allowed.includes(mimeType)) {
+    throw new Error(`uploadPhoto: mimeType must be one of ${allowed.join(', ')}.`);
+  }
+}
+
+/**
+ * Build Instagram rupload params for photo - Matching instagram-private-api
+ */
+function buildRuploadParams(uploadId, mimeType) {
+  const isJpeg = mimeType === 'image/jpeg' || mimeType === 'image/jpg';
+  const compression = isJpeg
+    ? JSON.stringify({ lib_name: 'moz', lib_version: '3.1.m', quality: '80' })
+    : JSON.stringify({ lib_name: 'png', lib_version: '1.0', quality: '100' });
+
+  return {
+    retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+    media_type: '1', // String '1' per instagram-private-api
+    upload_id: uploadId.toString(),
+    xsharing_user_ids: JSON.stringify([]),
+    image_compression: compression,
+  };
+}
+
+/**
+ * Upload a photo to Instagram's rupload endpoint.
+ */
+async function uploadPhoto(session, photoBuffer, options = {}) {
+  const {
+    mimeType = 'image/jpeg',
+    fileName,
+    signal,
+  } = options;
+
+  validateImageInput(photoBuffer, mimeType);
+
+  const uploadId = Date.now().toString();
+  const name = `${uploadId}_0_${Math.floor(Math.random() * (9999999999 - 1000000000) + 1000000000)}`;
+  const contentLength = photoBuffer.byteLength;
+  
+  const ruploadParams = buildRuploadParams(uploadId, mimeType);
+
+  // Headers expected by Instagram rupload (matched with instagram-private-api)
+  const headers = {
+    'X_FB_PHOTO_WATERFALL_ID': uuidv4(),
+    'X-Entity-Type': 'image/jpeg',
+    'Offset': '0',
+    'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+    'X-Entity-Name': name,
+    'X-Entity-Length': String(contentLength),
+    'Content-Type': 'application/octet-stream',
+    'Content-Length': String(contentLength),
+    'Accept-Encoding': 'gzip',
+  };
+
+  // If it's png, maybe we should adjust X-Entity-Type? 
+  // instagram-private-api seems to hardcode 'image/jpeg' in the trace for 'photo' method.
+  // We'll stick to 'image/jpeg' for X-Entity-Type as per reference unless user provided PNG which might work anyway.
+
+  const url = `/rupload_igphoto/${name}`;
+
+  try {
+    const response = await session.request.send({
+      url,
+      method: 'POST',
+      headers,
+      body: photoBuffer,
+      signal,
+    });
+
+    if (!response) {
+      throw new Error('uploadPhoto: Empty response from Instagram rupload endpoint.');
+    }
+
+    // Try to get upload_id from response
+    let serverUploadId = null;
+    if (typeof response === 'object' && response.body) {
+        try {
+            const body = typeof response.body === 'string' ? JSON.parse(response.body) : response.body;
+            serverUploadId = body.upload_id;
+        } catch (e) {
+            // ignore parse error
+        }
+    }
+
+    return serverUploadId || uploadId;
+  } catch (err) {
+    // If error, try to extract message
+    const msg = err.message || err.toString();
+    throw new Error(`uploadPhoto: Upload failed — ${msg}`);
+  }
+}
+
+module.exports = uploadPhoto;

package/dist/sendmedia/uploadfFile.js

@@ -0,0 +1,130 @@
+/**
+ * uploadfFile.js - FIXED version based on instagram-private-api
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+const DEFAULT_CHUNK_SIZE = 512 * 1024; // 512KB
+
+/**
+ * Validate upload input
+ */
+function validateFileInput(fileBuffer, mimeType) {
+  if (!fileBuffer || !Buffer.isBuffer(fileBuffer) || fileBuffer.length === 0) {
+    throw new Error('uploadFile: fileBuffer must be a non-empty Buffer.');
+  }
+  if (typeof mimeType !== 'string' || mimeType.length === 0) {
+    throw new Error('uploadFile: mimeType must be a non-empty string.');
+  }
+}
+
+/**
+ * Build rupload params - Matching instagram-private-api
+ */
+function buildRuploadParams(uploadId, mimeType, opts) {
+  const isVideo = mimeType.startsWith('video/');
+  const isAudio = mimeType.startsWith('audio/');
+  
+  const params = {
+    retry_context: JSON.stringify({ num_step_auto_retry: 0, num_reupload: 0, num_step_manual_retry: 0 }),
+    media_type: isVideo ? '2' : '3', // 2 for video, 3 for audio/others?
+    upload_id: uploadId.toString(),
+    xsharing_user_ids: JSON.stringify([]),
+  };
+
+  if (isVideo) {
+    params.upload_media_duration_ms = opts.duration?.toString() || '0';
+    params.upload_media_width = opts.width?.toString() || '720';
+    params.upload_media_height = opts.height?.toString() || '1280';
+    params.direct_v2 = '1';
+  }
+
+  return params;
+}
+
+/**
+ * Upload file via rupload with chunking.
+ */
+async function uploadFile(session, fileBuffer, options = {}) {
+  const {
+    mimeType = 'video/mp4',
+    fileName,
+    chunkSize = DEFAULT_CHUNK_SIZE,
+    signal,
+  } = options;
+
+  validateFileInput(fileBuffer, mimeType);
+
+  const uploadId = Date.now().toString();
+  const name = `${uploadId}_0_${Math.floor(Math.random() * 9000000000 + 1000000000)}`;
+  const totalLength = fileBuffer.length;
+  const waterfallId = uuidv4();
+
+  const ruploadParams = buildRuploadParams(uploadId, mimeType, options);
+  
+  const endpoint = mimeType.startsWith('image/')
+    ? `/rupload_igphoto/${name}`
+    : `/rupload_igvideo/${name}`;
+
+  // Start upload
+  let offset = 0;
+  const size = Math.max(64 * 1024, Math.min(4 * 1024 * 1024, chunkSize));
+
+  try {
+    while (offset < totalLength) {
+      const end = Math.min(offset + size, totalLength);
+      const chunk = fileBuffer.subarray(offset, end);
+
+      const headers = {
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+        'X-Entity-Type': mimeType,
+        'X-Entity-Name': name,
+        'X-Entity-Length': String(totalLength),
+        'Offset': String(offset),
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(chunk.length),
+        'Accept-Encoding': 'gzip',
+      };
+
+      const res = await session.request.send({
+        url: endpoint,
+        method: 'POST',
+        headers,
+        body: chunk,
+        signal,
+      });
+
+      if (!res) throw new Error(`uploadFile: Empty response at offset ${offset}`);
+      offset = end;
+    }
+
+    // Finalize
+    const confirm = await session.request.send({
+      url: endpoint,
+      method: 'POST',
+      headers: {
+        'X-Instagram-Rupload-Params': JSON.stringify(ruploadParams),
+        'X_FB_VIDEO_WATERFALL_ID': waterfallId,
+        'X-Entity-Type': mimeType,
+        'Offset': String(totalLength),
+        'Content-Length': '0',
+      },
+      signal,
+    });
+
+    let serverUploadId = null;
+    if (confirm && confirm.body) {
+        try {
+            const body = typeof confirm.body === 'string' ? JSON.parse(confirm.body) : confirm.body;
+            serverUploadId = body.upload_id;
+        } catch (e) {}
+    }
+
+    return serverUploadId || uploadId;
+  } catch (err) {
+    throw new Error(`uploadFile: Upload failed — ${err.message}`);
+  }
+}
+
+module.exports = uploadFile;

package/dist/services/live.service.js

@@ -0,0 +1,139 @@
+const Repository = require('../core/repository');
+
+class LiveService extends Repository {
+  async create(options = {}) {
+    const {
+      previewWidth = 720,
+      previewHeight = 1280,
+      broadcastMessage = '',
+    } = options;
+
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: '/api/v1/live/create/',
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        preview_width: previewWidth,
+        preview_height: previewHeight,
+        broadcast_message: broadcastMessage,
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async start(broadcastId, shouldSendNotifications = false) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/start/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        should_send_notifications: shouldSendNotifications ? '1' : '0',
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async end(broadcastId, endAfterCopyrightWarning = false) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/end_broadcast/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        end_after_copyright_warning: endAfterCopyrightWarning ? '1' : '0',
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async info(broadcastId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/live/${broadcastId}/info/`,
+    });
+    
+    return response.body;
+  }
+
+  async getViewerList(broadcastId) {
+    const response = await this.client.request.send({
+      method: 'GET',
+      url: `/api/v1/live/${broadcastId}/get_viewer_list/`,
+    });
+    
+    return response.body;
+  }
+
+  async comment(broadcastId, message) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/comment/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        user_breadcrumb: this.client.request.userBreadcrumb(message.length),
+        idempotence_token: Date.now(),
+        comment_text: message,
+        live_or_vod: '1',
+        offset: '0',
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async like(broadcastId, likeCount = 1) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/like/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        user_like_count: likeCount,
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async getHeartbeatAndViewerCount(broadcastId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/heartbeat_and_get_viewer_count/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        offset_to_video_start: '0',
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async muteComment(broadcastId, userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/mute_comment/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    
+    return response.body;
+  }
+
+  async unmuteComment(broadcastId, userId) {
+    const response = await this.client.request.send({
+      method: 'POST',
+      url: `/api/v1/live/${broadcastId}/unmute_comment/`,
+      form: this.client.request.sign({
+        _uuid: this.client.state.uuid,
+        user_id: userId,
+      }),
+    });
+    
+    return response.body;
+  }
+}
+
+module.exports = LiveService;