@armatofik/tgsnake-core 1.0.0

package/lib/src/file/Download.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDownload = handleDownload;
+exports.downloadStream = downloadStream;
+const File_js_1 = require("./File.js");
+const index_js_1 = require("../raw/index.js");
+const index_js_2 = require("../session/index.js");
+const helpers_js_1 = require("../helpers.js");
+const index_js_3 = require("../errors/index.js");
+const index_js_4 = require("../crypto/index.js");
+const platform_node_js_1 = require("../platform.node.js");
+async function handleDownload(client, file, location, dcId, limit, offset) {
+    const release = await client._getFileSemaphore.acquire();
+    let current = 0;
+    const total = Math.abs(limit) || (1 << 31) - 1;
+    const chunkSize = 1024 * 1024;
+    let offsetBytes = helpers_js_1.bigMath.abs(offset) * BigInt(1024);
+    const session = new index_js_2.Session(client, dcId, dcId !== client._storage.dcId
+        ? await new index_js_2.Auth(dcId, client._storage.testMode, client._ipv6).create()
+        : client._storage.authKey, client._storage.testMode, client._proxy, true);
+    try {
+        await session.start();
+        if (dcId !== client._storage.dcId) {
+            const exportedAuth = await client.invoke(new index_js_1.Raw.auth.ExportAuthorization({ dcId: dcId }));
+            await session.invoke(new index_js_1.Raw.auth.ImportAuthorization({
+                id: exportedAuth.id,
+                bytes: exportedAuth.bytes,
+            }));
+        }
+        let r = await session.invoke(new index_js_1.Raw.upload.GetFile({
+            location: location,
+            offset: offsetBytes,
+            limit: chunkSize,
+        }), session.MAX_RETRIES, session.WAIT_TIMEOUT, 30000);
+        if (r instanceof index_js_1.Raw.upload.File) {
+            while (true) {
+                const chunk = r.bytes;
+                file.push(chunk);
+                current++;
+                offsetBytes += BigInt(chunkSize);
+                if (platform_node_js_1.Buffer.byteLength(chunk) < chunkSize || current >= total) {
+                    break;
+                }
+                r = await session.invoke(new index_js_1.Raw.upload.GetFile({
+                    location: location,
+                    offset: offsetBytes,
+                    limit: chunkSize,
+                }), session.MAX_RETRIES, session.WAIT_TIMEOUT, 30000);
+            }
+        }
+        else if (r instanceof index_js_1.Raw.upload.FileCdnRedirect) {
+            const cdnSession = new index_js_2.Session(client, dcId, dcId !== client._storage.dcId
+                ? await new index_js_2.Auth(dcId, client._storage.testMode, client._ipv6).create()
+                : client._storage.authKey, client._storage.testMode, client._proxy, true, true);
+            try {
+                while (true) {
+                    const r2 = (await cdnSession.invoke(new index_js_1.Raw.upload.GetCdnFile({
+                        fileToken: r.fileToken,
+                        offset: offsetBytes,
+                        limit: chunkSize,
+                    }), session.MAX_RETRIES, session.WAIT_TIMEOUT, 30000));
+                    if (r2 instanceof index_js_1.Raw.upload.CdnFileReuploadNeeded) {
+                        try {
+                            await session.invoke(new index_js_1.Raw.upload.ReuploadCdnFile({
+                                fileToken: r.fileToken,
+                                requestToken: r2.requestToken,
+                            }));
+                        }
+                        catch (error) {
+                            if (error instanceof index_js_3.Exceptions.BadRequest.VolumeLocNotFound) {
+                                break;
+                            }
+                        }
+                    }
+                    const chunk = r2.bytes;
+                    const decryptedChunk = await index_js_4.AES.ctr256Cipher(r.encryptionKey, platform_node_js_1.Buffer.concat([
+                        r.encryptionIv.subarray(0, -4),
+                        (0, helpers_js_1.bigintToBuffer)(offsetBytes / BigInt(16), 4, false),
+                    ]))(chunk);
+                    const hashes = (await session.invoke(new index_js_1.Raw.upload.GetCdnFileHashes({
+                        fileToken: r.fileToken,
+                        offset: offsetBytes,
+                    })));
+                    for (let i = 0; i < hashes.length; i++) {
+                        const hash = hashes[i];
+                        const hashChunk = decryptedChunk.subarray(hash.limit * i, hash.limit * (i + 1));
+                        const chash = platform_node_js_1.crypto.createHash('sha256');
+                        chash.update(hashChunk);
+                        index_js_3.CDNFileHashMismatch.check(chash.digest('hex') === hash.hash.toString('hex'), `CDN file hash mismatch when downloading cdn file`);
+                    }
+                    current++;
+                    offsetBytes += BigInt(chunkSize);
+                    if (platform_node_js_1.Buffer.byteLength(chunk) < chunkSize || current >= total) {
+                        break;
+                    }
+                }
+            }
+            finally {
+                await cdnSession.stop();
+            }
+        }
+    }
+    finally {
+        await session.stop();
+        file.push(null);
+        if (platform_node_js_1.isDeno) {
+            release();
+        }
+        else {
+            release[1]();
+        }
+    }
+}
+function downloadStream(client, location, dcId, limit = 0, offset = BigInt(0)) {
+    const file = new File_js_1.File();
+    handleDownload(client, file, location, dcId, limit, offset);
+    return file;
+}

