@mtkruto/node 0.0.820 → 0.0.821

package/script/tl/3_functions_test.d.ts

@@ -0,0 +1 @@
+export {};

package/script/tl/3_tl_reader.d.ts

@@ -0,0 +1,6 @@
+import { TLRawReader } from "./0_tl_raw_reader.js";
+import { TLObject } from "./1_tl_object.js";
+export type ReadObject = TLObject | Array<ReadObject | TLObject>;
+export declare class TLReader extends TLRawReader {
+    readObject(id?: number): ReadObject;
+}

package/script/tl/3_tl_writer.d.ts

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

package/script/tl/4_rpc_result.d.ts

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

package/script/tl/5_message.d.ts

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

package/script/tl/6_message_container.d.ts

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

package/script/transport/transport.d.ts

@@ -0,0 +1,15 @@
+import { MaybePromise } from "../types.js";
+import { CTR } from "../utilities/0_crypto.js";
+export declare abstract class Transport {
+    protected initialized: boolean;
+    protected obfuscationParameters: {
+        encryptionCTR: CTR;
+        decryptionCTR: CTR;
+    } | null;
+    protected encrypt(buffer: Uint8Array): Uint8Array;
+    protected decrypt(buffer: Uint8Array): Uint8Array;
+    abstract initialize(): MaybePromise<void>;
+    abstract receive(): MaybePromise<Uint8Array>;
+    abstract send(buffer: Uint8Array): MaybePromise<void>;
+    abstract deinitialize(): MaybePromise<void>;
+}

package/script/transport/transport_abridged.d.ts

@@ -0,0 +1,11 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "./transport.js";
+export declare class TransportAbridged extends Transport implements Transport {
+    private readonly connection;
+    private readonly obfuscated;
+    constructor(connection: Connection, obfuscated?: boolean);
+    initialize(): Promise<void>;
+    receive(): Promise<Uint8Array>;
+    send(buffer: Uint8Array): Promise<void>;
+    deinitialize(): void;
+}

package/script/transport/transport_intermediate.d.ts

@@ -0,0 +1,11 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "./transport.js";
+export declare class TransportIntermediate extends Transport implements Transport {
+    private readonly connection;
+    private readonly obfuscated;
+    constructor(connection: Connection, obfuscated?: boolean);
+    initialize(): Promise<void>;
+    receive(): Promise<Uint8Array>;
+    send(buffer: Uint8Array): Promise<void>;
+    deinitialize(): void;
+}

package/script/transport/transport_provider.d.ts

@@ -0,0 +1,17 @@
+import { Connection } from "../connection/connection.js";
+import { Transport } from "./transport.js";
+export type DC = "1" | "2" | "3" | "4" | "5" | "1-test" | "2-test" | "3-test";
+export interface TransportProviderParams {
+    dc?: DC;
+    cdn: boolean;
+}
+export type TransportProvider = (params: TransportProviderParams) => {
+    connection: Connection;
+    transport: Transport;
+    dcId: number;
+};
+export interface TransportProviderCreatorParams {
+    initialDc: DC;
+}
+export type TransportProviderCreator = (params: TransportProviderCreatorParams) => TransportProvider;
+export declare const defaultTransportProvider: TransportProviderCreator;

package/script/types.d.ts

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | Promise<T>;

package/script/utilities/0_bigint.d.ts

@@ -0,0 +1,5 @@
+export declare function modExp(a: bigint, b: bigint, n: bigint): bigint;
+export declare function mod(n: bigint, m: bigint): bigint;
+export declare function bigIntFromBuffer(buffer: Uint8Array, little?: boolean, signed?: boolean): bigint;
+export declare function getRandomBigInt(byteLength: number, little?: boolean, signed?: boolean): bigint;
+export declare function getRandomId(): bigint;

package/script/utilities/0_bigint_test.d.ts

@@ -0,0 +1 @@
+export {};

package/script/utilities/0_buffer.d.ts

@@ -0,0 +1,2 @@
+export declare function concat(...buffers: [Uint8Array, Uint8Array, ...Uint8Array[]]): Uint8Array;
+export declare function bufferFromBigInt(bigIntVar: bigint | number, bytesNumber: number, little?: boolean, signed?: boolean): Uint8Array;

package/script/utilities/0_buffer_test.d.ts

@@ -0,0 +1 @@
+export {};

package/script/utilities/0_crypto.d.ts

@@ -0,0 +1,8 @@
+export declare class CTR {
+    readonly key: Uint8Array;
+    iv: Uint8Array;
+    state: Uint8Array;
+    constructor(key: Uint8Array, iv: Uint8Array);
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+}

package/script/utilities/0_hash.d.ts

@@ -0,0 +1,2 @@
+export declare function sha256(payload: Uint8Array): Promise<Uint8Array>;
+export declare function sha1(payload: Uint8Array): Promise<Uint8Array>;

package/script/utilities/1_auth.d.ts

@@ -0,0 +1 @@
+export declare function rsaPad(data: Uint8Array, [serverKey, exponent]: [bigint, bigint]): Promise<Uint8Array>;

package/script/utilities/1_message.d.ts

@@ -0,0 +1,10 @@
+import { Message } from "../tl/5_message.js";
+import { MessageContainer } from "../tl/6_message_container.js";
+export declare function getMessageId(): bigint;
+export declare function packUnencryptedMessage(data: Uint8Array): Uint8Array;
+export declare function unpackUnencryptedMessage(buffer: Uint8Array): {
+    messageId: bigint;
+    message: Uint8Array;
+};
+export declare function encryptMessage(message: Message, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
+export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message | MessageContainer>;

package/script/utilities/1_obfuscation.d.ts

@@ -0,0 +1,6 @@
+import { Connection } from "../connection/connection.js";
+import { CTR } from "./0_crypto.js";
+export declare function getObfuscationParameters(protocol: number, connection: Connection): Promise<{
+    encryptionCTR: CTR;
+    decryptionCTR: CTR;
+}>;

package/script/utilities/1_password.d.ts

@@ -0,0 +1,11 @@
+import * as types from "../tl/2_types.js";
+import { sha256 } from "./0_hash.js";
+export declare function isSafePrime(primeBytes: Uint8Array, g: number): boolean;
+export declare const h: typeof sha256;
+export declare const sh: (data: Uint8Array, salt: Uint8Array) => Promise<Uint8Array>;
+export declare const ph1: (password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array) => Promise<Uint8Array>;
+export declare function pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number): Promise<Uint8Array>;
+export declare const ph2: (password: Uint8Array, salt1: Uint8Array, salt2: Uint8Array) => Promise<Uint8Array>;
+export declare function isGoodModExpFirst(modexp: bigint, prime: bigint): boolean;
+export declare function pad(bigint: number | bigint | Uint8Array): Uint8Array;
+export declare function checkPassword(password: Uint8Array, ap: types.AccountPassword): Promise<types.InputCheckPasswordSRP>;

package/script/utilities/1_password_test.d.ts

@@ -0,0 +1 @@
+export {};