@mtcute/test 0.16.7 → 0.16.13

package/index.js

@@ -1,9 +1,862 @@
-export * from './client.js';
-export * from './crypto.js';
-export * from './platform.js';
-export * from './storage.js';
-export * from './storage/index.js';
-export * from './stub.js';
-export * from './transport.js';
-export * from './types.js';
-//# sourceMappingURL=index.js.map
+import { MemoryStorage, MtArgumentError, TransportState, parseMarkedPeerId, tl } from "@mtcute/core";
+import { BaseTelegramClient } from "@mtcute/core/client.js";
+import { WebPlatform, WebCryptoProvider } from "@mtcute/web";
+import { createAesIgeForMessage, dataViewFromBuffer, TlBinaryWriter } from "@mtcute/core/utils.js";
+import EventEmitter from "node:events";
+import { gzipSync, inflateSync } from "node:zlib";
+import { beforeEach, vi, afterEach, beforeAll, it, expect, describe } from "vitest";
+import { getPlatform } from "@mtcute/core/platform.js";
+import Long from "long";
+import * as schema_ from "@mtcute/tl/api-schema.json";
+import { __tlWriterMap } from "@mtcute/tl/binary/writer.js";
+const defaultPlatform = new WebPlatform();
+const defaultCryptoProvider = new WebCryptoProvider();
+class StubMemoryTelegramStorage extends MemoryStorage {
+  constructor(params = {
+    hasKeys: true,
+    hasTempKeys: true
+  }) {
+    super();
+    this.params = params;
+    const _origGet = this.authKeys.get;
+    this.authKeys.get = (dcId) => {
+      if (this.params.hasKeys) {
+        if (this.params.hasKeys === true || this.params.hasKeys.includes(dcId)) {
+          return new Uint8Array(256);
+        }
+      }
+      return _origGet.call(this.authKeys, dcId);
+    };
+    const _origGetTemp = this.authKeys.getTemp;
+    this.authKeys.getTemp = (dcId, idx, now) => {
+      if (this.params.hasTempKeys) {
+        if (this.params.hasTempKeys === true || this.params.hasTempKeys.includes(dcId)) {
+          return new Uint8Array(256);
+        }
+      }
+      return _origGetTemp.call(this.authKeys, dcId, idx, now);
+    };
+  }
+  decryptOutgoingMessage(crypto, data, dcId, tempIndex) {
+    const key = tempIndex ? this.authKeys.getTemp(dcId, tempIndex, Date.now()) : this.authKeys.get(dcId);
+    if (!key) {
+      throw new MtArgumentError(`No auth key for DC ${dcId}`);
+    }
+    const messageKey = data.subarray(8, 24);
+    const encryptedData = data.subarray(24);
+    const ige = createAesIgeForMessage(crypto, key, messageKey, true);
+    const innerData = ige.decrypt(encryptedData);
+    const dv = new DataView(innerData.buffer, innerData.byteOffset, innerData.byteLength);
+    const length = dv.getUint32(28, true);
+    return innerData.subarray(32, 32 + length);
+  }
+}
+class StubTelegramTransport extends EventEmitter {
+  constructor(params) {
+    super();
+    this.params = params;
+    if (params.getMtproxyInfo) {
+      this.getMtproxyInfo = params.getMtproxyInfo;
+    }
+  }
+  _state = TransportState.Idle;
+  _currentDc = null;
+  _crypto;
+  _log;
+  write(data) {
+    this.emit("message", data);
+  }
+  setup(crypto, log) {
+    this._crypto = crypto;
+    this._log = log;
+  }
+  state() {
+    return this._state;
+  }
+  currentDc() {
+    return this._currentDc;
+  }
+  connect(dc, testMode) {
+    this._currentDc = dc;
+    this._state = TransportState.Ready;
+    this.emit("ready");
+    this._log.debug("stubbing connection to %s:%d", dc.ipAddress, dc.port);
+    this.params.onConnect?.(dc, testMode);
+  }
+  close() {
+    this._currentDc = null;
+    this._state = TransportState.Idle;
+    this.emit("close");
+    this._log.debug("stub connection closed");
+    this.params.onClose?.();
+  }
+  async send(data) {
+    this.params.onMessage?.(data);
+  }
+}
+function markedIdToPeer(id) {
+  const [type, bareId] = parseMarkedPeerId(id);
+  switch (type) {
+    case "user":
+      return { _: "peerUser", userId: bareId };
+    case "chat":
+      return { _: "peerChat", chatId: bareId };
+    case "channel":
+      return { _: "peerChannel", channelId: bareId };
+  }
+}
+class StubTelegramClient extends BaseTelegramClient {
+  constructor(params) {
+    const storage = new StubMemoryTelegramStorage({
+      hasKeys: true,
+      hasTempKeys: true
+    });
+    super({
+      apiId: 0,
+      apiHash: "",
+      logLevel: 5,
+      storage,
+      disableUpdates: true,
+      transport: () => {
+        const transport = new StubTelegramTransport({
+          onMessage: (data) => {
+            if (!this._onRawMessage) {
+              if (this._responders.size) {
+                this.emitError(new Error("Unexpected outgoing message"));
+              }
+              return;
+            }
+            const dcId = transport._currentDc.id;
+            const key = storage.authKeys.get(dcId);
+            if (key) {
+              this._onRawMessage(storage.decryptOutgoingMessage(transport._crypto, data, dcId));
+            }
+          }
+        });
+        return transport;
+      },
+      crypto: defaultCryptoProvider,
+      ...params
+    });
+  }
+  /**
+   * Create a fake client that may not actually be used for API calls
+   *
+   * Useful for testing "offline" methods
+   */
+  static offline() {
+    const client = new StubTelegramClient();
+    client.call = (obj) => {
+      throw new Error(`Expected offline client to not make any API calls (method called: ${obj._})`);
+    };
+    return client;
+  }
+  /**
+   * Create a fake "full" client (i.e. TelegramClient)
+   *
+   * Basically a proxy that returns an empty function for every unknown method
+   */
+  static full() {
+    const client = new StubTelegramClient();
+    return new Proxy(client, {
+      get(target, prop) {
+        if (typeof prop === "string" && !(prop in target)) {
+          return () => {
+          };
+        }
+        return target[prop];
+      }
+    });
+  }
+  // some fake peers handling //
+  _knownChats = /* @__PURE__ */ new Map();
+  _knownUsers = /* @__PURE__ */ new Map();
+  _selfId = 0;
+  async registerPeers(...peers) {
+    for (const peer of peers) {
+      if (tl.isAnyUser(peer)) {
+        this._knownUsers.set(peer.id, peer);
+      } else {
+        this._knownChats.set(peer.id, peer);
+      }
+      await this.storage.peers.updatePeersFrom(peer);
+    }
+  }
+  getPeers(ids) {
+    const users = [];
+    const chats = [];
+    for (let id of ids) {
+      if (!id) continue;
+      if (typeof id === "number") {
+        id = markedIdToPeer(id);
+      }
+      switch (id._) {
+        case "peerUser": {
+          const user = this._knownUsers.get(id.userId);
+          if (!user) throw new Error(`Unknown user with ID ${id.userId}`);
+          users.push(user);
+          break;
+        }
+        case "peerChat": {
+          const chat = this._knownChats.get(id.chatId);
+          if (!chat) throw new Error(`Unknown chat with ID ${id.chatId}`);
+          chats.push(chat);
+          break;
+        }
+        case "peerChannel": {
+          const chat = this._knownChats.get(id.channelId);
+          if (!chat) throw new Error(`Unknown channel with ID ${id.channelId}`);
+          chats.push(chat);
+          break;
+        }
+      }
+    }
+    return { users, chats };
+  }
+  // method calls intercepting //
+  _onRawMessage;
+  onRawMessage(fn) {
+    this._onRawMessage = fn;
+  }
+  _responders = /* @__PURE__ */ new Map();
+  addResponder(responders) {
+    if (Array.isArray(responders)) {
+      for (const responder2 of responders) {
+        this.addResponder(responder2);
+      }
+      return;
+    }
+    if (typeof responders === "function") {
+      responders = responders(this);
+    }
+    const [method, responder] = responders;
+    this.respondWith(method, responder);
+  }
+  respondWith(method, response) {
+    this._responders.set(method, response);
+    return response;
+  }
+  async call(message, params) {
+    if (this._responders.has(message._)) {
+      return Promise.resolve(this._responders.get(message._)(message));
+    }
+    return super.call(message, params);
+  }
+  // some fake updates mechanism //
+  _fakeMessageBoxes = /* @__PURE__ */ new Map();
+  _lastQts = 0;
+  _lastDate = Math.floor(Date.now() / 1e3);
+  _lastSeq = 0;
+  getMessageBox(chatId = 0) {
+    const state = this._fakeMessageBoxes.get(chatId);
+    if (!state) {
+      const newState = { pts: 0, lastMessageId: 0 };
+      this._fakeMessageBoxes.set(chatId, newState);
+      return newState;
+    }
+    return state;
+  }
+  getNextMessageId(chatId = 0) {
+    const state = this.getMessageBox(chatId);
+    const nextId = state.lastMessageId + 1;
+    state.lastMessageId = nextId;
+    return nextId;
+  }
+  getNextPts(chatId = 0, count = 1) {
+    const state = this.getMessageBox(chatId);
+    const nextPts = state.pts + count;
+    state.pts = nextPts;
+    return nextPts;
+  }
+  getNextQts() {
+    return this._lastQts++;
+  }
+  getNextDate() {
+    return this._lastDate = Math.floor(Date.now() / 1e3);
+  }
+  createStubUpdates(params) {
+    const { peers, updates, seq = 0, seqCount = 1 } = params;
+    const { users, chats } = this.getPeers(peers ?? []);
+    const seqStart = seq - seqCount + 1;
+    if (seq !== 0) {
+      this._lastSeq = seq + seqCount;
+    }
+    if (seqStart !== seq) {
+      return {
+        _: "updatesCombined",
+        updates,
+        users,
+        chats,
+        date: this.getNextDate(),
+        seq,
+        seqStart
+      };
+    }
+    return {
+      _: "updates",
+      updates,
+      users,
+      chats,
+      date: this.getNextDate(),
+      seq
+    };
+  }
+  // helpers //
+  async with(fn) {
+    await this.connect();
+    let error;
+    this.onError((err) => {
+      error = err;
+    });
+    try {
+      await fn();
+    } catch (e) {
+      error = e;
+    }
+    await this.close();
+    if (error) {
+      throw error;
+    }
+  }
+}
+const DEFAULT_ENTROPY = `
+29afd26df40fb8ed10b6b4ad6d56ef5df9453f88e6ee6adb6e0544ba635dc6a8a990c9b8b980c343936b33fa7f97bae025102532233abb269c489920ef99021b
+259ce3a2c964c5c8972b4a84ff96f3375a94b535a9468f2896e2080ac7a32ed58e910474a4b02415e07671cbb5bdd58a5dd26fd137c4c98b8c346571fae6ead3
+9dfd612bd6b480b6723433f5218e9d6e271591153fb3ffefc089f7e848d3f4633459fff66b33cf939e5655813149fa34be8625f9bc4814d1ee6cf40e4d0de229
+1aa22e68c8ad8cc698103734f9aaf79f2bdc052a787a7a9b3629d1ed38750f88cb0481c0ba30a9c611672f9a4d1dc02637abb4e98913ee810a3b152d3d75f25d
+7efdc263c08833569968b1771ebbe843d187e2c917d9ad8e8865e44b69f7b74d72ab86a4ef1891dce196ee11a7c9d7d8074fc0450e745bd3a827d77bb0820b90
+3055dc15f0abd897ea740a99606b64d28968d770b5e43492ddbf07a7c75104d3e522be9b72050c0fdae8412cdf49014be21105b87a06cb7202dd580387adc007
+6280d98b015a1a413819d817f007939d1490467a1ef85a345584c7e594bb729c12a1233f806e515e7088360219dfa109264310ba84777b93eb1ad3c40727a25a
+a5d9cdd6748c6ab2ca0bd4daa2ba8225bce2b066a163bcacf05609fc84055bb86a4742c28addd7d7ab8d87b64cfde0b3f4b3bc8e05f3d0a1a2fadb294860e099
+a10b3721b0d5b28918b8fb49a18a82a0fde6680a64ed915637805e35ffe8b2c1d4177ec10d10eaaf24425e0351b6a89e794944e1aa82eb5c0210a37da66cccac
+895398cf915a8aa141f611521fc258514a99c02721113942c66f2c9a8f9601ff0044a953d17a47b07ad1b5f8725cc020a1a5239be65db0a43d42c206903740f0
+27c3f749ecfff2e646570118cd54db2fec392b44d8eb8377309f3e4d164dbc0530914b117b9d278b06db8359d97442d4dcbcaff93cd9a08a6b06a5ba8725d0d7
+06b313a5d792be254d33e087b7a4fafcdf819941b9bec4c6057d4c050bd01eb243efd4e6b707281b127820a2b734c6d8f6b2131bf0b5b215c7a798ff3fe90ceb
+da91539fcc7b03d2b8b1381bd6023fff20278344ad944d364ba684842db3901c346335f0d455eda414f99c1e794a86aa3a90bcc6e085eecb0b4bf61198d16ed3
+89cfa495f977a37a51502b2f60649f2efd7d89c757b6366776ba4c0612017bf1fbfc682dd62e9960d39cbea854d2dcc708b1db5d268192954d13ee72c0bb1bd8
+558a3cf3b02b1cd795b40f7a57780391bb8724883d3f7764846c3823e165b3f8c025f59d896905f9a955478586ce57f820d958a01aa59a4cace7ecdf125df334
+fa3de8e50aac96c1275591a1221c32a60a1513370a33a228e00894341b10cf44a6ae6ac250d17a364e956ab1a17b068df3fb2d5b5a672d8a409eeb8b6ca1ade6
+`.replace(/\s/g, "");
+function withFakeRandom(provider, source = DEFAULT_ENTROPY) {
+  const sourceBytes = getPlatform().hexDecode(source);
+  let offset = 0;
+  function getRandomValues(buf) {
+    if (offset + buf.length > sourceBytes.length) {
+      throw new Error("not enough entropy");
+    }
+    buf.set(sourceBytes.subarray(offset, offset + buf.length));
+    offset += buf.length;
+  }
+  return new Proxy(provider, {
+    get(target, prop, receiver) {
+      if (prop === "randomFill") return getRandomValues;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function useFakeMathRandom(source = DEFAULT_ENTROPY) {
+  const sourceBytes = getPlatform().hexDecode(source);
+  const dv = dataViewFromBuffer(sourceBytes);
+  let spy;
+  beforeEach(() => {
+    let offset = 0;
+    spy = vi.spyOn(globalThis.Math, "random").mockImplementation(() => {
+      const ret = dv.getUint32(offset, true) / 4294967295;
+      offset += 4;
+      return ret;
+    });
+  });
+  afterEach(() => {
+    spy.mockRestore();
+  });
+}
+async function defaultTestCryptoProvider(source = DEFAULT_ENTROPY) {
+  const prov = withFakeRandom(defaultCryptoProvider, source);
+  await prov.initialize?.();
+  return prov;
+}
+function testCryptoProvider(c) {
+  beforeAll(() => c.initialize?.());
+  const p = getPlatform();
+  function gzipSyncWrap(data) {
+    return gzipSync(data);
+  }
+  function inflateSyncWrap(data) {
+    return inflateSync(data);
+  }
+  it("should calculate sha1", () => {
+    expect(p.hexEncode(c.sha1(p.utf8Encode("")))).to.eq("da39a3ee5e6b4b0d3255bfef95601890afd80709");
+    expect(p.hexEncode(c.sha1(p.utf8Encode("hello")))).to.eq("aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d");
+    expect(p.hexEncode(c.sha1(p.hexDecode("aebb1f")))).to.eq("62849d15c5dea495916c5eea8dba5f9551288850");
+  });
+  it("should calculate sha256", () => {
+    expect(p.hexEncode(c.sha256(p.utf8Encode("")))).to.eq(
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    );
+    expect(p.hexEncode(c.sha256(p.utf8Encode("hello")))).to.eq(
+      "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
+    );
+    expect(p.hexEncode(c.sha256(p.hexDecode("aebb1f")))).to.eq(
+      "2d29658aba48f2b286fe8bbddb931b7ad297e5adb5b9a6fc3aab67ef7fbf4e80"
+    );
+  });
+  it("should calculate hmac-sha256", async () => {
+    const key = p.hexDecode("aaeeff");
+    expect(p.hexEncode(await c.hmacSha256(p.utf8Encode(""), key))).to.eq(
+      "642711307c9e4437df09d6ebaa6bdc1b3a810c7f15c50fd1d0f8d7d5490f44dd"
+    );
+    expect(p.hexEncode(await c.hmacSha256(p.utf8Encode("hello"), key))).to.eq(
+      "39b00bab151f9868e6501655c580b5542954711181243474d46b894703b1c1c2"
+    );
+    expect(p.hexEncode(await c.hmacSha256(p.hexDecode("aebb1f"), key))).to.eq(
+      "a3a7273871808711cab17aba14f58e96f63f3ccfc5097d206f0f00ead2c3dd35"
+    );
+  });
+  it("should derive pbkdf2 key", async () => {
+    expect(p.hexEncode(await c.pbkdf2(p.utf8Encode("pbkdf2 test"), p.utf8Encode("some salt"), 10))).to.eq(
+      "e43276cfa27f135f261cec8ddcf593fd74ec251038e459c165461f2308f3a7235e0744ee1aed9710b00db28d1a2112e20fea3601c60e770ac57ffe6b33ca8be1"
+    );
+  });
+  it("should encrypt and decrypt aes-ctr", () => {
+    let aes = c.createAesCtr(
+      p.hexDecode("d450aae0bf0060a4af1044886b42a13f7c506b35255d134a7e87ab3f23a9493b"),
+      p.hexDecode("0182de2bd789c295c3c6c875c5e9e190"),
+      true
+    );
+    const data = p.hexDecode("7baae571e4c2f4cfadb1931d5923aca7");
+    expect(p.hexEncode(aes.process(data))).eq("df5647dbb70bc393f2fb05b72f42286f");
+    expect(p.hexEncode(aes.process(data))).eq("3917147082672516b3177150129bc579");
+    expect(p.hexEncode(aes.process(data))).eq("2a7a9089270a5de45d5e3dd399cac725");
+    expect(p.hexEncode(aes.process(data))).eq("56d085217771398ac13583de4d677dd8");
+    expect(p.hexEncode(aes.process(data))).eq("cc639b488126cf36e79c4515e8012b92");
+    expect(p.hexEncode(aes.process(data))).eq("01384d100646cd562cc5586ec3f8f8c4");
+    aes.close?.();
+    aes = c.createAesCtr(
+      p.hexDecode("d450aae0bf0060a4af1044886b42a13f7c506b35255d134a7e87ab3f23a9493b"),
+      p.hexDecode("0182de2bd789c295c3c6c875c5e9e190"),
+      false
+    );
+    expect(p.hexEncode(aes.process(p.hexDecode("df5647dbb70bc393f2fb05b72f42286f")))).eq(p.hexEncode(data));
+    expect(p.hexEncode(aes.process(p.hexDecode("3917147082672516b3177150129bc579")))).eq(p.hexEncode(data));
+    expect(p.hexEncode(aes.process(p.hexDecode("2a7a9089270a5de45d5e3dd399cac725")))).eq(p.hexEncode(data));
+    expect(p.hexEncode(aes.process(p.hexDecode("56d085217771398ac13583de4d677dd8")))).eq(p.hexEncode(data));
+    expect(p.hexEncode(aes.process(p.hexDecode("cc639b488126cf36e79c4515e8012b92")))).eq(p.hexEncode(data));
+    expect(p.hexEncode(aes.process(p.hexDecode("01384d100646cd562cc5586ec3f8f8c4")))).eq(p.hexEncode(data));
+    aes.close?.();
+  });
+  it("should encrypt and decrypt aes-ige", () => {
+    const aes = c.createAesIge(
+      p.hexDecode("5468697320697320616E20696D706C655468697320697320616E20696D706C65"),
+      p.hexDecode("6D656E746174696F6E206F6620494745206D6F646520666F72204F70656E5353")
+    );
+    expect(
+      p.hexEncode(aes.encrypt(p.hexDecode("99706487a1cde613bc6de0b6f24b1c7aa448c8b9c3403e3467a8cad89340f53b")))
+    ).to.eq("792ea8ae577b1a66cb3bd92679b8030ca54ee631976bd3a04547fdcb4639fa69");
+    expect(
+      p.hexEncode(aes.decrypt(p.hexDecode("792ea8ae577b1a66cb3bd92679b8030ca54ee631976bd3a04547fdcb4639fa69")))
+    ).to.eq("99706487a1cde613bc6de0b6f24b1c7aa448c8b9c3403e3467a8cad89340f53b");
+  });
+  it(
+    "should decompose PQ to prime factors P and Q",
+    async () => {
+      const testFactorization = async (pq, p_, q) => {
+        const [p1, q1] = await c.factorizePQ(p.hexDecode(pq));
+        expect(p.hexEncode(p1)).eq(p_.toLowerCase());
+        expect(p.hexEncode(q1)).eq(q.toLowerCase());
+      };
+      await testFactorization("17ED48941A08F981", "494C553B", "53911073");
+      await testFactorization("14fcab4dfc861f45", "494c5c99", "494c778d");
+    },
+    // since PQ factorization relies on RNG, it may take a while (or may not!)
+    { timeout: 1e4 }
+  );
+  it("should correctly gzip", () => {
+    const data = new Uint8Array(1e3).fill(66);
+    const compressed = c.gzip(data, 100);
+    expect(compressed).not.toBeNull();
+    const decompressed = inflateSyncWrap(compressed);
+    expect(compressed.length).toBeLessThan(data.length);
+    expect(p.hexEncode(decompressed)).toEqual(p.hexEncode(data));
+  });
+  it("should correctly gunzip", () => {
+    const data = new Uint8Array(1e3).fill(66);
+    const compressed = gzipSyncWrap(data);
+    const decompressed = c.gunzip(compressed);
+    expect(p.hexEncode(decompressed)).toEqual(p.hexEncode(data));
+  });
+  describe("randomBytes", () => {
+    it("should return exactly N bytes", () => {
+      expect(c.randomBytes(0).length).eq(0);
+      expect(c.randomBytes(5).length).eq(5);
+      expect(c.randomBytes(10).length).eq(10);
+      expect(c.randomBytes(256).length).eq(256);
+    });
+    it("should not be deterministic", () => {
+      expect([...c.randomBytes(8)]).not.eql([...c.randomBytes(8)]);
+    });
+    it("should use randomFill", () => {
+      const spy = vi.spyOn(c, "randomFill");
+      c.randomBytes(8);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+}
+function u8HexDecode(hex) {
+  const buf = getPlatform().hexDecode(hex);
+  return buf;
+}
+function fakeAuthKeysRepository() {
+  return {
+    get: vi.fn(),
+    set: vi.fn(),
+    getTemp: vi.fn(),
+    setTemp: vi.fn(),
+    deleteByDc: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixBuffer$1(buf) {
+  if (!buf) return buf;
+  return typeof Buffer !== "undefined" && buf instanceof Buffer ? new Uint8Array(buf) : buf;
+}
+function testAuthKeysRepository(repo) {
+  const key2 = new Uint8Array(256).fill(66);
+  const key3 = new Uint8Array(256).fill(67);
+  const key2i0 = new Uint8Array(256).fill(68);
+  const key2i1 = new Uint8Array(256).fill(69);
+  const key3i0 = new Uint8Array(256).fill(70);
+  const key3i1 = new Uint8Array(256).fill(71);
+  describe("auth keys", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(fixBuffer$1(await repo.get(2))).toEqual(null);
+      expect(fixBuffer$1(await repo.get(3))).toEqual(null);
+    });
+    it("should store and retrieve auth keys", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      expect(fixBuffer$1(await repo.get(2))).toEqual(key2);
+      expect(fixBuffer$1(await repo.get(3))).toEqual(key3);
+    });
+    it("should delete auth keys", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      await repo.set(2, null);
+      await repo.set(3, null);
+      expect(fixBuffer$1(await repo.get(2))).toEqual(null);
+      expect(fixBuffer$1(await repo.get(3))).toEqual(null);
+    });
+    it("should store and retrieve temp auth keys", async () => {
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      expect(fixBuffer$1(await repo.getTemp(2, 0, 0))).toEqual(key2i0);
+      expect(fixBuffer$1(await repo.getTemp(2, 1, 0))).toEqual(key2i1);
+      expect(fixBuffer$1(await repo.getTemp(3, 0, 0))).toEqual(key3i0);
+      expect(fixBuffer$1(await repo.getTemp(3, 1, 0))).toEqual(key3i1);
+      expect(fixBuffer$1(await repo.getTemp(2, 0, 100))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(2, 1, 100))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(3, 0, 100))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(3, 1, 100))).toEqual(null);
+    });
+    it("should delete temp auth keys", async () => {
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      await repo.setTemp(2, 0, null, 1);
+      await repo.setTemp(2, 1, null, 1);
+      await repo.setTemp(3, 0, null, 1);
+      await repo.setTemp(3, 1, null, 1);
+      expect(fixBuffer$1(await repo.getTemp(2, 0, 0))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(2, 1, 0))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(3, 0, 0))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(3, 1, 0))).toEqual(null);
+    });
+    it("should delete all auth keys by DC", async () => {
+      await repo.set(2, key2);
+      await repo.set(3, key3);
+      await repo.setTemp(2, 0, key2i0, 1);
+      await repo.setTemp(2, 1, key2i1, 1);
+      await repo.setTemp(3, 0, key3i0, 1);
+      await repo.setTemp(3, 1, key3i1, 1);
+      await repo.deleteByDc(2);
+      expect(fixBuffer$1(await repo.get(2))).toEqual(null);
+      expect(fixBuffer$1(await repo.get(3))).toEqual(key3);
+      expect(fixBuffer$1(await repo.getTemp(2, 0, 0))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(2, 1, 0))).toEqual(null);
+      expect(fixBuffer$1(await repo.getTemp(3, 0, 0))).toEqual(key3i0);
+      expect(fixBuffer$1(await repo.getTemp(3, 1, 0))).toEqual(key3i1);
+    });
+  });
+}
+function fakeKeyValueRepository() {
+  return {
+    get: vi.fn(),
+    set: vi.fn(),
+    delete: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixBuffer(buf) {
+  if (!buf) return buf;
+  return typeof Buffer !== "undefined" && buf instanceof Buffer ? new Uint8Array(buf) : buf;
+}
+function testKeyValueRepository(repo, driver) {
+  describe("key-value", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(fixBuffer(await repo.get("key"))).toEqual(null);
+    });
+    it("should store and retrieve values", async () => {
+      await repo.set("key", new Uint8Array([1, 2, 3]));
+      await driver.save?.();
+      expect(fixBuffer(await repo.get("key"))).toEqual(new Uint8Array([1, 2, 3]));
+    });
+    it("should delete values", async () => {
+      await repo.set("key", new Uint8Array([1, 2, 3]));
+      await driver.save?.();
+      await repo.delete("key");
+      await driver.save?.();
+      expect(fixBuffer(await repo.get("key"))).toEqual(null);
+    });
+  });
+}
+const schema = "default" in schema_ ? schema_.default : schema_;
+let _cachedEntriesMap = null;
+let _cachedUnionsMap = null;
+function getEntriesMap() {
+  if (_cachedEntriesMap) {
+    return {
+      entries: _cachedEntriesMap,
+      unions: _cachedUnionsMap
+    };
+  }
+  _cachedEntriesMap = /* @__PURE__ */ new Map();
+  _cachedUnionsMap = /* @__PURE__ */ new Map();
+  let entry;
+  for (entry of schema.e) {
+    _cachedEntriesMap.set(entry.name, entry);
+    if (!_cachedUnionsMap.has(entry.type)) {
+      _cachedUnionsMap.set(entry.type, []);
+    }
+    _cachedUnionsMap.get(entry.type).push(entry);
+  }
+  return {
+    entries: _cachedEntriesMap,
+    unions: _cachedUnionsMap
+  };
+}
+function getDefaultFor(arg) {
+  if (arg.typeModifiers?.isVector || arg.typeModifiers?.isBareVector) {
+    return [];
+  }
+  if (arg.typeModifiers?.predicate) {
+    return arg.type === "true" ? false : void 0;
+  }
+  switch (arg.type) {
+    case "int":
+    case "int53":
+    case "double":
+      return 0;
+    case "long":
+      return Long.ZERO;
+    case "int128":
+      return new Uint8Array(16);
+    case "int256":
+      return new Uint8Array(32);
+    case "string":
+      return "";
+    case "bytes":
+      return new Uint8Array(0);
+    case "Bool":
+    case "bool":
+      return false;
+    default: {
+      const union = getEntriesMap().unions.get(arg.type);
+      if (!union) throw new Error(`Unknown type ${arg.type}`);
+      return createStub(union[0].name);
+    }
+  }
+}
+function snakeToCamel(s) {
+  return s.replace(/(?<!^|_)_[a-z0-9]/gi, ($1) => {
+    return $1.substring(1).toUpperCase();
+  });
+}
+function createStub(name, partial = {}) {
+  const { entries } = getEntriesMap();
+  const entry = entries.get(name);
+  if (!entry) throw new Error(`Entry ${name} is unknown`);
+  const ret = {
+    _: name
+  };
+  for (const arg of entry.arguments) {
+    if (arg.type === "#") continue;
+    if (arg.name in partial) continue;
+    ret[snakeToCamel(arg.name)] = getDefaultFor(arg);
+  }
+  for (const key in partial) {
+    ret[key] = partial[key];
+  }
+  return ret;
+}
+function fakePeersRepository() {
+  return {
+    getById: vi.fn(),
+    getByUsername: vi.fn(),
+    getByPhone: vi.fn(),
+    store: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function fixPeerInfo(peer) {
+  if (!peer) return peer;
+  return {
+    ...peer,
+    complete: (
+      // eslint-disable-next-line no-restricted-globals
+      typeof Buffer !== "undefined" && peer.complete instanceof Buffer ? new Uint8Array(peer.complete) : peer.complete
+    )
+  };
+}
+function testPeersRepository(repo, driver) {
+  const stubPeerUser = {
+    id: 123123,
+    accessHash: "123|456",
+    isMin: false,
+    usernames: ["some_user"],
+    phone: "78005553535",
+    updated: 666,
+    complete: TlBinaryWriter.serializeObject(__tlWriterMap, createStub("user", { id: 123123 }))
+  };
+  const stubPeerChannel = {
+    id: -1001183945448,
+    accessHash: "666|555",
+    isMin: false,
+    usernames: ["some_channel"],
+    updated: 777,
+    complete: TlBinaryWriter.serializeObject(__tlWriterMap, createStub("channel", { id: 123123 }))
+  };
+  const stupPeerMinUser = { ...stubPeerUser, isMin: true };
+  describe("peers", () => {
+    it("should be empty by default", async () => {
+      expect(await repo.getById(123123, false)).toEqual(null);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(await repo.getByPhone("phone")).toEqual(null);
+    });
+    it("should store and retrieve peers", async () => {
+      await repo.store(stubPeerUser);
+      await repo.store(stubPeerChannel);
+      await driver.save?.();
+      expect(fixPeerInfo(await repo.getById(123123, false))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getByUsername("some_user"))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getByPhone("78005553535"))).toEqual(stubPeerUser);
+      expect(fixPeerInfo(await repo.getById(-1001183945448, false))).toEqual(stubPeerChannel);
+      expect(fixPeerInfo(await repo.getByUsername("some_channel"))).toEqual(stubPeerChannel);
+    });
+    it("should update peers usernames", async () => {
+      await repo.store(stubPeerUser);
+      await driver.save?.();
+      const modUser = { ...stubPeerUser, usernames: ["some_user2"] };
+      await repo.store(modUser);
+      await driver.save?.();
+      expect(fixPeerInfo(await repo.getById(123123, false))).toEqual(modUser);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(fixPeerInfo(await repo.getByUsername("some_user2"))).toEqual(modUser);
+    });
+    it("should not return min peers by default", async () => {
+      await repo.deleteAll();
+      await repo.store(stupPeerMinUser);
+      await driver.save?.();
+      expect(await repo.getById(123123, false)).toEqual(null);
+      expect(await repo.getByUsername("some_user")).toEqual(null);
+      expect(await repo.getByPhone("78005553535")).toEqual(null);
+      expect(fixPeerInfo(await repo.getById(123123, true))).toEqual(stupPeerMinUser);
+    });
+  });
+}
+function fakeRefMessagesRepository() {
+  return {
+    store: vi.fn(),
+    getByPeer: vi.fn(),
+    delete: vi.fn(),
+    deleteByPeer: vi.fn(),
+    deleteAll: vi.fn()
+  };
+}
+function testRefMessagesRepository(repo, driver) {
+  describe("IReferenceMessagesRepository", () => {
+    afterEach(() => repo.deleteAll());
+    it("should be empty by default", async () => {
+      expect(await repo.getByPeer(1)).toEqual(null);
+    });
+    it("should store and retrieve reference messages", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(2, 6, 7);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).deep.oneOf([
+        [2, 3],
+        [4, 5]
+      ]);
+      expect(await repo.getByPeer(2)).toEqual([6, 7]);
+      expect(await repo.getByPeer(3)).toEqual(null);
+      expect(await repo.getByPeer(4)).toEqual(null);
+      expect(await repo.getByPeer(5)).toEqual(null);
+      expect(await repo.getByPeer(6)).toEqual(null);
+      expect(await repo.getByPeer(7)).toEqual(null);
+    });
+    it("should delete reference messages", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(2, 6, 7);
+      await driver.save?.();
+      await repo.delete(4, [5]);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual([2, 3]);
+      await repo.delete(2, [2, 3, 4]);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual(null);
+    });
+    it("should delete all reference messages for a peer", async () => {
+      await repo.store(1, 2, 3);
+      await repo.store(1, 4, 5);
+      await repo.store(1, 6, 7);
+      await repo.store(2, 20, 30);
+      await repo.store(2, 40, 50);
+      await repo.store(2, 60, 70);
+      await driver.save?.();
+      await repo.deleteByPeer(1);
+      await driver.save?.();
+      expect(await repo.getByPeer(1)).toEqual(null);
+      expect(await repo.getByPeer(2)).deep.oneOf([
+        [20, 30],
+        [40, 50],
+        [60, 70]
+      ]);
+    });
+  });
+}
+export {
+  StubMemoryTelegramStorage,
+  StubTelegramClient,
+  StubTelegramTransport,
+  createStub,
+  defaultCryptoProvider,
+  defaultPlatform,
+  defaultTestCryptoProvider,
+  fakeAuthKeysRepository,
+  fakeKeyValueRepository,
+  fakePeersRepository,
+  fakeRefMessagesRepository,
+  testAuthKeysRepository,
+  testCryptoProvider,
+  testKeyValueRepository,
+  testPeersRepository,
+  testRefMessagesRepository,
+  u8HexDecode,
+  useFakeMathRandom,
+  withFakeRandom
+};