@mtcute/core 0.17.1 → 0.18.0

package/highlevel/methods/users/iter-profile-photos.cjs

@@ -0,0 +1,29 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getProfilePhotos = require("./get-profile-photos.cjs");
+const resolvePeer = require("./resolve-peer.cjs");
+async function* iterProfilePhotos(client, userId, params) {
+  if (!params) params = {};
+  const peer = await resolvePeer.resolveUser(client, userId);
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await getProfilePhotos.getProfilePhotos(client, peer, {
+      offset,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    for (const it of res) {
+      yield it;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+exports.iterProfilePhotos = iterProfilePhotos;

package/highlevel/methods/users/iter-profile-photos.d.cts

@@ -0,0 +1,23 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Photo } from '../../types/index.js';
+import { getProfilePhotos } from './get-profile-photos.js';
+/**
+ * Iterate over profile photos
+ *
+ * @param userId  User ID, username, phone number, `"me"` or `"self"`
+ * @param params
+ */
+export declare function iterProfilePhotos(client: ITelegramClient, userId: InputPeerLike, params?: Parameters<typeof getProfilePhotos>[2] & {
+    /**
+     * Maximum number of items to fetch
+     *
+     * @default  `Infinity`, i.e. all items are fetched
+     */
+    limit?: number;
+    /**
+     * Size of chunks which are fetched. Usually not needed.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Photo>;

package/highlevel/methods/users/iter-profile-photos.js

@@ -0,0 +1,24 @@
+import { getProfilePhotos } from "./get-profile-photos.js";
+import { resolveUser } from "./resolve-peer.js";
+async function* iterProfilePhotos(client, userId, params) {
+  if (!params) params = {};
+  const peer = await resolveUser(client, userId);
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await getProfilePhotos(client, peer, {
+      offset,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    for (const it of res) {
+      yield it;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+export {
+  iterProfilePhotos
+};

package/highlevel/methods/users/resolve-peer-many.cjs

@@ -0,0 +1,84 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const errors = require("../../types/errors.cjs");
+const resolvePeer = require("./resolve-peer.cjs");
+async function resolvePeerMany(client, peerIds, normalizer) {
+  const ret = [];
+  const limit = 8;
+  if (peerIds.length < limit) {
+    const res = await Promise.all(
+      peerIds.map(
+        (it) => resolvePeer.resolvePeer(client, it).catch((e) => {
+          if (e instanceof errors.MtPeerNotFoundError) {
+            return null;
+          }
+          throw e;
+        })
+      )
+    );
+    if (!normalizer) return res;
+    for (const value of res) {
+      if (!value) continue;
+      const norm = normalizer(value);
+      if (norm) {
+        ret.push(norm);
+      }
+    }
+    return ret;
+  }
+  const cv = new utils.ConditionVariable();
+  const buffer = {};
+  let nextIdx = 0;
+  let nextWorkerIdx = 0;
+  const fetchNext = async (idx = nextWorkerIdx++) => {
+    try {
+      const result = await resolvePeer.resolvePeer(client, peerIds[idx]);
+      buffer[idx] = result;
+    } catch (e) {
+      if (e instanceof errors.MtPeerNotFoundError) {
+        buffer[idx] = null;
+      } else {
+        throw e;
+      }
+    }
+    if (nextIdx === idx) {
+      cv.notify();
+    }
+    if (nextWorkerIdx < peerIds.length) {
+      await fetchNext(nextWorkerIdx++);
+    }
+  };
+  let error;
+  void Promise.all(Array.from({ length: limit }, (_, i) => fetchNext(i))).catch((e) => {
+    client.log.debug("resolvePeerMany errored: %e", e);
+    error = e;
+    cv.notify();
+  });
+  while (nextIdx < peerIds.length) {
+    await cv.wait();
+    if (error) throw error;
+    while (nextIdx in buffer) {
+      const buf = buffer[nextIdx];
+      delete buffer[nextIdx];
+      nextIdx++;
+      if (!normalizer) {
+        ret.push(buf);
+        continue;
+      }
+      if (buf !== null) {
+        const norm = normalizer(buf);
+        if (norm) {
+          ret.push(norm);
+        }
+      }
+    }
+  }
+  return ret;
+}
+exports.resolvePeerMany = resolvePeerMany;

package/highlevel/methods/users/resolve-peer-many.d.cts

@@ -0,0 +1,26 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+/**
+ * Get multiple `InputPeer`s at once,
+ * while also normalizing and removing
+ * peers that can't be normalized to that type.
+ *
+ * If a peer was not found, it will be skipped.
+ *
+ * Uses async pool internally, with a concurrent limit of 8
+ *
+ * @param peerIds  Peer Ids
+ * @param normalizer  Normalization function
+ */
+export declare function resolvePeerMany<T extends tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel>(client: ITelegramClient, peerIds: InputPeerLike[], normalizer: (obj: tl.TypeInputPeer) => T | null): Promise<T[]>;
+/**
+ * Get multiple `InputPeer`s at once.
+ *
+ * If a peer was not found, `null` will be returned instead
+ *
+ * Uses async pool internally, with a concurrent limit of 8
+ *
+ * @param peerIds  Peer Ids
+ */
+export declare function resolvePeerMany(client: ITelegramClient, peerIds: InputPeerLike[]): Promise<(tl.TypeInputPeer | null)[]>;

package/highlevel/methods/users/resolve-peer-many.js

@@ -0,0 +1,79 @@
+import { ConditionVariable } from "@fuman/utils";
+import { MtPeerNotFoundError } from "../../types/errors.js";
+import { resolvePeer } from "./resolve-peer.js";
+async function resolvePeerMany(client, peerIds, normalizer) {
+  const ret = [];
+  const limit = 8;
+  if (peerIds.length < limit) {
+    const res = await Promise.all(
+      peerIds.map(
+        (it) => resolvePeer(client, it).catch((e) => {
+          if (e instanceof MtPeerNotFoundError) {
+            return null;
+          }
+          throw e;
+        })
+      )
+    );
+    if (!normalizer) return res;
+    for (const value of res) {
+      if (!value) continue;
+      const norm = normalizer(value);
+      if (norm) {
+        ret.push(norm);
+      }
+    }
+    return ret;
+  }
+  const cv = new ConditionVariable();
+  const buffer = {};
+  let nextIdx = 0;
+  let nextWorkerIdx = 0;
+  const fetchNext = async (idx = nextWorkerIdx++) => {
+    try {
+      const result = await resolvePeer(client, peerIds[idx]);
+      buffer[idx] = result;
+    } catch (e) {
+      if (e instanceof MtPeerNotFoundError) {
+        buffer[idx] = null;
+      } else {
+        throw e;
+      }
+    }
+    if (nextIdx === idx) {
+      cv.notify();
+    }
+    if (nextWorkerIdx < peerIds.length) {
+      await fetchNext(nextWorkerIdx++);
+    }
+  };
+  let error;
+  void Promise.all(Array.from({ length: limit }, (_, i) => fetchNext(i))).catch((e) => {
+    client.log.debug("resolvePeerMany errored: %e", e);
+    error = e;
+    cv.notify();
+  });
+  while (nextIdx < peerIds.length) {
+    await cv.wait();
+    if (error) throw error;
+    while (nextIdx in buffer) {
+      const buf = buffer[nextIdx];
+      delete buffer[nextIdx];
+      nextIdx++;
+      if (!normalizer) {
+        ret.push(buf);
+        continue;
+      }
+      if (buf !== null) {
+        const norm = normalizer(buf);
+        if (norm) {
+          ret.push(norm);
+        }
+      }
+    }
+  }
+  return ret;
+}
+export {
+  resolvePeerMany
+};

package/highlevel/methods/users/resolve-peer.cjs

@@ -0,0 +1,200 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tl = require("@mtcute/tl");
+const Long = require("long");
+const errors$1 = require("../../../types/errors.cjs");
+const peerUtils$1 = require("../../../utils/peer-utils.cjs");
+const errors = require("../../types/errors.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const batchedQueries = require("../chats/batched-queries.cjs");
+function _normalizePeerId(peerId) {
+  if (typeof peerId === "object") {
+    if (tl.tl.isAnyPeer(peerId)) {
+      peerId = peerUtils$1.getMarkedPeerId(peerId);
+    } else if ("inputPeer" in peerId) {
+      peerId = peerId.inputPeer;
+    } else {
+      peerId = peerUtils.toInputPeer(peerId);
+    }
+  }
+  if (typeof peerId === "object") {
+    switch (peerId._) {
+      case "mtcute.dummyInputPeerMinUser":
+        return peerId.userId;
+      case "mtcute.dummyInputPeerMinChannel":
+        return peerUtils$1.toggleChannelIdMark(peerId.channelId);
+      default:
+        return peerId;
+    }
+  }
+  return peerId;
+}
+async function resolvePeer(client, peerId, force = false) {
+  peerId = _normalizePeerId(peerId);
+  if (typeof peerId === "object") {
+    return peerId;
+  }
+  if (typeof peerId === "number" && !force) {
+    const fromStorage = await client.storage.peers.getById(peerId);
+    if (fromStorage) return fromStorage;
+  }
+  if (typeof peerId === "string") {
+    if (peerId === "self" || peerId === "me") return { _: "inputPeerSelf" };
+    peerId = peerId.replace(/[@+\s()]/g, "");
+    let res;
+    if (peerId.match(/^\d+$/)) {
+      const fromStorage = await client.storage.peers.getByPhone(peerId);
+      if (fromStorage) return fromStorage;
+      try {
+        res = await client.call({
+          _: "contacts.resolvePhone",
+          phone: peerId
+        });
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "PHONE_NOT_OCCUPIED")) {
+          throw new errors.MtPeerNotFoundError(`Peer with phone number ${peerId} was not found`);
+        } else {
+          throw e;
+        }
+      }
+    } else {
+      if (!force) {
+        const fromStorage = await client.storage.peers.getByUsername(peerId);
+        if (fromStorage) return fromStorage;
+      }
+      try {
+        res = await client.call({
+          _: "contacts.resolveUsername",
+          username: peerId
+        });
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "USERNAME_NOT_OCCUPIED")) {
+          throw new errors.MtPeerNotFoundError(`Peer with username ${peerId} was not found`);
+        } else {
+          throw e;
+        }
+      }
+    }
+    if (res.peer._ === "peerUser") {
+      const id = res.peer.userId;
+      const found = res.users.find((it) => it.id === id);
+      if (found && found._ === "user") {
+        if (!found.accessHash) {
+          throw new errors.MtPeerNotFoundError(
+            `Peer (user) with username ${peerId} was found, but it has no access hash`
+          );
+        }
+        return {
+          _: "inputPeerUser",
+          userId: found.id,
+          accessHash: found.accessHash
+        };
+      }
+    } else if (res.peer._ === "peerChannel") {
+      const id = res.peer.channelId;
+      const found = res.chats.find((it) => it.id === id);
+      if (found) {
+        if (!(found._ === "channel" || found._ === "channelForbidden")) {
+          throw new errors$1.MtTypeAssertionError("contacts.resolveUsername#chats", "channel", found._);
+        }
+        if (!found.accessHash) {
+          throw new errors.MtPeerNotFoundError(`Peer (channel) with ${peerId} was found, but it has no access hash`);
+        }
+        return {
+          _: "inputPeerChannel",
+          channelId: found.id,
+          accessHash: found.accessHash
+        };
+      }
+    } else {
+      throw new errors$1.MtTypeAssertionError("contacts.resolveUsername", "user or channel", res.peer._);
+    }
+    throw new errors.MtPeerNotFoundError(`Could not find a peer by ${peerId}`);
+  }
+  const [peerType, bareId] = peerUtils$1.parseMarkedPeerId(peerId);
+  if (peerType === "chat" || client.storage.self.getCached(true)?.isBot) {
+    switch (peerType) {
+      case "user":
+        return {
+          _: "inputPeerUser",
+          userId: bareId,
+          accessHash: Long.ZERO
+        };
+      case "chat":
+        return {
+          _: "inputPeerChat",
+          chatId: bareId
+        };
+      case "channel":
+        return {
+          _: "inputPeerChannel",
+          channelId: bareId,
+          accessHash: Long.ZERO
+        };
+    }
+  }
+  const cached = await client.storage.peers.getCompleteById(peerId, true);
+  if (cached && (cached._ === "channel" || cached._ === "user")) {
+    const [username] = peerUtils.extractUsernames(cached);
+    if (username) {
+      const resolved = await resolvePeer(client, username, true);
+      if (peerUtils$1.getMarkedPeerId(resolved) === peerId) {
+        return resolved;
+      }
+    }
+    if (cached._ === "user" && cached.phone) {
+      const resolved = await resolvePeer(client, cached.phone, true);
+      if (peerUtils$1.getMarkedPeerId(resolved) === peerId) {
+        return resolved;
+      }
+    }
+  }
+  switch (peerType) {
+    case "user": {
+      const res = await batchedQueries._getUsersBatched(client, {
+        _: "inputUser",
+        userId: bareId,
+        accessHash: Long.ZERO
+      });
+      if (res != null && res._ === "user" && res.accessHash != null) {
+        return {
+          _: "inputPeerUser",
+          userId: bareId,
+          accessHash: res.accessHash
+        };
+      }
+      break;
+    }
+    case "channel": {
+      const res = await batchedQueries._getChannelsBatched(client, {
+        _: "inputChannel",
+        channelId: bareId,
+        accessHash: Long.ZERO
+      });
+      if (res != null && res._ === "channel" && res.accessHash != null) {
+        return {
+          _: "inputPeerChannel",
+          channelId: bareId,
+          accessHash: res.accessHash
+        };
+      }
+      break;
+    }
+  }
+  throw new errors.MtPeerNotFoundError(`Peer ${peerId} is not found in local cache`);
+}
+async function resolveUser(client, peerId, force = false) {
+  return peerUtils.toInputUser(await resolvePeer(client, peerId, force), peerId);
+}
+async function resolveChannel(client, peerId, force = false) {
+  return peerUtils.toInputChannel(await resolvePeer(client, peerId, force), peerId);
+}
+exports._normalizePeerId = _normalizePeerId;
+exports.resolveChannel = resolveChannel;
+exports.resolvePeer = resolvePeer;
+exports.resolveUser = resolveUser;

package/highlevel/methods/users/resolve-peer.d.cts

@@ -0,0 +1,20 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { tl } from '@mtcute/tl';
+export declare function _normalizePeerId(peerId: InputPeerLike): number | string | tl.TypeInputPeer;
+/**
+ * Get the `InputPeer` of a known peer id.
+ * Useful when an `InputPeer` is needed in Raw API.
+ *
+ * @param peerId  The peer identifier that you want to extract the `InputPeer` from.
+ * @param force  Whether to force re-fetch the peer from the server (only for usernames and phone numbers)
+ */
+export declare function resolvePeer(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputPeer>;
+/**
+ * Shorthand for `resolvePeer` that converts the input peer to `InputUser`.
+ */
+export declare function resolveUser(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputUser>;
+/**
+ * Shorthand for `resolvePeer` that converts the input peer to `InputChannel`.
+ */
+export declare function resolveChannel(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputChannel>;

package/highlevel/methods/users/resolve-peer.d.ts

@@ -1,6 +1,6 @@
-import { tl } from '@mtcute/tl';
 import { ITelegramClient } from '../../client.types.js';
 import { InputPeerLike } from '../../types/peers/index.js';
+import { tl } from '@mtcute/tl';
 export declare function _normalizePeerId(peerId: InputPeerLike): number | string | tl.TypeInputPeer;
 /**
  * Get the `InputPeer` of a known peer id.

package/highlevel/methods/users/resolve-peer.js

@@ -0,0 +1,195 @@
+import { tl } from "@mtcute/tl";
+import Long from "long";
+import { MtTypeAssertionError } from "../../../types/errors.js";
+import { getMarkedPeerId, toggleChannelIdMark, parseMarkedPeerId } from "../../../utils/peer-utils.js";
+import { MtPeerNotFoundError } from "../../types/errors.js";
+import { toInputUser, toInputPeer, extractUsernames, toInputChannel } from "../../utils/peer-utils.js";
+import { _getChannelsBatched, _getUsersBatched } from "../chats/batched-queries.js";
+function _normalizePeerId(peerId) {
+  if (typeof peerId === "object") {
+    if (tl.isAnyPeer(peerId)) {
+      peerId = getMarkedPeerId(peerId);
+    } else if ("inputPeer" in peerId) {
+      peerId = peerId.inputPeer;
+    } else {
+      peerId = toInputPeer(peerId);
+    }
+  }
+  if (typeof peerId === "object") {
+    switch (peerId._) {
+      case "mtcute.dummyInputPeerMinUser":
+        return peerId.userId;
+      case "mtcute.dummyInputPeerMinChannel":
+        return toggleChannelIdMark(peerId.channelId);
+      default:
+        return peerId;
+    }
+  }
+  return peerId;
+}
+async function resolvePeer(client, peerId, force = false) {
+  peerId = _normalizePeerId(peerId);
+  if (typeof peerId === "object") {
+    return peerId;
+  }
+  if (typeof peerId === "number" && !force) {
+    const fromStorage = await client.storage.peers.getById(peerId);
+    if (fromStorage) return fromStorage;
+  }
+  if (typeof peerId === "string") {
+    if (peerId === "self" || peerId === "me") return { _: "inputPeerSelf" };
+    peerId = peerId.replace(/[@+\s()]/g, "");
+    let res;
+    if (peerId.match(/^\d+$/)) {
+      const fromStorage = await client.storage.peers.getByPhone(peerId);
+      if (fromStorage) return fromStorage;
+      try {
+        res = await client.call({
+          _: "contacts.resolvePhone",
+          phone: peerId
+        });
+      } catch (e) {
+        if (tl.RpcError.is(e, "PHONE_NOT_OCCUPIED")) {
+          throw new MtPeerNotFoundError(`Peer with phone number ${peerId} was not found`);
+        } else {
+          throw e;
+        }
+      }
+    } else {
+      if (!force) {
+        const fromStorage = await client.storage.peers.getByUsername(peerId);
+        if (fromStorage) return fromStorage;
+      }
+      try {
+        res = await client.call({
+          _: "contacts.resolveUsername",
+          username: peerId
+        });
+      } catch (e) {
+        if (tl.RpcError.is(e, "USERNAME_NOT_OCCUPIED")) {
+          throw new MtPeerNotFoundError(`Peer with username ${peerId} was not found`);
+        } else {
+          throw e;
+        }
+      }
+    }
+    if (res.peer._ === "peerUser") {
+      const id = res.peer.userId;
+      const found = res.users.find((it) => it.id === id);
+      if (found && found._ === "user") {
+        if (!found.accessHash) {
+          throw new MtPeerNotFoundError(
+            `Peer (user) with username ${peerId} was found, but it has no access hash`
+          );
+        }
+        return {
+          _: "inputPeerUser",
+          userId: found.id,
+          accessHash: found.accessHash
+        };
+      }
+    } else if (res.peer._ === "peerChannel") {
+      const id = res.peer.channelId;
+      const found = res.chats.find((it) => it.id === id);
+      if (found) {
+        if (!(found._ === "channel" || found._ === "channelForbidden")) {
+          throw new MtTypeAssertionError("contacts.resolveUsername#chats", "channel", found._);
+        }
+        if (!found.accessHash) {
+          throw new MtPeerNotFoundError(`Peer (channel) with ${peerId} was found, but it has no access hash`);
+        }
+        return {
+          _: "inputPeerChannel",
+          channelId: found.id,
+          accessHash: found.accessHash
+        };
+      }
+    } else {
+      throw new MtTypeAssertionError("contacts.resolveUsername", "user or channel", res.peer._);
+    }
+    throw new MtPeerNotFoundError(`Could not find a peer by ${peerId}`);
+  }
+  const [peerType, bareId] = parseMarkedPeerId(peerId);
+  if (peerType === "chat" || client.storage.self.getCached(true)?.isBot) {
+    switch (peerType) {
+      case "user":
+        return {
+          _: "inputPeerUser",
+          userId: bareId,
+          accessHash: Long.ZERO
+        };
+      case "chat":
+        return {
+          _: "inputPeerChat",
+          chatId: bareId
+        };
+      case "channel":
+        return {
+          _: "inputPeerChannel",
+          channelId: bareId,
+          accessHash: Long.ZERO
+        };
+    }
+  }
+  const cached = await client.storage.peers.getCompleteById(peerId, true);
+  if (cached && (cached._ === "channel" || cached._ === "user")) {
+    const [username] = extractUsernames(cached);
+    if (username) {
+      const resolved = await resolvePeer(client, username, true);
+      if (getMarkedPeerId(resolved) === peerId) {
+        return resolved;
+      }
+    }
+    if (cached._ === "user" && cached.phone) {
+      const resolved = await resolvePeer(client, cached.phone, true);
+      if (getMarkedPeerId(resolved) === peerId) {
+        return resolved;
+      }
+    }
+  }
+  switch (peerType) {
+    case "user": {
+      const res = await _getUsersBatched(client, {
+        _: "inputUser",
+        userId: bareId,
+        accessHash: Long.ZERO
+      });
+      if (res != null && res._ === "user" && res.accessHash != null) {
+        return {
+          _: "inputPeerUser",
+          userId: bareId,
+          accessHash: res.accessHash
+        };
+      }
+      break;
+    }
+    case "channel": {
+      const res = await _getChannelsBatched(client, {
+        _: "inputChannel",
+        channelId: bareId,
+        accessHash: Long.ZERO
+      });
+      if (res != null && res._ === "channel" && res.accessHash != null) {
+        return {
+          _: "inputPeerChannel",
+          channelId: bareId,
+          accessHash: res.accessHash
+        };
+      }
+      break;
+    }
+  }
+  throw new MtPeerNotFoundError(`Peer ${peerId} is not found in local cache`);
+}
+async function resolveUser(client, peerId, force = false) {
+  return toInputUser(await resolvePeer(client, peerId, force), peerId);
+}
+async function resolveChannel(client, peerId, force = false) {
+  return toInputChannel(await resolvePeer(client, peerId, force), peerId);
+}
+export {
+  _normalizePeerId,
+  resolveChannel,
+  resolvePeer,
+  resolveUser
+};