@mtkruto/node 0.0.835 → 0.0.901

package/esm/client/client_abstract.d.ts

@@ -7,6 +7,8 @@ export declare abstract class ClientAbstract {
     protected connection: Connection;
     protected transport: Transport;
     private _dcId;
+    private _initialDc;
+    get initialDc(): DC;
     constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;

package/esm/client/client_abstract.js

@@ -2,6 +2,9 @@ import { initTgCrypto } from "../deps.js";
 import { DEFAULT_INITIAL_DC } from "../constants.js";
 import { defaultTransportProvider } from "../transport/transport_provider.js";
 export class ClientAbstract {
+    get initialDc() {
+        return this._initialDc;
+    }
     constructor(transportProvider = defaultTransportProvider({ initialDc: DEFAULT_INITIAL_DC })) {
         Object.defineProperty(this, "transportProvider", {
             enumerable: true,
@@ -27,7 +30,15 @@ export class ClientAbstract {
             writable: true,
             value: void 0
         });
-        const { connection, transport, dcId } = transportProvider({ cdn: false });
+        Object.defineProperty(this, "_initialDc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { initialDc, createTransport } = transportProvider;
+        this._initialDc = initialDc;
+        const { connection, transport, dcId } = createTransport({ cdn: false });
         this.connection = connection;
         this.transport = transport;
         this._dcId = dcId;
@@ -37,7 +48,7 @@ export class ClientAbstract {
     }
     // MaybePromise since `Client` has to deal with `Storage.set()`
     setDc(dc) {
-        const { connection, transport, dcId } = this.transportProvider({ dc, cdn: false });
+        const { connection, transport, dcId } = this.transportProvider.createTransport({ dc, cdn: false });
         this.connection = connection;
         this.transport = transport;
         this._dcId = dcId;
@@ -53,7 +64,7 @@ export class ClientAbstract {
     async reconnect(dc) {
         await this.disconnect();
         if (dc) {
-            this.setDc(dc);
+            await this.setDc(dc);
         }
         await this.connect();
     }

package/esm/client/client_plain.js

@@ -2,6 +2,7 @@ import { assertEquals, assertInstanceOf, debug, factorize, ige256Decrypt, ige256
 import { publicKeys } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, modExp } from "../utilities/0_bigint.js";
 import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { rsaPad } from "../utilities/1_auth.js";
 import { serialize } from "../tl/1_tl_object.js";
@@ -28,10 +29,23 @@ export class ClientPlain extends ClientAbstract {
     async createAuthKey() {
         const nonce = getRandomBigInt(16, false, true);
         d("auth key creation started");
-        const resPq = await this.invoke(new ReqPQMulti({ nonce }));
-        assertInstanceOf(resPq, ResPQ);
-        assertEquals(resPq.nonce, nonce);
-        d("got res_pq");
+        let resPq = null;
+        for (let i = 0; i < 10; i++) {
+            try {
+                d("req_pq_multi [%d]", i + 1);
+                resPq = await this.invoke(new ReqPQMulti({ nonce }));
+                assertInstanceOf(resPq, ResPQ);
+                assertEquals(resPq.nonce, nonce);
+                d("got res_pq");
+                break;
+            }
+            catch (err) {
+                d("req_pq_multi error: %o", err);
+            }
+        }
+        if (!resPq) {
+            UNREACHABLE();
+        }
         const pq_ = bigIntFromBuffer(resPq.pq, false, false);
         const [p_, q_] = factorize(pq_);
         d("factorized pq");

package/esm/constants.d.ts

@@ -4,13 +4,15 @@ export declare const publicKeys: Map<bigint, [bigint, bigint]>;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const DEFAULT_INITIAL_DC: DC;
 export declare const LAYER = 158;
-export declare const DEFAULT_APP_VERSION = "MTKruto Unstable <v1.0.0";
-export declare const DEFAULT_DEVICE_MODEL = "Krutaya Device";
-export declare const DEFAULT_LANG_CODE = "en";
+export declare const DEFAULT_APP_VERSION = "MTKruto 0.0.901";
+export declare const DEFAULT_DEVICE_MODEL: string;
+export declare const DEFAULT_LANG_CODE: string;
 export declare const DEFAULT_LANG_PACK = "";
-export declare const DEFAULT_SYSTEM_LANG_CODE = "en";
-export declare const DEFAULT_SYSTEM_VERSION = "1.0";
+export declare const DEFAULT_SYSTEM_LANG_CODE: string;
+export declare const DEFAULT_SYSTEM_VERSION: string;
 export declare const USERNAME_TTL = 86400;
 export declare const MAX_CHAT_ID = 999999999999;
 export declare const MAX_CHANNEL_ID = 997852516352;
 export declare const ZERO_CHANNEL_ID = -1000000000000;
+export declare const CHANNEL_DIFFERENCE_LIMIT_USER = 100;
+export declare const CHANNEL_DIFFERENCE_LIMIT_BOT = 100000;

package/esm/constants.js

@@ -1,3 +1,4 @@
+import * as dntShim from "./_dnt.shims.js";
 export const ackThreshold = 10;
 export const publicKeys = new Map([
     [
@@ -61,14 +62,17 @@ export const publicKeys = new Map([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const DEFAULT_INITIAL_DC = "2-test";
 export const LAYER = 158;
-// TODO
-export const DEFAULT_APP_VERSION = "MTKruto Unstable <v1.0.0";
-export const DEFAULT_DEVICE_MODEL = "Krutaya Device";
-export const DEFAULT_LANG_CODE = "en";
+export const DEFAULT_APP_VERSION = "MTKruto 0.0.901";
+// @ts-ignore: lib
+export const DEFAULT_DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
+export const DEFAULT_LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];
 export const DEFAULT_LANG_PACK = "";
-export const DEFAULT_SYSTEM_LANG_CODE = "en";
-export const DEFAULT_SYSTEM_VERSION = "1.0";
+export const DEFAULT_SYSTEM_LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];
+// @ts-ignore: lib
+export const DEFAULT_SYSTEM_VERSION = typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : "Node.js/" + process.versions.node : navigator.userAgent;
 export const USERNAME_TTL = 86400;
 export const MAX_CHAT_ID = 999999999999;
 export const MAX_CHANNEL_ID = 997852516352;
 export const ZERO_CHANNEL_ID = -1000000000000;
+export const CHANNEL_DIFFERENCE_LIMIT_USER = 100;
+export const CHANNEL_DIFFERENCE_LIMIT_BOT = 100000;

package/esm/deps/deno.land/std@0.190.0/encoding/base64.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export declare function encode(data: ArrayBuffer | string): string;
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export declare function decode(b64: string): Uint8Array;

package/esm/deps/deno.land/std@0.190.0/encoding/base64.js

@@ -0,0 +1,140 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * const b64Repr = "Zm9vYg==";
+ *
+ * const binaryData = decode(b64Repr);
+ * console.log(binaryData);
+ * // => Uint8Array [ 102, 111, 111, 98 ]
+ *
+ * console.log(encode(binaryData));
+ * // => Zm9vYg==
+ * ```
+ *
+ * @module
+ */
+const base64abc = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "+",
+    "/",
+];
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export function encode(data) {
+    const uint8 = typeof data === "string"
+        ? new TextEncoder().encode(data)
+        : data instanceof Uint8Array
+            ? data
+            : new Uint8Array(data);
+    let result = "", i;
+    const l = uint8.length;
+    for (i = 2; i < l; i += 3) {
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+        result += base64abc[uint8[i] & 0x3f];
+    }
+    if (i === l + 1) {
+        // 1 octet yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[(uint8[i - 2] & 0x03) << 4];
+        result += "==";
+    }
+    if (i === l) {
+        // 2 octets yet to write
+        result += base64abc[uint8[i - 2] >> 2];
+        result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+        result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+        result += "=";
+    }
+    return result;
+}
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export function decode(b64) {
+    const binString = atob(b64);
+    const size = binString.length;
+    const bytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        bytes[i] = binString.charCodeAt(i);
+    }
+    return bytes;
+}

package/esm/deps/deno.land/x/q@v0.0.1/mod.d.ts

@@ -0,0 +1,6 @@
+export declare function queue<T, R>(runner: (task: T) => R, concurrency: number): {
+    push: (task: T | T[]) => void;
+    drain: (fn?: any) => void | Promise<any>;
+    onError: (fn: (task: T, error: Error) => any) => (task: T, error: Error) => any;
+    onDone: (fn: (task: T, result: R) => any) => (task: T, result: R) => any;
+};

package/esm/deps/deno.land/x/q@v0.0.1/mod.js

@@ -0,0 +1,71 @@
+export function queue(runner, concurrency) {
+    if (concurrency <= 0) {
+        throw new RangeError('concurrency can only be a positive integer');
+    }
+    if (!Number.isInteger(concurrency)) {
+        throw new RangeError('concurrency can only be a positive integer');
+    }
+    const tasks = [];
+    let running = 0;
+    let drains = [];
+    let onError = () => { };
+    let onDone = () => { };
+    let drainAwaiters = [];
+    function drained() {
+        drains.forEach((d) => d());
+        drains = [];
+        drainAwaiters.forEach((s) => s());
+        drainAwaiters = [];
+    }
+    async function runNext() {
+        if (running < concurrency && tasks.length > 0) {
+            running++;
+            const task = tasks.shift();
+            if (task) {
+                try {
+                    const result = await runner(task);
+                    onDone(task, result);
+                }
+                catch (err) {
+                    onError(task, err);
+                }
+            }
+            running--;
+            if (tasks.length > 0) {
+                queueMicrotask(runNext); // to prevent "Maximum call stack size exceeded"
+            }
+            else if (running === 0) {
+                drained();
+            }
+        }
+    }
+    return {
+        push: (task) => {
+            let needed = 1;
+            if (Array.isArray(task)) {
+                tasks.push(...task);
+                needed = task.length;
+            }
+            else {
+                tasks.push(task);
+            }
+            const free = concurrency - running;
+            for (let i = 0; i < Math.max(free, needed); i++) {
+                runNext();
+            }
+        },
+        drain: (fn) => {
+            if (fn) {
+                drains.push(fn);
+            }
+            else if (tasks.length > 0 || running > 0) {
+                return new Promise((resolve) => drainAwaiters.push(resolve));
+            }
+            else {
+                return Promise.resolve();
+            }
+        },
+        onError: (fn) => (onError = fn),
+        onDone: (fn) => (onDone = fn),
+    };
+}

package/esm/deps.d.ts

@@ -5,3 +5,5 @@ export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export declare const debug: typeof debug_;
+export { queue } from "./deps/deno.land/x/q@v0.0.1/mod.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";

package/esm/deps.js

@@ -5,3 +5,5 @@ export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/master/mod.js";
 export const debug = (v) => debug_(`mtkruto__${v}`);
+export { queue } from "./deps/deno.land/x/q@v0.0.1/mod.js";
+export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.190.0/encoding/base64.js";

package/esm/mod.d.ts

@@ -7,9 +7,9 @@ export declare const utils: {
 export { as } from "./tl/1_tl_object.js";
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
-export * from "./tl/4_rpc_result.js";
-export * from "./tl/5_message.js";
-export * from "./tl/6_message_container.js";
+export * from "./tl/5_rpc_result.js";
+export * from "./tl/6_message.js";
+export * from "./tl/7_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
 export * from "./storage/storage.js";

package/esm/mod.js

@@ -4,9 +4,9 @@ export const utils = { checkPassword, getRandomId };
 export { as } from "./tl/1_tl_object.js";
 export * as types from "./tl/2_types.js";
 export * as functions from "./tl/3_functions.js";
-export * from "./tl/4_rpc_result.js";
-export * from "./tl/5_message.js";
-export * from "./tl/6_message_container.js";
+export * from "./tl/5_rpc_result.js";
+export * from "./tl/6_message.js";
+export * from "./tl/7_message_container.js";
 export * from "./client/client_plain.js";
 export * from "./client/client.js";
 export * from "./storage/storage.js";

package/esm/storage/storage.d.ts

@@ -1,5 +1,6 @@
 import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/transport_provider.js";
+import * as types from "../tl/2_types.js";
 export declare abstract class Storage {
     private _authKeyId;
     abstract init(): MaybePromise<void>;
@@ -20,4 +21,21 @@ export declare abstract class Storage {
     private readonly username__;
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
     getUsername(username: string): Promise<readonly ["channel" | "user", bigint, Date] | null>;
+    private readonly state__;
+    setState(state: types.UpdatesState): Promise<void>;
+    getState(): Promise<types.UpdatesState | null>;
+    private readonly channelPts__;
+    setChannelPts(channelId: bigint, pts: number): Promise<void>;
+    getChannelPts(channelId: bigint): Promise<number | null>;
+    private readonly peer__;
+    setEntity(peer: types.Channel): Promise<void>;
+    setEntity(peer: types.Chat): Promise<void>;
+    setEntity(peer: types.User): Promise<void>;
+    getEntity(type: "channel", id: bigint): Promise<types.Channel | null>;
+    getEntity(type: "chat", id: bigint): Promise<types.Chat | null>;
+    getEntity(type: "user", id: bigint): Promise<types.User | null>;
+    getEntity(type: "channel" | "chat" | "user", id: bigint): Promise<types.Channel | types.Chat | types.User | null>;
+    private readonly accountType__;
+    setAccountType(type: "user" | "bot"): Promise<void>;
+    getAccountType(): Promise<"bot" | "user">;
 }

package/esm/storage/storage.js

@@ -1,5 +1,10 @@
+import { base64Decode, base64Encode } from "../deps.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { bigIntFromBuffer } from "../utilities/0_bigint.js";
+import { serialize } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { TLReader } from "../tl/3_tl_reader.js";
 export class Storage {
     constructor() {
         Object.defineProperty(this, "_authKeyId", {
@@ -26,6 +31,30 @@ export class Storage {
             writable: true,
             value: "username__"
         });
+        Object.defineProperty(this, "state__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "state__"
+        });
+        Object.defineProperty(this, "channelPts__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "channelPts__"
+        });
+        Object.defineProperty(this, "peer__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "peer__"
+        });
+        Object.defineProperty(this, "accountType__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "accountType__"
+        });
     }
     setDc(dc) {
         return this.set("dc", dc);
@@ -95,4 +124,78 @@ export class Storage {
             return null;
         }
     }
+    async setState(state) {
+        await this.set(this.state__, JSON.stringify({
+            date: state.date,
+            pts: state.pts,
+            qts: state.qts,
+            seq: state.seq,
+            unreadCount: state.unreadCount,
+        }));
+    }
+    async getState() {
+        const state__ = await this.get(this.state__);
+        if (state__ != null) {
+            const state_ = JSON.parse(state__);
+            return new types.UpdatesState({
+                date: state_.date,
+                pts: state_.pts,
+                qts: state_.qts,
+                seq: state_.seq,
+                unreadCount: state_.unreadCount,
+            });
+        }
+        else {
+            return null;
+        }
+    }
+    async setChannelPts(channelId, pts) {
+        await this.set(`${this.channelPts__}${channelId}`, String(pts));
+    }
+    async getChannelPts(channelId) {
+        const pts = await this.get(`${this.channelPts__}${channelId}`);
+        if (pts != null) {
+            return Number(pts);
+        }
+        else {
+            return null;
+        }
+    }
+    async setEntity(peer) {
+        const type = peer instanceof types.Channel ? "channel" : peer instanceof types.Chat ? "chat" : peer instanceof types.User ? "user" : UNREACHABLE();
+        await this.set(`${this.peer__}${type}${peer.id}`, base64Encode(peer[serialize]()));
+    }
+    async getEntity(type, id) {
+        const peer_ = await this.get(`${this.peer__}${type}${id}`);
+        if (peer_ != null) {
+            const reader = new TLReader(base64Decode(peer_));
+            return reader.readObject();
+        }
+        else {
+            return null;
+        }
+    }
+    async setAccountType(type) {
+        try {
+            await this.getAccountType();
+            UNREACHABLE();
+        }
+        catch (err) {
+            if (!(err instanceof Error) || !(err.message == "Unreachable")) {
+                throw err;
+            }
+            else {
+                await this.set(this.accountType__, type);
+            }
+        }
+    }
+    async getAccountType() {
+        const accountType = await this.get(this.accountType__);
+        if (accountType != null) {
+            return accountType;
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
 }

package/esm/tl/1_tl_object.d.ts

@@ -31,7 +31,6 @@ export declare abstract class TLObject {
     [serialize](): Uint8Array;
     [as]<T extends TLObjectConstructor<InstanceType<T>>>(constructor: T): InstanceType<T>;
 }
-export type MaybeVectorTLObject = TLObject | Array<MaybeVectorTLObject | TLObject>;
 export interface TLObjectConstructor<T = TLObject> {
     new (params: any): T;
     [paramDesc]: ParamDesc;

package/esm/tl/1_tl_object.js

@@ -28,7 +28,7 @@ function serializeSingleParam(writer, value, type, ntype) {
             return;
         }
         else {
-            throw new TypeError(`Expected ${type.name}`);
+            throw new TypeError(`Expected ${type.name} but received ${value == null ? null : value.constructor.name}`);
         }
     }
     if (type == Uint8Array) {

package/esm/tl/4_tl_writer.d.ts

@@ -0,0 +1,5 @@
+import { TLRawWriter } from "./0_tl_raw_writer.js";
+import { ReadObject } from "./3_tl_reader.js";
+export declare class TLWriter extends TLRawWriter {
+    writeObject(object: ReadObject): this;
+}

package/esm/tl/5_rpc_result.d.ts

@@ -0,0 +1,9 @@
+import { id } from "./1_tl_object.js";
+import { ReadObject } from "./3_tl_reader.js";
+export declare class RPCResult {
+    readonly messageId: bigint;
+    readonly result: ReadObject;
+    static get [id](): number;
+    constructor(messageId: bigint, result: ReadObject);
+    static deserialize(buffer: Uint8Array): RPCResult;
+}

package/esm/tl/6_message.d.ts

@@ -0,0 +1,10 @@
+import { ReadObject, TLReader } from "./3_tl_reader.js";
+import { RPCResult } from "./5_rpc_result.js";
+export declare class Message {
+    readonly id: bigint;
+    readonly seqNo: number;
+    readonly body: ReadObject | RPCResult;
+    constructor(id: bigint, seqNo: number, body: ReadObject | RPCResult);
+    serialize(): Uint8Array;
+    static deserialize(reader: TLReader): Message;
+}

package/esm/tl/{5_message.js → 6_message.js}

@@ -1,7 +1,7 @@
 import { id, serialize } from "./1_tl_object.js";
 import { TLReader } from "./3_tl_reader.js";
-import { TLWriter } from "./3_tl_writer.js";
-import { RPCResult } from "./4_rpc_result.js";
+import { TLWriter } from "./4_tl_writer.js";
+import { RPCResult } from "./5_rpc_result.js";
 // TODO: test
 function calculateLength(object) {
     let length = 0;

package/esm/tl/{6_message_container.d.ts → 7_message_container.d.ts}

@@ -1,5 +1,5 @@
 import { id } from "./1_tl_object.js";
-import { Message } from "./5_message.js";
+import { Message } from "./6_message.js";
 export declare class MessageContainer {
     messages: Message[];
     static get [id](): number;

package/esm/tl/{6_message_container.js → 7_message_container.js}

@@ -1,7 +1,7 @@
 import { id } from "./1_tl_object.js";
 import { TLReader } from "./3_tl_reader.js";
-import { TLWriter } from "./3_tl_writer.js";
-import { Message } from "./5_message.js";
+import { TLWriter } from "./4_tl_writer.js";
+import { Message } from "./6_message.js";
 export class MessageContainer {
     static get [id]() {
         return 0x73F1F8DC;

package/esm/transport/transport_provider.d.ts

@@ -5,10 +5,13 @@ export interface TransportProviderParams {
     dc?: DC;
     cdn: boolean;
 }
-export type TransportProvider = (params: TransportProviderParams) => {
-    connection: Connection;
-    transport: Transport;
-    dcId: number;
+export type TransportProvider = {
+    initialDc: DC;
+    createTransport: (params: TransportProviderParams) => {
+        connection: Connection;
+        transport: Transport;
+        dcId: number;
+    };
 };
 export interface TransportProviderCreatorParams {
     initialDc: DC;