@armatofik/tgsnake-core 1.0.0

package/lib/src/storage/SecretChat.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretChat = void 0;
+const platform_node_js_1 = require("../platform.node.js");
+const index_js_1 = require("../raw/index.js");
+class SecretChat {
+    id;
+    accessHash;
+    rekeyStep;
+    rekeyExchange;
+    created;
+    changed;
+    isAdmin;
+    authKey;
+    mtproto;
+    layer;
+    inSeqNo;
+    outSeqNo;
+    inSeqNoX;
+    outSeqNoX;
+    adminId;
+    timeRekey;
+    ttl;
+    _mutex;
+    constructor({ id, accessHash, isAdmin, authKey, }) {
+        this.id = id;
+        this.accessHash = accessHash;
+        this.isAdmin = isAdmin;
+        this.authKey = platform_node_js_1.Buffer.from(authKey);
+        this.created = Date.now() / 1000;
+        this.changed = 0;
+        this.mtproto = 2;
+        this.layer = index_js_1.Raw.Layer;
+        this.ttl = 0;
+        this.timeRekey = 100;
+        this.outSeqNoX = isAdmin ? 1 : 0;
+        this.inSeqNoX = isAdmin ? 0 : 1;
+        this._mutex = new platform_node_js_1.Mutex();
+    }
+    async update(storage) {
+        const release = await this._mutex.acquire();
+        try {
+            storage.updateSecretChats([this]);
+        }
+        finally {
+            release();
+        }
+        return true;
+    }
+    static save(storage, params) {
+        const tempChat = new SecretChat(params);
+        storage.updateSecretChats([tempChat]);
+        return tempChat;
+    }
+    static async remove(storage, id) {
+        return await storage.removeSecretChatById(id);
+    }
+    get input() {
+        return new index_js_1.Raw.InputEncryptedChat({
+            chatId: this.id,
+            accessHash: this.accessHash,
+        });
+    }
+    [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.SecretChat = SecretChat;

package/lib/src/storage/Session.d.ts

@@ -0,0 +1,63 @@
+import { AbstractSession } from './Abstract.js';
+import { Raw } from '../raw/index.js';
+import { Buffer } from '../platform.node.js';
+import type { SecretChat } from './SecretChat.js';
+export declare function getInputPeer(id: bigint, accessHash: bigint, type: string): Raw.InputPeerUser | Raw.InputPeerChat | Raw.InputPeerChannel;
+export declare class BaseSession extends AbstractSession {
+    protected _ip: string;
+    protected _dcId: number;
+    protected _port: number;
+    protected _peers: Map<bigint, [
+        id: bigint,
+        accessHash: bigint,
+        type: string,
+        username?: Array<string>,
+        phoneNumber?: string
+    ]>;
+    protected _secretChats: Map<number, SecretChat>;
+    protected _authKey: Buffer;
+    protected _testMode: boolean;
+    protected _apiId: number;
+    protected _userId: bigint;
+    protected _isBot: boolean;
+    constructor();
+    setAddress(dcId: number, ip: string, port: number, testMode: boolean): void;
+    setAuthKey(authKey: Buffer, dcId: number): void;
+    setApiId(apiId: number): void;
+    setIsBot(isbot: boolean): void;
+    setUserId(userId: bigint): void;
+    get authKey(): Buffer<ArrayBufferLike>;
+    get isBot(): boolean;
+    get testMode(): boolean;
+    get userId(): bigint;
+    get apiId(): number;
+    get dcId(): number;
+    get port(): number;
+    get ip(): string;
+    get peers(): Map<bigint, [id: bigint, accessHash: bigint, type: string, username?: string[] | undefined, phoneNumber?: string | undefined]>;
+    get secretChats(): Map<number, SecretChat>;
+    load(): Promise<void>;
+    delete(): Promise<void>;
+    save(): Promise<void>;
+    updatePts(_pts: number, _date: number): Promise<void>;
+    getPts(): Promise<[pts: number, date: number]>;
+    move(session: AbstractSession): Promise<void>;
+    updatePeers(peers: Array<[
+        id: bigint,
+        accessHash: bigint,
+        type: string,
+        username?: Array<string>,
+        phoneNumber?: string
+    ]>): Promise<void>;
+    updateSecretChats(chats: Array<SecretChat>): Promise<void>;
+    getSecretChatById(id: number): Promise<SecretChat | undefined>;
+    getPeerById(id: bigint): Promise<Raw.InputPeerUser | Raw.InputPeerChat | Raw.InputPeerChannel | undefined>;
+    getPeerByUsername(username: string): Promise<Raw.InputPeerUser | Raw.InputPeerChat | Raw.InputPeerChannel | undefined>;
+    getPeerByPhoneNumber(phoneNumber: string): Promise<Raw.InputPeerUser | Raw.InputPeerChat | Raw.InputPeerChannel | undefined>;
+    removeSecretChatById(id: number): Promise<boolean>;
+    exportString(): string;
+    toJSON(): {
+        [key: string]: any;
+    };
+    toString(): string;
+}

package/lib/src/storage/Session.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSession = void 0;
+exports.getInputPeer = getInputPeer;
+const Logger_js_1 = require("../Logger.js");
+const Abstract_js_1 = require("./Abstract.js");
+const index_js_1 = require("../raw/index.js");
+const helpers_js_1 = require("../helpers.js");
+const platform_node_js_1 = require("../platform.node.js");
+function getInputPeer(id, accessHash, type) {
+    if (type === 'bot' || type === 'user') {
+        return new index_js_1.Raw.InputPeerUser({
+            userId: id,
+            accessHash: accessHash,
+        });
+    }
+    else if (type === 'group') {
+        return new index_js_1.Raw.InputPeerChat({
+            chatId: -id,
+        });
+    }
+    else if (type === 'channel' || type === 'supergroup') {
+        return new index_js_1.Raw.InputPeerChannel({
+            channelId: (0, helpers_js_1.getChannelId)(id),
+            accessHash: accessHash,
+        });
+    }
+    else {
+        throw new Error(`Invalid peer type: ${type}`);
+    }
+}
+class BaseSession extends Abstract_js_1.AbstractSession {
+    _ip;
+    _dcId = 2;
+    _port;
+    _peers = new Map();
+    _secretChats = new Map();
+    _authKey;
+    _testMode = false;
+    _apiId;
+    _userId;
+    _isBot;
+    constructor() {
+        super();
+    }
+    setAddress(dcId, ip, port, testMode) {
+        this._dcId = dcId ?? 2;
+        this._ip = ip;
+        this._port = port ?? 443;
+        this._testMode = testMode;
+    }
+    setAuthKey(authKey, dcId) {
+        if (dcId !== this._dcId)
+            return;
+        this._authKey = authKey;
+    }
+    setApiId(apiId) {
+        this._apiId = apiId;
+    }
+    setIsBot(isbot) {
+        this._isBot = isbot;
+    }
+    setUserId(userId) {
+        this._userId = userId;
+    }
+    get authKey() {
+        return this._authKey;
+    }
+    get isBot() {
+        return this._isBot;
+    }
+    get testMode() {
+        return this._testMode;
+    }
+    get userId() {
+        return this._userId;
+    }
+    get apiId() {
+        return this._apiId;
+    }
+    get dcId() {
+        return this._dcId;
+    }
+    get port() {
+        return this._port;
+    }
+    get ip() {
+        return this._ip;
+    }
+    get peers() {
+        return this._peers;
+    }
+    get secretChats() {
+        return this._secretChats;
+    }
+    async load() { }
+    async delete() { }
+    async save() { }
+    async updatePts(_pts, _date) { }
+    async getPts() {
+        const res = [0, 0];
+        return res;
+    }
+    async move(session) {
+        Logger_js_1.Logger.info(`[73] Moving session from ${this.constructor.name} to ${session.constructor.name}.`);
+        await session.setAddress(this._dcId, this._ip, this._port, this._testMode);
+        await session.setAuthKey(this._authKey, this._dcId);
+        await session.setApiId(this._apiId);
+        await session.setIsBot(this._isBot);
+        await session.setUserId(this._userId);
+        Logger_js_1.Logger.info(`[74] Successfully move session from ${this.constructor.name} to ${session.constructor.name}.`);
+        Logger_js_1.Logger.debug(`[75] Deleting current session, cause: moved to another instance (${session.constructor.name}).`);
+        await this.delete();
+    }
+    async updatePeers(peers) {
+        Logger_js_1.Logger.debug(`[76] Updating ${peers.length} peers`);
+        for (let peer of peers) {
+            this._peers.set(peer[0], peer);
+        }
+    }
+    async updateSecretChats(chats) {
+        Logger_js_1.Logger.debug(`[109] Updating ${chats.length} secret chats`);
+        for (let chat of chats) {
+            this._secretChats.set(chat.id, chat);
+        }
+    }
+    async getSecretChatById(id) {
+        Logger_js_1.Logger.debug(`[110] Getting secret chat by id: ${id}`);
+        let chat = this._secretChats.get(id);
+        if (chat) {
+            return chat;
+        }
+    }
+    async getPeerById(id) {
+        Logger_js_1.Logger.debug(`[77] Getting peer by id: ${id}`);
+        let peer = this._peers.get(id);
+        if (peer) {
+            return getInputPeer(peer[0], peer[1], peer[2]);
+        }
+    }
+    async getPeerByUsername(username) {
+        Logger_js_1.Logger.debug(`[78] Getting peer by username: ${username}`);
+        for (let [, peer] of this._peers) {
+            if (peer[3]) {
+                if (Array.isArray(peer[3]) && peer[3].includes(username.toLowerCase())) {
+                    return getInputPeer(peer[0], peer[1], peer[2]);
+                }
+            }
+        }
+    }
+    async getPeerByPhoneNumber(phoneNumber) {
+        Logger_js_1.Logger.debug(`[79] Getting peer by phone number: ${phoneNumber}`);
+        for (let [, peer] of this._peers) {
+            if (peer[4] && peer[4] === phoneNumber) {
+                return getInputPeer(peer[0], peer[1], peer[2]);
+            }
+        }
+    }
+    async removeSecretChatById(id) {
+        if (this._secretChats.has(id)) {
+            this._secretChats.delete(id);
+        }
+        return true;
+    }
+    exportString() {
+        let bytes = platform_node_js_1.Buffer.alloc(6);
+        bytes.writeUInt8(this._dcId, 0);
+        bytes.writeUInt32LE(this._apiId, 1);
+        bytes.writeUInt8(this._testMode ? 1 : 0, 5);
+        bytes = platform_node_js_1.Buffer.concat([bytes, this._authKey]);
+        bytes = platform_node_js_1.Buffer.concat([
+            bytes,
+            packLong(this._userId),
+        ]);
+        bytes = platform_node_js_1.Buffer.concat([
+            bytes,
+            platform_node_js_1.Buffer.alloc(1),
+        ]);
+        bytes.writeUInt8(this._isBot ? 1 : 0, 270);
+        Logger_js_1.Logger.debug(`[80] Exporting ${platform_node_js_1.Buffer.byteLength(bytes)} bytes of session`);
+        try {
+            return bytes.toString('base64url').replace(/=+$/g, '');
+        }
+        catch (_error) {
+            return bytes.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+        }
+    }
+    [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) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    toString() {
+        return `[constructor of ${this.constructor.name}] ${JSON.stringify(this, null, 2)}`;
+    }
+}
+exports.BaseSession = BaseSession;
+function packLong(long, little = true, signed = false) {
+    const bytes = platform_node_js_1.Buffer.alloc(8);
+    const shift = BigInt((1 << 16) * (1 << 16));
+    if (signed) {
+        bytes.writeInt32LE(Number(String(long % shift)), 0);
+        bytes.writeInt32LE(Number(String(long / shift)), 4);
+        return little ? bytes.reverse() : bytes;
+    }
+    else {
+        bytes.writeUInt32LE(Number(String(long % shift)), 0);
+        bytes.writeUInt32LE(Number(String(long / shift)), 4);
+        return little ? bytes.reverse() : bytes;
+    }
+}

package/lib/src/storage/StringSession.d.ts

@@ -0,0 +1,4 @@
+import { BaseSession } from './Session.js';
+export declare class StringSession extends BaseSession {
+    constructor(session: string);
+}

package/lib/src/storage/StringSession.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringSession = void 0;
+const Logger_js_1 = require("../Logger.js");
+const Session_js_1 = require("./Session.js");
+const index_js_1 = require("../raw/index.js");
+const helpers_js_1 = require("../helpers.js");
+const platform_node_js_1 = require("../platform.node.js");
+class StringSession extends Session_js_1.BaseSession {
+    constructor(session) {
+        super();
+        if (session.length) {
+            Logger_js_1.Logger.debug(`[81] Starting parsing string session, length is: ${session.length}`);
+            const start = Math.floor(Date.now() / 1000);
+            if (session[0] === '1') {
+                Logger_js_1.Logger.debug(`[82] The string session look like telethon or gramjs string session, start parsing.`);
+                session = session.slice(1);
+                const bytes = new index_js_1.BytesIO(platform_node_js_1.Buffer.from((0, helpers_js_1.base64urlTobase64)(session), 'base64'));
+                this._dcId = bytes.read(1).readUInt8();
+                Logger_js_1.Logger.debug(`[84] Found dcId: ${this._dcId}.`);
+                if (session.length === 352) {
+                    const ipv4 = bytes.read(4);
+                    this._ip = `${ipv4[0]}.${ipv4[1]}.${ipv4[2]}.${ipv4[3]}`;
+                    Logger_js_1.Logger.debug(`[85] Found ip: ${this._ip}.`);
+                }
+                else {
+                    const serverAddressLen = bytes.read(2).readInt16BE();
+                    if (serverAddressLen > 1000) {
+                        bytes.seek(-2, 1);
+                        this._ip = bytes
+                            .read(16)
+                            .toString('hex')
+                            .match(/.{1,4}/g)
+                            .map((val) => val.replace(/^0+/, ''))
+                            .join(':')
+                            .replace(/0000\:/g, ':')
+                            .replace(/:{2,}/g, '::');
+                        Logger_js_1.Logger.debug(`[86] Found ip: ${this._ip}.`);
+                    }
+                    else {
+                        this._ip = bytes.read(serverAddressLen).toString();
+                        Logger_js_1.Logger.debug(`[87] Found ip: ${this._ip}.`);
+                    }
+                }
+                this._port = bytes.read(2).readInt16BE();
+                Logger_js_1.Logger.debug(`[88] Found port: ${this._port}.`);
+                this._authKey = bytes.read();
+                Logger_js_1.Logger.debug(`[89] Found authKey: ${platform_node_js_1.Buffer.byteLength(this._authKey)} bytes.`);
+            }
+            else {
+                const bytes = platform_node_js_1.Buffer.from((0, helpers_js_1.base64urlTobase64)(session), 'base64');
+                if (platform_node_js_1.Buffer.byteLength(bytes) === 271) {
+                    Logger_js_1.Logger.debug(`[90] The string session look like pyrogram or tgsnake string session, start parsing.`);
+                    Logger_js_1.Logger.debug(`[91] String session have a ${platform_node_js_1.Buffer.byteLength(bytes)} bytes`);
+                    this._dcId = bytes.readUInt8(0);
+                    Logger_js_1.Logger.debug(`[92] Found dcId: ${this._dcId}.`);
+                    this._apiId = bytes.readUInt32LE(1);
+                    Logger_js_1.Logger.debug(`[93] Found apiId: ${this._apiId}.`);
+                    this._testMode = bytes.readUInt8(5) ? true : false;
+                    Logger_js_1.Logger.debug(`[94] Found testMode: ${this._testMode}.`);
+                    this._authKey = bytes.subarray(6, 262);
+                    Logger_js_1.Logger.debug(`[95] Found authKey: ${platform_node_js_1.Buffer.byteLength(this._authKey)} bytes.`);
+                    this._userId = BigInt(`0x${bytes.subarray(262, 270).toString('hex')}`);
+                    Logger_js_1.Logger.debug(`[96] Found userId: ${this._userId}.`);
+                    this._isBot = bytes.readUInt8(270) ? true : false;
+                    Logger_js_1.Logger.debug(`[97] Found isBot: ${this._isBot}.`);
+                    Logger_js_1.Logger.debug(`[98] Done parsing string session (${Math.floor(Date.now() / 1000) - start}s)`);
+                }
+                else {
+                    Logger_js_1.Logger.error(`[99] Can't parsing ${platform_node_js_1.Buffer.byteLength(bytes)} bytes of string session, we only supported string session from telethon,gramjs,tgsnake, and pyrogram (latest version, old version doesn't supported)`);
+                    throw new Error(`Invalid String Session`);
+                }
+            }
+        }
+    }
+}
+exports.StringSession = StringSession;

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

@@ -0,0 +1,4 @@
+export { AbstractSession } from './Abstract.js';
+export { BaseSession, getInputPeer } from './Session.js';
+export { StringSession } from './StringSession.js';
+export { SecretChat } from './SecretChat.js';

package/lib/src/storage/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretChat = exports.StringSession = exports.getInputPeer = exports.BaseSession = exports.AbstractSession = void 0;
+var Abstract_js_1 = require("./Abstract.js");
+Object.defineProperty(exports, "AbstractSession", { enumerable: true, get: function () { return Abstract_js_1.AbstractSession; } });
+var Session_js_1 = require("./Session.js");
+Object.defineProperty(exports, "BaseSession", { enumerable: true, get: function () { return Session_js_1.BaseSession; } });
+Object.defineProperty(exports, "getInputPeer", { enumerable: true, get: function () { return Session_js_1.getInputPeer; } });
+var StringSession_js_1 = require("./StringSession.js");
+Object.defineProperty(exports, "StringSession", { enumerable: true, get: function () { return StringSession_js_1.StringSession; } });
+var SecretChat_js_1 = require("./SecretChat.js");
+Object.defineProperty(exports, "SecretChat", { enumerable: true, get: function () { return SecretChat_js_1.SecretChat; } });

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@armatofik/tgsnake-core",
+  "version": "1.0.0",
+  "description": "Pure Telegram MTProto library for Javascript or Typescript. Fork from @tgsnake-core v1.13.15",
+  "main": "./lib/src/index.js",
+  "devDependencies": {
+    "@types/node": "22.14.0",
+    "deno2node": "1.15.0",
+    "prettier": "3.5.3"
+  },
+  "scripts": {
+    "build": "deno2node tsconfig.json",
+    "build:license": "node ./generator/license",
+    "build:chglog": "node ./generator/chglog",
+    "prepare": "yarn build",
+    "prettier": "NODE_OPTIONS=--max_old_space_size=4096 prettier -w ."
+  },
+  "homepage": "https://tgsnake.js.org",
+  "keywords": [
+    "tgsnake",
+    "mtproto",
+    "telegram"
+  ],
+  "bugs": "https://github.com/tgsnake/core/issues",
+  "repository": "https://github.com/Armatofik/tgsnake-core",
+  "author": "butthx",
+  "files": [
+    "lib/**/**"
+  ],
+  "license": "(GPL-3.0 OR LGPL-3.0)",
+  "engineStrict": true,
+  "engines": {
+    "node": ">=12.0.0",
+    "npm": ">=6.0.0",
+    "yarn": ">=1.0.0"
+  },
+  "packageManager": "yarn@4.8.1",
+  "dependencies": {
+    "@tgsnake/log": "latest",
+    "async-mutex": "0.5.0",
+    "big-integer": "1.6.52",
+    "socks": "2.8.4"
+  },
+  "isBeta": false,
+  "isPrivate": false
+}