@mtcute/convert 0.16.0 → 0.16.9

package/README.md

@@ -8,7 +8,7 @@ Currently only the libraries that support exporting sessions to strings are supp
 
 ## [Telethon](https://github.com/LonamiWebs/Telethon)
 
-> Telethon v2 seems to have removed the ability to export sessions, 
+> Telethon v2 seems to have removed the ability to export sessions,
 > so it's currently not supported
 
 ```ts

package/gramjs/__fixtures__/session.d.ts

@@ -0,0 +1 @@
+export declare const GRAMJS_SESSION = "1AgAOMTQ5LjE1NC4xNjcuNDABu60obcEYS8Yb/I7YlCwaLvW84dXCX2oGnBYG+zuMciJhHP99c8ZJvwxJgH8yU1QrqI+Gh0kK0JAuQucIpDfq/jJVLZ1ZRimq5yy1XbeEs65gtZA1+SUwZRXahh+NzGbPmOVUMCnCtRONo9GNvcx/QxSXRrh7T/K0YYN1iHsK1vJDk8/SUnthvTNmRycC+JLn4fMtctqP4Le2WPOH/deYbUF0BlwmR77M7fv1GZSInqCgWReaIl5nvn0IqA4mOCTkdOgcvwOiB2UmXwiyInxRuLdBIyLbBUDCuTlmL1m3FJqbuEpZEUJnoJf2YDFZ1wR6TfL0MUS1VwnjOcy3WIIFwwg=";

package/gramjs/serialize.test.d.ts

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

package/index.cjs

@@ -0,0 +1,493 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/convert] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/convert] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils_js = require("@mtcute/core/utils.js");
+const core = require("@mtcute/core");
+const platform_js = require("@mtcute/core/platform.js");
+const DC_MAPPING_PROD = {
+  1: {
+    main: {
+      id: 1,
+      ipAddress: "149.154.175.56",
+      port: 443
+    },
+    media: {
+      id: 1,
+      ipAddress: "149.154.175.211",
+      port: 443
+    }
+  },
+  2: {
+    main: {
+      id: 2,
+      ipAddress: "149.154.167.41",
+      port: 443
+    },
+    media: {
+      id: 2,
+      ipAddress: "149.154.167.35",
+      port: 443
+    }
+  },
+  3: {
+    main: {
+      id: 3,
+      ipAddress: "149.154.175.100",
+      port: 443
+    },
+    media: {
+      id: 3,
+      ipAddress: "149.154.175.100",
+      port: 443
+    }
+  },
+  4: {
+    main: {
+      id: 4,
+      ipAddress: "149.154.167.91",
+      port: 443
+    },
+    media: {
+      id: 4,
+      ipAddress: "149.154.167.255",
+      port: 443
+    }
+  },
+  5: {
+    main: {
+      id: 5,
+      ipAddress: "91.108.56.179",
+      port: 443
+    },
+    media: {
+      id: 5,
+      ipAddress: "149.154.171.255",
+      port: 443
+    }
+  }
+};
+const DC_MAPPING_TEST = {
+  1: {
+    main: {
+      id: 1,
+      ipAddress: "149.154.175.10",
+      port: 80
+    },
+    media: {
+      id: 1,
+      ipAddress: "149.154.175.10",
+      port: 80
+    }
+  },
+  2: {
+    main: {
+      id: 2,
+      ipAddress: "149.154.167.40",
+      port: 443
+    },
+    media: {
+      id: 2,
+      ipAddress: "149.154.167.40",
+      port: 443
+    }
+  },
+  3: {
+    main: {
+      id: 3,
+      ipAddress: "149.154.175.117",
+      port: 443
+    },
+    media: {
+      id: 3,
+      ipAddress: "149.154.175.117",
+      port: 443
+    }
+  }
+};
+function isTestDc(ip) {
+  return Object.values(DC_MAPPING_TEST).some((dc) => dc.main.ipAddress === ip || dc.media.ipAddress === ip);
+}
+function parseIpFromBytes(data) {
+  if (data.length === 4) {
+    return `${data[0]}.${data[1]}.${data[2]}.${data[3]}`;
+  }
+  if (data.length === 16) {
+    let res = "";
+    for (let i = 0; i < 16; i += 2) {
+      res += data[i].toString(16).padStart(2, "0");
+      res += data[i + 1].toString(16).padStart(2, "0");
+      if (i < 14) res += ":";
+    }
+    return res;
+  }
+  throw new core.MtArgumentError("Invalid IP address length");
+}
+function serializeIpv4ToBytes(ip, buf) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) {
+    throw new core.MtArgumentError("Invalid IPv4 address");
+  }
+  buf[0] = Number(parts[0]);
+  buf[1] = Number(parts[1]);
+  buf[2] = Number(parts[2]);
+  buf[3] = Number(parts[3]);
+}
+function serializeIpv6ToBytes(ip, buf) {
+  const parts = ip.split(":");
+  if (parts.length !== 8) {
+    throw new core.MtArgumentError("Invalid IPv6 address");
+  }
+  for (let i = 0; i < 8; i++) {
+    const val = Number.parseInt(parts[i], 16);
+    buf[i * 2] = val >> 8;
+    buf[i * 2 + 1] = val & 255;
+  }
+}
+function parseTelethonSession(session) {
+  if (session[0] !== "1") {
+    throw new core.MtArgumentError(`Invalid session string (version = ${session[0]})`);
+  }
+  session = session.slice(1);
+  const data = platform_js.getPlatform().base64Decode(session, true);
+  const dv = utils_js.dataViewFromBuffer(data);
+  const dcId = dv.getUint8(0);
+  const ipSize = session.length === 352 ? 4 : 16;
+  let pos = 1 + ipSize;
+  const ipBytes = data.subarray(1, pos);
+  const port = dv.getUint16(pos);
+  pos += 2;
+  const authKey = data.subarray(pos, pos + 256);
+  const ip = parseIpFromBytes(ipBytes);
+  return {
+    dcId,
+    ipAddress: ip,
+    ipv6: ipSize === 16,
+    port,
+    authKey
+  };
+}
+function serializeTelethonSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new core.MtArgumentError("authKey must be 256 bytes long");
+  }
+  const ipSize = session.ipv6 ? 16 : 4;
+  const u8 = new Uint8Array(259 + ipSize);
+  const dv = utils_js.dataViewFromBuffer(u8);
+  dv.setUint8(0, session.dcId);
+  let pos;
+  if (session.ipv6) {
+    serializeIpv6ToBytes(session.ipAddress, u8.subarray(1, 17));
+    pos = 17;
+  } else {
+    serializeIpv4ToBytes(session.ipAddress, u8.subarray(1, 5));
+    pos = 5;
+  }
+  dv.setUint16(pos, session.port);
+  pos += 2;
+  u8.set(session.authKey, pos);
+  let b64 = platform_js.getPlatform().base64Encode(u8, true);
+  while (b64.length % 4 !== 0) b64 += "=";
+  return `1${b64}`;
+}
+function convertFromTelethonSession(session) {
+  if (typeof session === "string") {
+    session = parseTelethonSession(session);
+  }
+  const dc = {
+    id: session.dcId,
+    ipAddress: session.ipAddress,
+    port: session.port,
+    ipv6: session.ipv6
+  };
+  return {
+    version: 3,
+    // we don't exactly have that information. try to deduce it from DC_MAPPING_TEST
+    // todo: we should maybe check this at connect?
+    testMode: isTestDc(session.ipAddress),
+    primaryDcs: {
+      main: dc,
+      media: dc
+    },
+    authKey: session.authKey
+  };
+}
+function convertToTelethonSession(session) {
+  if (typeof session === "string") {
+    session = utils_js.readStringSession(session);
+  }
+  return serializeTelethonSession({
+    dcId: session.primaryDcs.main.id,
+    ipAddress: session.primaryDcs.main.ipAddress,
+    port: session.primaryDcs.main.port,
+    ipv6: session.primaryDcs.main.ipv6 ?? false,
+    authKey: session.authKey
+  });
+}
+function parseGramjsSession(session) {
+  if (session[0] !== "1") {
+    throw new core.MtArgumentError(`Invalid session string (version = ${session[0]})`);
+  }
+  session = session.slice(1);
+  const data = platform_js.getPlatform().base64Decode(session);
+  const dv = utils_js.dataViewFromBuffer(data);
+  const dcId = dv.getUint8(0);
+  const ipSize = dv.getUint16(1);
+  let pos = 3 + ipSize;
+  const ip = platform_js.getPlatform().utf8Decode(data.subarray(3, pos));
+  const port = dv.getUint16(pos);
+  pos += 2;
+  const authKey = data.subarray(pos, pos + 256);
+  return {
+    dcId,
+    ipAddress: ip,
+    ipv6: ip.includes(":"),
+    // dumb check but gramjs does this
+    port,
+    authKey
+  };
+}
+function serializeGramjsSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new core.MtArgumentError("authKey must be 256 bytes long");
+  }
+  const ipEncoded = platform_js.getPlatform().utf8Encode(session.ipAddress);
+  const u8 = new Uint8Array(261 + ipEncoded.length);
+  const dv = utils_js.dataViewFromBuffer(u8);
+  dv.setUint8(0, session.dcId);
+  dv.setUint16(1, ipEncoded.length);
+  u8.set(ipEncoded, 3);
+  let pos = 3 + ipEncoded.length;
+  dv.setUint16(pos, session.port);
+  pos += 2;
+  u8.set(session.authKey, pos);
+  return `1${platform_js.getPlatform().base64Encode(u8)}`;
+}
+function convertFromGramjsSession(session) {
+  if (typeof session === "string") {
+    session = parseGramjsSession(session);
+  }
+  return convertFromTelethonSession(session);
+}
+function convertToGramjsSession(session) {
+  if (typeof session === "string") {
+    session = utils_js.readStringSession(session);
+  }
+  return serializeGramjsSession({
+    dcId: session.primaryDcs.main.id,
+    ipAddress: session.primaryDcs.main.ipAddress,
+    port: session.primaryDcs.main.port,
+    ipv6: session.primaryDcs.main.ipv6 ?? false,
+    authKey: session.authKey
+  });
+}
+function telegramRleEncode(buf) {
+  const len = buf.length;
+  const ret = [];
+  let count = 0;
+  for (let i = 0; i < len; i++) {
+    const cur = buf[i];
+    if (cur === 0) {
+      count += 1;
+    } else {
+      if (count > 0) {
+        ret.push(0, count);
+        count = 0;
+      }
+      ret.push(cur);
+    }
+  }
+  if (count > 0) {
+    ret.push(0, count);
+  }
+  return new Uint8Array(ret);
+}
+function telegramRleDecode(buf) {
+  const len = buf.length;
+  const ret = [];
+  let prev = -1;
+  for (let i = 0; i < len; i++) {
+    const cur = buf[i];
+    if (prev === 0) {
+      for (let j = 0; j < cur; j++) {
+        ret.push(prev);
+      }
+      prev = -1;
+    } else {
+      if (prev !== -1) ret.push(prev);
+      prev = cur;
+    }
+  }
+  if (prev !== -1) ret.push(prev);
+  return new Uint8Array(ret);
+}
+function parseMtkrutoSession(session) {
+  const data = telegramRleDecode(platform_js.getPlatform().base64Decode(session, true));
+  const reader = utils_js.TlBinaryReader.manual(data);
+  let dcIdStr = reader.string();
+  const authKey = reader.bytes();
+  const isTest = dcIdStr.endsWith("-test");
+  if (isTest) {
+    dcIdStr = dcIdStr.slice(0, -5);
+  }
+  const dcId = Number(dcIdStr);
+  if (Number.isNaN(dcId)) {
+    throw new core.MtArgumentError(`Invalid DC ID: ${dcIdStr}`);
+  }
+  return {
+    dcId,
+    isTest,
+    authKey
+  };
+}
+function serializeMtkrutoSession(session) {
+  const dcIdStr = `${session.dcId}${session.isTest ? "-test" : ""}`;
+  const writer = utils_js.TlBinaryWriter.manual(session.authKey.length + dcIdStr.length + 8);
+  writer.string(dcIdStr);
+  writer.bytes(session.authKey);
+  return platform_js.getPlatform().base64Encode(telegramRleEncode(writer.result()), true);
+}
+function convertFromMtkrutoSession(session) {
+  if (typeof session === "string") {
+    session = parseMtkrutoSession(session);
+  }
+  return {
+    version: 3,
+    testMode: session.isTest,
+    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
+    authKey: session.authKey
+  };
+}
+function convertToMtkrutoSession(session) {
+  if (typeof session === "string") {
+    session = utils_js.readStringSession(session);
+  }
+  return serializeMtkrutoSession({
+    dcId: session.primaryDcs.main.id,
+    isTest: session.testMode,
+    authKey: session.authKey
+  });
+}
+const SESSION_STRING_SIZE$1 = 351;
+const SESSION_STRING_SIZE_64 = 356;
+function parsePyrogramSession(session) {
+  const data = platform_js.getPlatform().base64Decode(session, true);
+  const dv = utils_js.dataViewFromBuffer(data);
+  if (session.length === SESSION_STRING_SIZE$1 || session.length === SESSION_STRING_SIZE_64) {
+    const dcId2 = dv.getUint8(0);
+    const isTest2 = dv.getUint8(1) !== 0;
+    const authKey2 = data.subarray(2, 258);
+    let userId2;
+    if (data.length === SESSION_STRING_SIZE$1) {
+      userId2 = dv.getUint32(258);
+    } else {
+      const high = dv.getUint32(258);
+      const low = dv.getUint32(262);
+      userId2 = core.Long.fromBits(low, high).toNumber();
+    }
+    const isBot2 = dv.getUint8(data.length - 1) !== 0;
+    return {
+      dcId: dcId2,
+      isTest: isTest2,
+      authKey: authKey2,
+      userId: userId2,
+      isBot: isBot2
+    };
+  }
+  const dcId = dv.getUint8(0);
+  const apiId = dv.getUint32(1);
+  const isTest = dv.getUint8(5) !== 0;
+  const authKey = data.subarray(6, 262);
+  const userId = utils_js.longFromBuffer(data.subarray(262, 270), true, false).toNumber();
+  const isBot = dv.getUint8(270) !== 0;
+  return {
+    dcId,
+    apiId,
+    isTest,
+    authKey,
+    userId,
+    isBot
+  };
+}
+const SESSION_STRING_SIZE_OLD = 267;
+const SESSION_STRING_SIZE = 271;
+function serializePyrogramSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new core.MtArgumentError("authKey must be 256 bytes long");
+  }
+  const userIdLong = core.Long.fromNumber(session.userId, true);
+  let u8;
+  if (session.apiId === void 0) {
+    u8 = new Uint8Array(SESSION_STRING_SIZE_OLD);
+    const dv = utils_js.dataViewFromBuffer(u8);
+    dv.setUint8(0, session.dcId);
+    dv.setUint8(1, session.isTest ? 1 : 0);
+    u8.set(session.authKey, 2);
+    dv.setUint32(258, userIdLong.high);
+    dv.setUint32(262, userIdLong.low);
+    dv.setUint8(266, session.isBot ? 1 : 0);
+  } else {
+    u8 = new Uint8Array(SESSION_STRING_SIZE);
+    const dv = utils_js.dataViewFromBuffer(u8);
+    dv.setUint8(0, session.dcId);
+    dv.setUint32(1, session.apiId);
+    dv.setUint8(5, session.isTest ? 1 : 0);
+    u8.set(session.authKey, 6);
+    dv.setUint32(262, userIdLong.high);
+    dv.setUint32(266, userIdLong.low);
+    dv.setUint8(270, session.isBot ? 1 : 0);
+  }
+  return platform_js.getPlatform().base64Encode(u8, true);
+}
+function convertFromPyrogramSession(session) {
+  if (typeof session === "string") {
+    session = parsePyrogramSession(session);
+  }
+  return {
+    version: 3,
+    testMode: session.isTest,
+    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
+    authKey: session.authKey,
+    self: {
+      userId: session.userId,
+      isBot: session.isBot,
+      isPremium: false,
+      usernames: []
+    }
+  };
+}
+function convertToPyrogramSession(session, params) {
+  if (typeof session === "string") {
+    session = utils_js.readStringSession(session);
+  }
+  return serializePyrogramSession({
+    apiId: params?.apiId,
+    isBot: session.self?.isBot ?? false,
+    isTest: session.testMode,
+    userId: session.self?.userId ?? 0,
+    dcId: session.primaryDcs.main.id,
+    authKey: session.authKey
+  });
+}
+exports.DC_MAPPING_PROD = DC_MAPPING_PROD;
+exports.DC_MAPPING_TEST = DC_MAPPING_TEST;
+exports.convertFromGramjsSession = convertFromGramjsSession;
+exports.convertFromMtkrutoSession = convertFromMtkrutoSession;
+exports.convertFromPyrogramSession = convertFromPyrogramSession;
+exports.convertFromTelethonSession = convertFromTelethonSession;
+exports.convertToGramjsSession = convertToGramjsSession;
+exports.convertToMtkrutoSession = convertToMtkrutoSession;
+exports.convertToPyrogramSession = convertToPyrogramSession;
+exports.convertToTelethonSession = convertToTelethonSession;
+exports.isTestDc = isTestDc;
+exports.parseGramjsSession = parseGramjsSession;
+exports.parseMtkrutoSession = parseMtkrutoSession;
+exports.parsePyrogramSession = parsePyrogramSession;
+exports.parseTelethonSession = parseTelethonSession;
+exports.serializeGramjsSession = serializeGramjsSession;
+exports.serializeMtkrutoSession = serializeMtkrutoSession;
+exports.serializePyrogramSession = serializePyrogramSession;
+exports.serializeTelethonSession = serializeTelethonSession;

package/index.d.ts

@@ -1 +1,5 @@
-export * from './esm/index.js'
+export * from './dcs.js';
+export * from './gramjs/index.js';
+export * from './mtkruto/index.js';
+export * from './pyrogram/index.js';
+export * from './telethon/index.js';