fix: Add support for sending large files (up to 2GB)

index.d.ts

@@ -160,6 +160,9 @@ declare namespace WAWebJS {
         /** Deletes the current user's profile picture */
         deleteProfilePicture(): Promise<boolean>
 
+        /** Gets the maximum file size for a given media type*/
+        getUploadLimits(mediaType: string): Promise<string>
+
         /** Generic event */
         on(event: string, listener: (...args: any) => void): this
 

src/Client.js

@@ -813,7 +813,7 @@ class Client extends EventEmitter {
         if (options.mentions && options.mentions.some(possiblyContact => possiblyContact instanceof Contact)) {
             console.warn('Mentions with an array of Contact are now deprecated. See more at https://github.com/pedroslopez/whatsapp-web.js/pull/2166.');
             options.mentions = options.mentions.map(a => a.id._serialized);
-        }
+        }     
         let internalOptions = {
             linkPreview: options.linkPreview === false ? undefined : true,
             sendAudioAsVoice: options.sendAudioAsVoice,
@@ -827,8 +827,10 @@ class Client extends EventEmitter {
             extraOptions: options.extra
         };
 
+
         const sendSeen = typeof options.sendSeen === 'undefined' ? true : options.sendSeen;
 
+
         if (content instanceof MessageMedia) {
             internalOptions.attachment = content;
             internalOptions.isViewOnce = options.isViewOnce,
@@ -855,7 +857,7 @@ class Client extends EventEmitter {
             internalOptions.list = content;
             content = '';
         }
-
+        
         if (internalOptions.sendMediaAsSticker && internalOptions.attachment) {
             internalOptions.attachment = await Util.formatToWebpSticker(
                 internalOptions.attachment, {
@@ -866,21 +868,62 @@ class Client extends EventEmitter {
             );
         }
 
+
+        if (internalOptions.attachment?.data?.length > (1024 * 1024 * 79)) {
+            let startDivision = 2;
+            let middle = internalOptions.attachment.data.length / startDivision;
+            let currentIndex = 0;
+
+
+            while (middle > (1024 * 1024 * 50)){
+                startDivision += 1;
+                middle = Math.floor(internalOptions.attachment.data.length / startDivision);
+            }
+
+            const randomId = Util.generateHash(32);
+
+            while(currentIndex < internalOptions.attachment.data.length){
+                let chunkPiece = middle;
+                if(currentIndex + middle > internalOptions.attachment.data.length){
+                    chunkPiece = internalOptions.attachment.data.length - currentIndex;
+                }
+                await this.pupPage.evaluate(async (chatId, chunk, randomId) => {
+                    if (chunk && window[`mediaChunk_${randomId}`]) {
+                        window[`mediaChunk_${randomId}`] += chunk;
+                    }
+                    else {
+                        window[`mediaChunk_${randomId}`] = chunk;
+                    }
+                }, chatId, internalOptions.attachment.data.substring(currentIndex, currentIndex+chunkPiece), randomId);
+                currentIndex += chunkPiece;
+
+            }
+
+            internalOptions.attachment = new MessageMedia(internalOptions.attachment.mimetype,`mediaChunk_${randomId}`, internalOptions.attachment.filename,internalOptions.attachment.filesize);
+        }
+
         const newMessage = await this.pupPage.evaluate(async (chatId, message, options, sendSeen) => {
             const chatWid = window.Store.WidFactory.createWid(chatId);
             const chat = await window.Store.Chat.find(chatWid);
 
 
+
             if (sendSeen) {
                 window.WWebJS.sendSeen(chatId);
             }
 
+            if(options?.attachment?.data?.startsWith('mediaChunk')) {
+                options.attachment.data = window[options.attachment.data];
+                delete window[options.attachment.data];
+            }
+
             const msg = await window.WWebJS.sendMessage(chat, message, options, sendSeen);
             return msg.serialize();
         }, chatId, content, internalOptions, sendSeen);
 
+
         return new Message(this, newMessage);
-    }
+    } 
 
     /**
      * Searches for messages
@@ -1434,6 +1477,19 @@ class Client extends EventEmitter {
             return await window.Store.Label.addOrRemoveLabels(actions, chats);
         }, labelIds, chatIds);
     }
+
+    /***
+    * Returns the maximum file size for the given MessageType
+    * @param {string} messageType (valid values are = 'audio', 'document', 'video', 'sticker')
+    * @returns {Promise<string>}
+    */
+    async getUploadLimits(messageType) {
+        const uploadLimit = await this.pupPage.evaluate(async (messageType) => {
+            return await window.WWebJS.getUploadLimits(messageType);
+        }, messageType);
+
+        return uploadLimit;
+    }
 }
 
 module.exports = Client;

src/structures/MessageMedia.js

@@ -49,8 +49,9 @@ class MessageMedia {
         const b64data = fs.readFileSync(filePath, {encoding: 'base64'});
         const mimetype = mime.getType(filePath); 
         const filename = path.basename(filePath);
+        const fileSize = fs.statSync(filePath).size;
 
-        return new MessageMedia(mimetype, b64data, filename);
+        return new MessageMedia(mimetype, b64data, filename, fileSize);
     }
 
     /**

src/util/Injected.js

@@ -37,6 +37,7 @@ exports.ExposeStore = (moduleRaidStr) => {
     window.Store.ContactMethods = window.mR.findModule('getUserid')[0];
     window.Store.BusinessProfileCollection = window.mR.findModule('BusinessProfileCollection')[0].BusinessProfileCollection;
     window.Store.UploadUtils = window.mR.findModule((module) => (module.default && module.default.encryptAndUpload) ? module.default : null)[0].default;
+    window.Store.UploadLimits = window.mR.findModule('getUploadLimit')[0].getUploadLimit;
     window.Store.UserConstructor = window.mR.findModule((module) => (module.default && module.default.prototype && module.default.prototype.isServer && module.default.prototype.isUser) ? module.default : null)[0].default;
     window.Store.Validators = window.mR.findModule('findLinks')[0];
     window.Store.VCard = window.mR.findModule('vcardFromContactModel')[0];
@@ -118,6 +119,11 @@ exports.LoadUtils = () => {
 
     };
 
+    window.WWebJS.getUploadLimits = async (mediaType) => {
+        const uploadLimit = window.Store.UploadLimits(mediaType);
+        return uploadLimit;
+    };
+
     window.WWebJS.sendMessage = async (chat, content, options = {}) => {
         let attOptions = {};
         if (options.attachment) {
@@ -126,7 +132,8 @@ exports.LoadUtils = () => {
                 : await window.WWebJS.processMediaData(options.attachment, {
                     forceVoice: options.sendAudioAsVoice,
                     forceDocument: options.sendMediaAsDocument,
-                    forceGif: options.sendVideoAsGif
+                    forceGif: options.sendVideoAsGif,
+                    isViewOnce: options.isViewOnce
                 });
 
             if (options.caption){
@@ -376,13 +383,16 @@ exports.LoadUtils = () => {
         return stickerInfo;
     };
 
-    window.WWebJS.processMediaData = async (mediaInfo, { forceVoice, forceDocument, forceGif }) => {
+    window.WWebJS.processMediaData = async (mediaInfo, { forceVoice, forceDocument, forceGif, isViewOnce }) => {
         const file = window.WWebJS.mediaInfoToFile(mediaInfo);
         const mData = await window.Store.OpaqueData.createFromData(file, file.type);
         const mediaPrep = window.Store.MediaPrep.prepRawMedia(mData, { asDocument: forceDocument });
         const mediaData = await mediaPrep.waitForPrep();
-        const mediaObject = window.Store.MediaObject.getOrCreateMediaObject(mediaData.filehash);
-
+        const mediaObject = window.Store.MediaObject.getOrCreateMediaObject(mediaData.filehash);       
+        const uploadOrigin = 2;
+        const forwardedFromWeb = false;
+        const maxFileSize = window.Store.UploadLimits(mediaData.type);
+
         const mediaType = window.Store.MediaTypes.msgToMediaType({
             type: mediaData.type,
             isGif: mediaData.isGif
@@ -403,23 +413,45 @@ exports.LoadUtils = () => {
             mediaData.type = 'document';
         }
 
+        if(mediaInfo.filesize && maxFileSize > mediaInfo.file){
+            throw new Error(`Media size ({$mediaInfo.filesize}) exceeds current upload limit ({$maxFileSize})`);
+        }
+
         if (!(mediaData.mediaBlob instanceof window.Store.OpaqueData)) {
             mediaData.mediaBlob = await window.Store.OpaqueData.createFromData(mediaData.mediaBlob, mediaData.mediaBlob.type);
         }
 
         mediaData.renderableUrl = mediaData.mediaBlob.url();
         mediaObject.consolidate(mediaData.toJSON());
         mediaData.mediaBlob.autorelease();
-
-        const uploadedMedia = await window.Store.MediaUpload.uploadMedia({
+        let mediaKeyInfoKey = await window.WWebJS.generateHash(32);
+        const mediaKeyInfoTimestamp = Date.now();
+
+        let uploadedMedia = await window.Store.MediaUpload.uploadMedia({
             mimetype: mediaData.mimetype,
             mediaObject,
-            mediaType
+            mediaType,
+            isViewOnce: isViewOnce,
+            uploadOrigin: uploadOrigin,
+            forwardedFromWeb: forwardedFromWeb,
+            mediaKeyInfo: { key: mediaKeyInfoKey, timestamp: mediaKeyInfoTimestamp }
         });
 
-        const mediaEntry = uploadedMedia.mediaEntry;
+        let mediaEntry = uploadedMedia.mediaEntry;
         if (!mediaEntry) {
-            throw new Error('upload failed: media entry was not created');
+            uploadedMedia = await window.Store.MediaUpload.uploadMedia({
+                mimetype: mediaData.mimetype,
+                mediaObject,
+                mediaType,
+                isViewOnce: isViewOnce,
+                uploadOrigin: uploadOrigin,
+                forwardedFromWeb: forwardedFromWeb
+            });
+
+            mediaEntry = uploadedMedia.mediaEntry;
+            if(!mediaEntry){
+                throw new Error('upload failed: media entry was not created');
+            }
         }
 
         mediaData.set({