teleproto 1.224.1 → 1.224.2

package/Utils.js

@@ -915,8 +915,37 @@ function getInputMedia(media, { isPhoto = false, attributes = undefined, forceDo
         else {
             correctAnswers = undefined;
         }
+        const pollWithInputAnswers = new tl_1.Api.Poll({
+            id: media.poll.id,
+            question: media.poll.question,
+            answers: media.poll.answers.map((a) => {
+                if (!(a instanceof tl_1.Api.PollAnswer))
+                    return a;
+                return new tl_1.Api.PollAnswer({
+                    text: a.text,
+                    option: a.option,
+                    media: a.media
+                        ? getInputMedia(a.media)
+                        : undefined,
+                    addedBy: a.addedBy,
+                    date: a.date,
+                });
+            }),
+            closed: media.poll.closed,
+            publicVoters: media.poll.publicVoters,
+            multipleChoice: media.poll.multipleChoice,
+            quiz: media.poll.quiz,
+            openAnswers: media.poll.openAnswers,
+            revotingDisabled: media.poll.revotingDisabled,
+            shuffleAnswers: media.poll.shuffleAnswers,
+            hideResultsUntilClose: media.poll.hideResultsUntilClose,
+            creator: media.poll.creator,
+            closePeriod: media.poll.closePeriod,
+            closeDate: media.poll.closeDate,
+            hash: media.poll.hash,
+        });
         return new tl_1.Api.InputMediaPoll({
-            poll: media.poll,
+            poll: pollWithInputAnswers,
             correctAnswers: correctAnswers,
             solution: media.results.solution,
             solutionEntities: media.results.solutionEntities,

package/Version.d.ts

@@ -1 +1 @@
-export declare const version = "1.224.1";
+export declare const version = "1.224.2";

package/Version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = "1.224.1";
+exports.version = "1.224.2";

package/client/PtsWaiter.d.ts

@@ -0,0 +1,44 @@
+import type { Api } from "../tl";
+export declare const WAIT_FOR_SKIPPED_TIMEOUT_MS = 1000;
+export type SkippedTag = "update" | "updates";
+export interface SkippedEntry {
+    pts: number;
+    tieBreaker: number;
+    tag: SkippedTag;
+    update?: Api.TypeUpdate;
+    updates?: Api.TypeUpdates;
+}
+export interface PtsWaiterHost {
+    onWaitForSkipped(ms: number): void;
+    onWaitForShortPoll(ms: number): void;
+}
+export declare class PtsWaiter {
+    private readonly host;
+    private good;
+    private last;
+    private count;
+    private requestingFlag;
+    private waitingForSkipped;
+    private waitingForShortPoll;
+    private applyingSkippedDepth;
+    private skippedKey;
+    private readonly queue;
+    constructor(host: PtsWaiterHost);
+    inited(): boolean;
+    current(): number;
+    init(pts: number): void;
+    requesting(): boolean;
+    setRequesting(value: boolean): void;
+    isWaitingForSkipped(): boolean;
+    isWaitingForShortPoll(): boolean;
+    setWaitingForSkipped(ms: number): void;
+    setWaitingForShortPoll(ms: number): void;
+    updated(pts: number, count: number, payload: Omit<SkippedEntry, "pts" | "tieBreaker">): boolean;
+    updateAndApply(pts: number, count: number, payload: Omit<SkippedEntry, "pts" | "tieBreaker">, applyUpdate: (update: Api.TypeUpdate) => void, applyUpdates: (updates: Api.TypeUpdates) => void): boolean;
+    applySkippedUpdates(applyUpdate: (update: Api.TypeUpdate) => void, applyUpdates: (updates: Api.TypeUpdates) => void): void;
+    clearSkippedUpdates(): void;
+    private check;
+    private enqueue;
+    private lowerBoundOf;
+    private checkForWaiting;
+}

package/client/PtsWaiter.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PtsWaiter = exports.WAIT_FOR_SKIPPED_TIMEOUT_MS = void 0;
+exports.WAIT_FOR_SKIPPED_TIMEOUT_MS = 1000;
+class PtsWaiter {
+    constructor(host) {
+        this.host = host;
+        this.good = 0;
+        this.last = 0;
+        this.count = 0;
+        this.requestingFlag = false;
+        this.waitingForSkipped = false;
+        this.waitingForShortPoll = false;
+        this.applyingSkippedDepth = 0;
+        this.skippedKey = 0;
+        this.queue = [];
+    }
+    inited() {
+        return this.good > 0;
+    }
+    current() {
+        return this.good;
+    }
+    init(pts) {
+        this.good = pts;
+        this.last = pts;
+        this.count = pts;
+        this.clearSkippedUpdates();
+    }
+    requesting() {
+        return this.requestingFlag;
+    }
+    setRequesting(value) {
+        this.requestingFlag = value;
+        if (value)
+            this.clearSkippedUpdates();
+    }
+    isWaitingForSkipped() {
+        return this.waitingForSkipped;
+    }
+    isWaitingForShortPoll() {
+        return this.waitingForShortPoll;
+    }
+    setWaitingForSkipped(ms) {
+        if (ms >= 0) {
+            this.waitingForSkipped = true;
+            this.host.onWaitForSkipped(ms);
+        }
+        else {
+            this.waitingForSkipped = false;
+            this.checkForWaiting();
+        }
+    }
+    setWaitingForShortPoll(ms) {
+        if (ms >= 0) {
+            this.waitingForShortPoll = true;
+            this.host.onWaitForShortPoll(ms);
+        }
+        else {
+            this.waitingForShortPoll = false;
+            this.checkForWaiting();
+        }
+    }
+    updated(pts, count, payload) {
+        if (this.requestingFlag || this.applyingSkippedDepth > 0) {
+            return true;
+        }
+        if (count > 0 && pts <= this.good) {
+            return false;
+        }
+        if (this.check(pts, count)) {
+            return true;
+        }
+        this.enqueue(pts, payload);
+        return false;
+    }
+    updateAndApply(pts, count, payload, applyUpdate, applyUpdates) {
+        if (!this.updated(pts, count, payload))
+            return false;
+        if (!this.waitingForSkipped || this.queue.length === 0) {
+            if (payload.tag === "update" && payload.update)
+                applyUpdate(payload.update);
+            else if (payload.tag === "updates" && payload.updates)
+                applyUpdates(payload.updates);
+            return true;
+        }
+        this.enqueue(pts, payload);
+        this.applySkippedUpdates(applyUpdate, applyUpdates);
+        return true;
+    }
+    applySkippedUpdates(applyUpdate, applyUpdates) {
+        if (!this.waitingForSkipped)
+            return;
+        this.setWaitingForSkipped(-1);
+        if (this.queue.length === 0)
+            return;
+        this.applyingSkippedDepth++;
+        try {
+            for (const entry of this.queue) {
+                if (entry.tag === "update" && entry.update)
+                    applyUpdate(entry.update);
+                else if (entry.tag === "updates" && entry.updates)
+                    applyUpdates(entry.updates);
+            }
+        }
+        finally {
+            this.applyingSkippedDepth--;
+            this.clearSkippedUpdates();
+        }
+    }
+    clearSkippedUpdates() {
+        this.queue.length = 0;
+    }
+    check(pts, count) {
+        if (!this.inited()) {
+            this.init(pts);
+            return true;
+        }
+        this.last = Math.max(this.last, pts);
+        this.count += count;
+        if (this.last === this.count) {
+            this.good = this.last;
+            return true;
+        }
+        if (this.last < this.count) {
+            this.setWaitingForSkipped(1);
+            return false;
+        }
+        this.setWaitingForSkipped(exports.WAIT_FOR_SKIPPED_TIMEOUT_MS);
+        return false;
+    }
+    enqueue(pts, payload) {
+        const entry = Object.assign({ pts, tieBreaker: ++this.skippedKey }, payload);
+        const idx = this.lowerBoundOf(entry);
+        this.queue.splice(idx, 0, entry);
+    }
+    lowerBoundOf(entry) {
+        let lo = 0;
+        let hi = this.queue.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            const cur = this.queue[mid];
+            const lt = cur.pts < entry.pts ||
+                (cur.pts === entry.pts && cur.tieBreaker < entry.tieBreaker);
+            if (lt)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    checkForWaiting() {
+        if (!this.waitingForSkipped && !this.waitingForShortPoll) {
+            this.host.onWaitForSkipped(-1);
+        }
+    }
+}
+exports.PtsWaiter = PtsWaiter;

package/client/TelegramClient.d.ts

@@ -1129,6 +1129,7 @@ export declare class TelegramClient extends TelegramBaseClient {
         ipAddress: string;
         port: number;
     }>;
+    private _lookupDcOption;
     /** @hidden */
     _getDownloadConcurrency(fileSize: number): Promise<number>;
     /** @hidden */

package/client/TelegramClient.js

@@ -1246,19 +1246,52 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
     async getDC(dcId, downloadDC = false) {
         this._log.debug(`Getting DC ${dcId}`);
         if (!this._config) {
-            this._config = await this.invoke(new tl_1.Api.help.GetConfig());
-        }
-        for (const DC of this._config.dcOptions) {
-            if (DC.id === dcId && !!DC.ipv6 === this._useIPV6) {
-                return {
-                    id: DC.id,
-                    ipAddress: DC.ipAddress,
-                    port: 443,
-                };
+            try {
+                this._config = await this.invoke(new tl_1.Api.help.GetConfig());
+            }
+            catch (e) {
+                this._log.warn(`help.GetConfig failed, falling back to built-in DC seeds: ${e}`);
             }
         }
+        const lookup = this._lookupDcOption(dcId, downloadDC);
+        if (lookup) {
+            return lookup;
+        }
+        const ipv4Table = this._testServers ? telegramBaseClient_1.TEST_DC_IPV4 : telegramBaseClient_1.PROD_DC_IPV4;
+        const ipv6Table = this._testServers ? telegramBaseClient_1.TEST_DC_IPV6 : telegramBaseClient_1.PROD_DC_IPV6;
+        const ipAddress = (this._useIPV6 ? ipv6Table : ipv4Table)[dcId];
+        if (ipAddress) {
+            return { id: dcId, ipAddress, port: 443 };
+        }
         throw new Error(`Cannot find the DC with the ID of ${dcId}`);
     }
+    _lookupDcOption(dcId, mediaCluster) {
+        if (!this._config)
+            return undefined;
+        let candidates = this._config.dcOptions.filter((DC) => {
+            if (DC.id !== dcId)
+                return false;
+            if (DC.cdn)
+                return false;
+            if (DC.mediaOnly && !mediaCluster)
+                return false;
+            if (DC.secret && DC.secret.length)
+                return false;
+            if (DC.tcpoOnly)
+                return false;
+            return !!DC.ipv6 === this._useIPV6;
+        });
+        if (!candidates.length)
+            return undefined;
+        if (mediaCluster && candidates.some((DC) => DC.mediaOnly)) {
+            candidates = candidates.filter((DC) => DC.mediaOnly);
+        }
+        if (this._proxy && candidates.some((DC) => DC.static)) {
+            candidates = candidates.filter((DC) => DC.static);
+        }
+        const chosen = candidates[0];
+        return { id: chosen.id, ipAddress: chosen.ipAddress, port: 443 };
+    }
     /** @hidden */
     async _getDownloadConcurrency(fileSize) {
         var _a, _b, _c, _d;

package/client/UpdateManager.d.ts

@@ -0,0 +1,53 @@
+import { Api } from "../tl";
+import type { TelegramClient } from "./TelegramClient";
+export interface UpdateState {
+    pts: number;
+    qts: number;
+    date: number;
+    seq: number;
+}
+export declare class UpdateManager {
+    state?: UpdateState;
+    lastUpdateTime: number;
+    private readonly client;
+    private readonly globalPts;
+    private globalPtsTimer?;
+    private readonly channels;
+    private readonly pendingSeq;
+    private fetchingDifference;
+    private failTimeoutS;
+    private failRetryTimer?;
+    private readonly channelFailTimeoutS;
+    private readonly channelFailRetryTimers;
+    private running;
+    constructor(client: TelegramClient);
+    start(): void;
+    stop(): void;
+    onUpdates(update: Api.TypeUpdate | Api.TypeUpdates): void;
+    catchUp(): Promise<void>;
+    ensureState(): Promise<void>;
+    refreshFromState(state: {
+        pts: number;
+        qts: number;
+        date: number;
+        seq: number;
+    }): void;
+    isStale(): boolean;
+    recoverIfStale(): Promise<void>;
+    private handleContainer;
+    private handleShortMessage;
+    private feedUpdate;
+    private dispatch;
+    private collectEntities;
+    private makeGlobalWaiter;
+    private getOrCreateChannel;
+    private scheduleCommonDifference;
+    private fetchCommonDifference;
+    private fetchDifferenceLoop;
+    private processDifference;
+    private drainPendingSeq;
+    private fetchChannelDifference;
+    private resolveChannel;
+    private bumpFailTimeout;
+    private bumpChannelFailTimeout;
+}