package/lib/src/file/File.d.ts

@@ -0,0 +1,20 @@
+import { Duplex, Buffer, type BufferEncoding } from '../platform.node.js';
+import { BytesIO } from '../raw/index.js';
+export type TypeFileChunk = Buffer | ArrayBufferView | DataView | string | null | any;
+export type TypeFileCallback = (error?: any) => void;
+export declare class File extends Duplex {
+    protected _bytes: BytesIO;
+    constructor();
+    _write(chunk: TypeFileChunk, encoding: BufferEncoding, next: TypeFileCallback): void;
+    _read(length?: number): Buffer | null;
+    push(chunk: TypeFileChunk, encoding?: BufferEncoding): boolean;
+    on(event: string, callback: TypeFileCallback): this;
+    pipe(destination: any, options?: {
+        end?: boolean;
+    }): any;
+    get bytes(): BytesIO;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}

package/lib/src/file/File.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_1 = require("../raw/index.js");
+class File extends platform_node_js_1.Duplex {
+    _bytes;
+    constructor() {
+        super({
+            readableHighWaterMark: 512 * 1024,
+            writableHighWaterMark: 512 * 1024,
+        });
+        this._bytes = new index_js_1.BytesIO();
+    }
+    _write(chunk, encoding, next) {
+        this._bytes.write(platform_node_js_1.Buffer.from(chunk, encoding));
+        return next();
+    }
+    _read(length) {
+        if (length) {
+            if (this._bytes.length > 0) {
+                const bytes = this._bytes.read(length);
+                if (platform_node_js_1.Buffer.byteLength(bytes) > 0) {
+                    return bytes;
+                }
+            }
+        }
+        else {
+            if (this._bytes.length > 0) {
+                return this._bytes.buffer;
+            }
+        }
+        return null;
+    }
+    push(chunk, encoding) {
+        return super.push(chunk, encoding);
+    }
+    on(event, callback) {
+        return super.on(event, callback);
+    }
+    pipe(destination, options) {
+        return super.pipe(destination, options);
+    }
+    get bytes() {
+        return this._bytes;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    [Symbol.for('Deno.customInspect')]() {
+        return String((0, platform_node_js_1.inspect)(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    toJSON() {
+        const toPrint = {
+            _: this.constructor.name,
+        };
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = typeof value === 'bigint' ? String(value) : value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.File = File;

package/lib/src/file/Upload.d.ts

@@ -0,0 +1,19 @@
+import { type Readable, Buffer } from '../platform.node.js';
+import { type Client } from '../client/Client.js';
+import { File } from './File.js';
+import { Raw } from '../raw/index.js';
+export type Progress = (current: number, total: number) => any;
+export interface SaveFileParams {
+    source: Buffer;
+    fileName?: string;
+    fileId?: bigint;
+    filePart?: number;
+    progress?: Progress;
+}
+export interface SaveFileStreamParams {
+    source: Readable | File;
+    fileName?: string;
+    progress?: Progress;
+}
+export declare function upload(client: Client, source: Buffer, fileName?: string, fileId?: bigint, filePart?: number, progress?: Progress): Promise<Raw.InputFile | Raw.InputFileBig | undefined>;
+export declare function uploadStream(client: Client, source: Readable | File, fileName?: string, progress?: Progress): Promise<Raw.InputFileBig | undefined>;

package/lib/src/file/Upload.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upload = upload;
+exports.uploadStream = uploadStream;
+const platform_node_js_1 = require("../platform.node.js");
+const Queue_js_1 = require("../Queue.js");
+const index_js_1 = require("../errors/index.js");
+const index_js_2 = require("../session/index.js");
+const index_js_3 = require("../raw/index.js");
+const Logger_js_1 = require("../Logger.js");
+async function upload(client, source, fileName, fileId, filePart = 0, progress) {
+    const release = await client._saveFileSemaphore.acquire();
+    try {
+        const queue = new Queue_js_1.Queue(1);
+        const partSize = 512 * 1024;
+        const user = client._me?.users.find((user) => user.id === client._me?.fullUser.id);
+        const premium = user && 'premium' in user ? user.premium : false;
+        const fileSizeLimitMiB = premium ? 4000 : 2000;
+        const fileSize = platform_node_js_1.Buffer.byteLength(source);
+        if (fileSize === 0) {
+            throw new index_js_1.FileErrors.FileUploadZero();
+        }
+        if (fileSize > fileSizeLimitMiB * 1024 * 1024) {
+            throw new index_js_1.FileErrors.FileUploadBigger(fileSizeLimitMiB * 1024 * 1024, fileSize);
+        }
+        const worker = async (session, index) => {
+            Logger_js_1.Logger.debug(`[142] Worker ${index} running`);
+            while (true) {
+                Logger_js_1.Logger.debug(`[143] Worker ${index} getting the queue`);
+                const data = await queue.get();
+                Logger_js_1.Logger.debug(`[144] Worker ${index} successfully getting the queue`);
+                if (data === null) {
+                    Logger_js_1.Logger.debug(`[145] Worker ${index} finished`);
+                    return;
+                }
+                if (data) {
+                    try {
+                        Logger_js_1.Logger.debug(`[146] Worker ${index} sending data from queue`);
+                        await session.invoke(data);
+                    }
+                    catch (error) {
+                        Logger_js_1.Logger.error(`[147] Error when uploading file:`, error);
+                    }
+                }
+            }
+        };
+        const fileTotalParts = Math.ceil(fileSize / partSize);
+        const isBig = fileSize > 10 * 1024 * 1024;
+        const workersAmount = isBig ? 4 : 1;
+        const isMissingPart = fileId !== undefined;
+        fileId = fileId || platform_node_js_1.Buffer.from(platform_node_js_1.crypto.randomBytes(8)).readBigInt64LE();
+        const file = new index_js_3.BytesIO(source);
+        const md5 = !isBig && !isMissingPart ? platform_node_js_1.crypto.createHash('md5').update(source).digest('hex') : '';
+        const session = new index_js_2.Session(client, client._storage.dcId, client._storage.authKey, client._storage.testMode, client._proxy, true);
+        const workers = Array(workersAmount)
+            .fill(null)
+            .map((_, i) => (() => worker(session, i + 1))());
+        try {
+            await session.start();
+            file.seek(partSize * filePart);
+            while (true) {
+                const chunk = file.read(partSize);
+                if (!platform_node_js_1.Buffer.byteLength(chunk)) {
+                    break;
+                }
+                if (isBig) {
+                    await queue.put(new index_js_3.Raw.upload.SaveBigFilePart({
+                        fileId: fileId,
+                        filePart: filePart,
+                        fileTotalParts: fileTotalParts,
+                        bytes: chunk,
+                    }));
+                }
+                else {
+                    await queue.put(new index_js_3.Raw.upload.SaveFilePart({
+                        fileId: fileId,
+                        filePart: filePart,
+                        bytes: chunk,
+                    }));
+                }
+                if (isMissingPart) {
+                    return;
+                }
+                filePart += 1;
+                if (progress) {
+                    progress(Math.min(filePart * partSize, fileSize), fileSize);
+                }
+            }
+            if (isBig) {
+                return new index_js_3.Raw.InputFileBig({
+                    id: fileId,
+                    parts: fileTotalParts,
+                    name: fileName ?? 'file.unknown',
+                });
+            }
+            else {
+                return new index_js_3.Raw.InputFile({
+                    id: fileId,
+                    parts: fileTotalParts,
+                    name: fileName ?? 'file.unknown',
+                    md5Checksum: md5,
+                });
+            }
+        }
+        catch (error) {
+            Logger_js_1.Logger.error('[141] Got error when trying to put rpc to queue', error);
+        }
+        finally {
+            for (let _ of workers) {
+                await queue.put(null);
+            }
+            await queue.put(null);
+            await queue.get();
+            await session.stop();
+        }
+    }
+    finally {
+        if (platform_node_js_1.isDeno) {
+            release();
+        }
+        else {
+            release[1]();
+        }
+    }
+}
+async function uploadStream(client, source, fileName, progress) {
+    if (!source.readable || !source._readableState) {
+        throw new index_js_1.FileErrors.FileIsNotReadable();
+    }
+    if (source.readableHighWaterMark !== 512 * 1024) {
+        source._readableState.highWaterMark = 512 * 1024;
+    }
+    const release = await client._saveFileSemaphore.acquire();
+    Logger_js_1.Logger.debug(`[148] Upload stream started.`);
+    try {
+        let resolve;
+        const partSize = 512 * 1024;
+        let filePart = 0;
+        let totalStreamSize = 0;
+        const fileId = platform_node_js_1.Buffer.from(platform_node_js_1.crypto.randomBytes(8)).readBigInt64LE();
+        let hasEndedBefore = false;
+        const queue = new Queue_js_1.Queue(1);
+        const waitUpload = new Promise((res) => {
+            resolve = res;
+        });
+        const user = client._me?.users.find((user) => user.id === client._me?.fullUser.id);
+        const premium = user && 'premium' in user ? true : false;
+        const fileSizeLimitMiB = premium ? 4000 : 2000;
+        const worker = async (session, index) => {
+            Logger_js_1.Logger.debug(`[149] Worker ${index} running`);
+            while (true) {
+                Logger_js_1.Logger.debug(`[150] Worker ${index} getting the queue`);
+                const data = await queue.get();
+                Logger_js_1.Logger.debug(`[151] Worker ${index} successfully getting the queue`);
+                if (data === null) {
+                    Logger_js_1.Logger.debug(`[152] Worker ${index} finished`);
+                    return;
+                }
+                if (data) {
+                    try {
+                        Logger_js_1.Logger.debug(`[153] Worker ${index} sending data from queue`);
+                        await session.invoke(data);
+                    }
+                    catch (error) {
+                        Logger_js_1.Logger.error(`[154] Error when uploading file:`, error);
+                    }
+                }
+            }
+        };
+        const session = new index_js_2.Session(client, client._storage.dcId, client._storage.authKey, client._storage.testMode, client._proxy, true);
+        const workers = Array(4)
+            .fill(null)
+            .map((_, i) => (() => worker(session, i + 1))());
+        try {
+            await session.start();
+            const uploader = new platform_node_js_1.Writable({
+                highWaterMark: 512 * 1024,
+                async write(chunk, encoding, callback) {
+                    totalStreamSize += platform_node_js_1.Buffer.byteLength(chunk);
+                    if (totalStreamSize > fileSizeLimitMiB * 1024 * 1024) {
+                        throw new index_js_1.FileErrors.FileUploadBigger(fileSizeLimitMiB * 1024 * 1024, totalStreamSize);
+                    }
+                    if (platform_node_js_1.Buffer.byteLength(chunk) < 512 * 1024) {
+                        hasEndedBefore = true;
+                        await queue.put(new index_js_3.Raw.upload.SaveBigFilePart({
+                            fileId: fileId,
+                            filePart: filePart,
+                            fileTotalParts: Math.ceil(totalStreamSize / partSize),
+                            bytes: platform_node_js_1.Buffer.from(chunk, encoding),
+                        }));
+                    }
+                    else {
+                        await queue.put(new index_js_3.Raw.upload.SaveBigFilePart({
+                            fileId: fileId,
+                            filePart: filePart,
+                            fileTotalParts: -1,
+                            bytes: platform_node_js_1.Buffer.from(chunk, encoding),
+                        }));
+                    }
+                    filePart += 1;
+                    if (progress) {
+                        progress(filePart * partSize, -1);
+                    }
+                    return callback();
+                },
+            });
+            uploader.on('finish', async () => {
+                if (!hasEndedBefore) {
+                    hasEndedBefore = true;
+                    await queue.put(new index_js_3.Raw.upload.SaveBigFilePart({
+                        fileId: fileId,
+                        filePart: filePart,
+                        fileTotalParts: Math.ceil(totalStreamSize / partSize),
+                        bytes: platform_node_js_1.Buffer.alloc(0),
+                    }));
+                }
+                if (progress) {
+                    progress(filePart * partSize, totalStreamSize);
+                }
+                resolve(true);
+            });
+            source.pipe(uploader);
+            await waitUpload;
+            return new index_js_3.Raw.InputFileBig({
+                id: fileId,
+                parts: Math.ceil(totalStreamSize / partSize),
+                name: fileName ?? 'file.unknown',
+            });
+        }
+        catch (error) {
+            Logger_js_1.Logger.error('[155] Got error when trying to put rpc to queue', error);
+        }
+        finally {
+            for (let _ of workers) {
+                await queue.put(null);
+            }
+            await queue.put(null);
+            await queue.get();
+            await session.stop();
+        }
+    }
+    finally {
+        if (platform_node_js_1.isDeno) {
+            release();
+        }
+        else {
+            release[1]();
+        }
+    }
+}

package/lib/src/file/index.d.ts

@@ -0,0 +1,3 @@
+export { File } from './File.js';
+export { upload, uploadStream, type Progress, type SaveFileParams, type SaveFileStreamParams, } from './Upload.js';
+export { handleDownload, downloadStream, type DownloadParam } from './Download.js';

package/lib/src/file/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadStream = exports.handleDownload = exports.uploadStream = exports.upload = exports.File = void 0;
+var File_js_1 = require("./File.js");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return File_js_1.File; } });
+var Upload_js_1 = require("./Upload.js");
+Object.defineProperty(exports, "upload", { enumerable: true, get: function () { return Upload_js_1.upload; } });
+Object.defineProperty(exports, "uploadStream", { enumerable: true, get: function () { return Upload_js_1.uploadStream; } });
+var Download_js_1 = require("./Download.js");
+Object.defineProperty(exports, "handleDownload", { enumerable: true, get: function () { return Download_js_1.handleDownload; } });
+Object.defineProperty(exports, "downloadStream", { enumerable: true, get: function () { return Download_js_1.downloadStream; } });

package/lib/src/helpers.d.ts

@@ -0,0 +1,34 @@
+import { Buffer } from './platform.node.js';
+export declare function bigintToBuffer(int: bigint, padding: number, litte?: boolean, signed?: boolean): Buffer<ArrayBuffer>;
+export declare function includesBuffer(array: Array<Buffer>, buffer: Buffer): boolean;
+export declare function sliceBuffer(buffer: Buffer, start: number, stop: number, step?: number): Buffer<ArrayBufferLike>;
+export declare function makeCRCTable(): any[];
+export declare function crc32(str: Buffer | string): number;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function bufferToBigint(buffer: Buffer, little?: boolean, signed?: boolean): bigint;
+export declare function mod(n: number, m: number): number;
+export declare function bigIntMod(n: bigint, m: bigint): bigint;
+export declare function range(start: number, stop: number, step?: number): Array<number>;
+export declare function rangeBigint(start: bigint, stop: bigint, step?: number): Array<bigint>;
+export declare function randint(min: number, max: number): number;
+export declare function randBigint(min: bigint, max: bigint): any;
+export declare function pow(x: number, y: number, z?: number): number;
+export declare function bigIntPow(x: bigint, y: bigint, z?: bigint): bigint;
+declare const bigMath: {
+    abs(x: bigint): bigint;
+    sign(x: bigint): bigint;
+    pow(base: bigint, exponent: bigint): bigint;
+    min(value: bigint, ...values: Array<bigint>): bigint;
+    max(value: bigint, ...values: Array<bigint>): bigint;
+};
+export { bigMath };
+export declare const MIN_CHANNEL_ID: bigint;
+export declare const MAX_CHANNEL_ID: bigint;
+export declare const MIN_CHAT_ID: bigint;
+export declare const MAX_USER_ID_OLD: bigint;
+export declare const MAX_USER_ID: bigint;
+export declare function getChannelId(id: bigint): bigint;
+export declare function getPeerType(id: bigint): "chat" | "channel" | "user" | undefined;
+export declare function base64urlTobase64(text: string): string;
+export declare function generateRandomBigInt(lowBigInt: bigint, highBigInt: bigint): bigint;
+export declare function normalizeSecretString(secret: string): Buffer<ArrayBuffer>;