@overpod/mcp-telegram 1.26.0 → 1.27.0

package/dist/__tests__/rate-limiter.test.js

@@ -1,81 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import { RateLimiter } from "../rate-limiter.js";
-describe("RateLimiter", () => {
-    it("should execute a function successfully", async () => {
-        const limiter = new RateLimiter({ maxRequestsPerSecond: 100 });
-        const result = await limiter.execute(async () => "success");
-        assert.strictEqual(result, "success");
-    });
-    it("should enforce rate limiting between requests", async () => {
-        const limiter = new RateLimiter({ maxRequestsPerSecond: 10 }); // 10 req/s = 100ms between requests
-        const start = Date.now();
-        await limiter.execute(async () => "first");
-        await limiter.execute(async () => "second");
-        const elapsed = Date.now() - start;
-        assert.ok(elapsed >= 90, `Expected at least 90ms, got ${elapsed}ms`);
-    });
-    it("should retry on FLOOD_WAIT error", async () => {
-        const limiter = new RateLimiter({ maxRetries: 2, maxRequestsPerSecond: 100 });
-        let attempts = 0;
-        const result = await limiter.execute(async () => {
-            attempts++;
-            if (attempts < 2) {
-                throw new Error("FLOOD_WAIT_1");
-            }
-            return "success after retry";
-        });
-        assert.strictEqual(result, "success after retry");
-        assert.strictEqual(attempts, 2);
-    });
-    it("should throw after max retries on FLOOD_WAIT", async () => {
-        const limiter = new RateLimiter({ maxRetries: 1, maxRequestsPerSecond: 100 });
-        await assert.rejects(async () => {
-            await limiter.execute(async () => {
-                throw new Error("FLOOD_WAIT_2");
-            });
-        }, {
-            message: /Rate limit exceeded after 1 retries/,
-        });
-    });
-    it("should retry on network errors with exponential backoff", async () => {
-        const limiter = new RateLimiter({
-            maxRetries: 2,
-            initialRetryDelay: 100,
-            maxRequestsPerSecond: 100,
-        });
-        let attempts = 0;
-        const result = await limiter.execute(async () => {
-            attempts++;
-            if (attempts < 2) {
-                throw new Error("TIMEOUT");
-            }
-            return "recovered";
-        });
-        assert.strictEqual(result, "recovered");
-        assert.strictEqual(attempts, 2);
-    });
-    it("should not retry on non-retryable errors", async () => {
-        const limiter = new RateLimiter({ maxRetries: 3, maxRequestsPerSecond: 100 });
-        let attempts = 0;
-        await assert.rejects(async () => {
-            await limiter.execute(async () => {
-                attempts++;
-                throw new Error("AUTH_KEY_UNREGISTERED");
-            });
-        }, {
-            message: "AUTH_KEY_UNREGISTERED",
-        });
-        assert.strictEqual(attempts, 1, "Should not retry non-retryable errors");
-    });
-    it("should handle FLOOD_WAIT with seconds parsing", async () => {
-        const limiter = new RateLimiter({ maxRetries: 1, maxRequestsPerSecond: 100 });
-        await assert.rejects(async () => {
-            await limiter.execute(async () => {
-                throw new Error("FLOOD_WAIT_1");
-            });
-        }, {
-            message: /Telegram requires 1s wait/,
-        });
-    });
-});

package/dist/__tests__/reactions.test.d.ts

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

package/dist/__tests__/reactions.test.js

@@ -1,23 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import bigInt from "big-integer";
-import { Api } from "telegram/tl/index.js";
-import { reactionToEmoji } from "../telegram-client.js";
-describe("reactionToEmoji", () => {
-    it("returns emoticon for ReactionEmoji", () => {
-        const r = new Api.ReactionEmoji({ emoticon: "👍" });
-        assert.strictEqual(reactionToEmoji(r), "👍");
-    });
-    it("returns custom:<id> for ReactionCustomEmoji", () => {
-        const r = new Api.ReactionCustomEmoji({ documentId: bigInt(12345) });
-        assert.strictEqual(reactionToEmoji(r), "custom:12345");
-    });
-    it("returns star for ReactionPaid", () => {
-        const r = new Api.ReactionPaid();
-        assert.strictEqual(reactionToEmoji(r), "⭐");
-    });
-    it("returns null for ReactionEmpty", () => {
-        const r = new Api.ReactionEmpty();
-        assert.strictEqual(reactionToEmoji(r), null);
-    });
-});

package/dist/__tests__/set-chat-permissions-merge.test.d.ts

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

package/dist/__tests__/set-chat-permissions-merge.test.js

@@ -1,107 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import bigInt from "big-integer";
-import { Api } from "telegram/tl/index.js";
-import { mergeBannedRights, TelegramService } from "../telegram-client.js";
-describe("mergeBannedRights", () => {
-    it("preserves omitted flags from current rights", () => {
-        const current = { pinMessages: true, inviteUsers: true, sendMessages: false };
-        const merged = mergeBannedRights(current, { sendMessages: false });
-        assert.strictEqual(merged.sendMessages, true, "user-specified denial applies");
-        assert.strictEqual(merged.pinMessages, true, "omitted flag stays banned");
-        assert.strictEqual(merged.inviteUsers, true, "omitted flag stays banned");
-        assert.strictEqual(merged.sendMedia, false, "omitted flag with no current stays unbanned");
-    });
-    it("user-provided value overrides current", () => {
-        const current = { pinMessages: true };
-        const merged = mergeBannedRights(current, { pinMessages: true });
-        assert.strictEqual(merged.pinMessages, false, "pinMessages:true allowed -> not banned");
-    });
-    it("fills missing flags with false when current is undefined", () => {
-        const merged = mergeBannedRights(undefined, { sendMessages: true });
-        assert.strictEqual(merged.sendMessages, false);
-        assert.strictEqual(merged.sendMedia, false);
-        assert.strictEqual(merged.pinMessages, false);
-    });
-    it("covers all nineteen flags (10 exposed + 9 extra preserved)", () => {
-        const merged = mergeBannedRights(undefined, {});
-        const keys = Object.keys(merged).sort();
-        assert.deepStrictEqual(keys, [
-            "changeInfo",
-            "embedLinks",
-            "inviteUsers",
-            "manageTopics",
-            "pinMessages",
-            "sendAudios",
-            "sendDocs",
-            "sendGames",
-            "sendGifs",
-            "sendInline",
-            "sendMedia",
-            "sendMessages",
-            "sendPhotos",
-            "sendPlain",
-            "sendPolls",
-            "sendRoundvideos",
-            "sendStickers",
-            "sendVideos",
-            "sendVoices",
-        ]);
-    });
-});
-describe("TelegramService.setChatPermissions", () => {
-    it("merges new permissions with existing defaultBannedRights", async () => {
-        const existingRights = new Api.ChatBannedRights({
-            untilDate: 0,
-            pinMessages: true,
-            inviteUsers: true,
-        });
-        const channel = new Api.Channel({
-            id: bigInt(12345),
-            title: "test",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            defaultBannedRights: existingRights,
-        });
-        const inputChannel = new Api.InputPeerChannel({ channelId: bigInt(12345), accessHash: bigInt(1) });
-        const invocations = [];
-        const fakeClient = {
-            invoke: async (req) => {
-                invocations.push(req);
-                if (req instanceof Api.channels.GetFullChannel) {
-                    return new Api.messages.ChatFull({
-                        fullChat: new Api.ChannelFull({
-                            id: bigInt(12345),
-                            about: "",
-                            readInboxMaxId: 0,
-                            readOutboxMaxId: 0,
-                            unreadCount: 0,
-                            chatPhoto: new Api.PhotoEmpty({ id: bigInt(0) }),
-                            notifySettings: new Api.PeerNotifySettings({}),
-                            pts: 0,
-                            botInfo: [],
-                        }),
-                        chats: [channel],
-                        users: [],
-                    });
-                }
-                return undefined;
-            },
-            getInputEntity: async () => inputChannel,
-        };
-        const service = new TelegramService(1, "hash");
-        const internals = service;
-        internals.client = fakeClient;
-        internals.connected = true;
-        internals.resolveChat = async () => channel;
-        await service.setChatPermissions("12345", { sendMessages: false });
-        const editCall = invocations.find((r) => r instanceof Api.messages.EditChatDefaultBannedRights);
-        assert.ok(editCall, "EditChatDefaultBannedRights was invoked");
-        const rights = editCall.bannedRights;
-        assert.strictEqual(rights.sendMessages, true, "sendMessages becomes banned");
-        assert.strictEqual(rights.pinMessages, true, "pinMessages stays banned (preserved)");
-        assert.strictEqual(rights.inviteUsers, true, "inviteUsers stays banned (preserved)");
-        assert.strictEqual(rights.sendMedia, false, "omitted flag with no prior value stays unbanned");
-    });
-});

package/dist/__tests__/set-chat-reactions.test.d.ts

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

package/dist/__tests__/set-chat-reactions.test.js

@@ -1,129 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import bigInt from "big-integer";
-import { Api } from "telegram/tl/index.js";
-import { TelegramService } from "../telegram-client.js";
-function makeService(entity, invocations) {
-    const fakeClient = {
-        invoke: async (req) => {
-            invocations.push(req);
-            return undefined;
-        },
-    };
-    const service = new TelegramService(1, "hash");
-    const internals = service;
-    internals.client = fakeClient;
-    internals.connected = true;
-    internals.resolveChat = async () => entity;
-    return service;
-}
-describe("TelegramService.setChatAvailableReactions", () => {
-    it("sends ChatReactionsAll without custom when type='all'", async () => {
-        const channel = new Api.Channel({
-            id: bigInt(12345),
-            title: "channel",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            megagroup: true,
-        });
-        const invocations = [];
-        const service = makeService(channel, invocations);
-        await service.setChatAvailableReactions("12345", { type: "all" });
-        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
-        assert.ok(call, "SetChatAvailableReactions was invoked");
-        assert.ok(call.availableReactions instanceof Api.ChatReactionsAll);
-        assert.strictEqual(call.availableReactions.allowCustom, undefined);
-    });
-    it("sends ChatReactionsAll with allowCustom=true when requested", async () => {
-        const channel = new Api.Channel({
-            id: bigInt(22222),
-            title: "channel",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            megagroup: true,
-        });
-        const invocations = [];
-        const service = makeService(channel, invocations);
-        await service.setChatAvailableReactions("22222", { type: "all", allowCustom: true });
-        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
-        assert.ok(call);
-        assert.ok(call.availableReactions instanceof Api.ChatReactionsAll);
-        assert.strictEqual(call.availableReactions.allowCustom, true);
-    });
-    it("sends ChatReactionsNone when type='none'", async () => {
-        const channel = new Api.Channel({
-            id: bigInt(33333),
-            title: "channel",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            megagroup: true,
-        });
-        const invocations = [];
-        const service = makeService(channel, invocations);
-        await service.setChatAvailableReactions("33333", { type: "none" });
-        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
-        assert.ok(call);
-        assert.ok(call.availableReactions instanceof Api.ChatReactionsNone);
-    });
-    it("sends ChatReactionsSome with ReactionEmoji list when type='some'", async () => {
-        const channel = new Api.Channel({
-            id: bigInt(44444),
-            title: "channel",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            megagroup: true,
-        });
-        const invocations = [];
-        const service = makeService(channel, invocations);
-        await service.setChatAvailableReactions("44444", { type: "some", emoji: ["👍", "❤️", "🔥"] });
-        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
-        assert.ok(call);
-        assert.ok(call.availableReactions instanceof Api.ChatReactionsSome);
-        const some = call.availableReactions;
-        assert.strictEqual(some.reactions.length, 3);
-        for (const r of some.reactions) {
-            assert.ok(r instanceof Api.ReactionEmoji);
-        }
-        assert.deepStrictEqual(some.reactions.map((r) => r.emoticon), ["👍", "❤️", "🔥"]);
-    });
-    it("accepts basic Chat entity (non-channel group)", async () => {
-        const chat = new Api.Chat({
-            id: bigInt(55555),
-            title: "basic group",
-            photo: new Api.ChatPhotoEmpty(),
-            participantsCount: 5,
-            date: 0,
-            version: 0,
-        });
-        const invocations = [];
-        const service = makeService(chat, invocations);
-        await service.setChatAvailableReactions("55555", { type: "none" });
-        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
-        assert.ok(call, "SetChatAvailableReactions was invoked for basic group");
-    });
-    it("rejects User peer (non-chat)", async () => {
-        const user = new Api.User({ id: bigInt(66666), accessHash: bigInt(1), firstName: "Bob" });
-        const invocations = [];
-        const service = makeService(user, invocations);
-        await assert.rejects(service.setChatAvailableReactions("66666", { type: "none" }), /groups, supergroups, and channels/);
-        assert.strictEqual(invocations.length, 0);
-    });
-    it("rejects empty emoji list on type='some'", async () => {
-        const channel = new Api.Channel({
-            id: bigInt(77777),
-            title: "channel",
-            photo: new Api.ChatPhotoEmpty(),
-            date: 0,
-            accessHash: bigInt(1),
-            megagroup: true,
-        });
-        const invocations = [];
-        const service = makeService(channel, invocations);
-        await assert.rejects(service.setChatAvailableReactions("77777", { type: "some", emoji: [] }), /non-empty/);
-        assert.strictEqual(invocations.length, 0);
-    });
-});

package/dist/__tests__/stars-status.test.d.ts

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

package/dist/__tests__/stars-status.test.js

@@ -1,205 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import bigInt from "big-integer";
-import { Api } from "telegram/tl/index.js";
-import { summarizeStarsAmount, summarizeStarsStatus, summarizeStarsSubscription, summarizeStarsTransaction, summarizeStarsTransactionPeer, TelegramService, } from "../telegram-client.js";
-import { isStarsEnabled } from "../tools/stars.js";
-function makeService(invocations, responder) {
-    const fakeClient = {
-        invoke: async (req) => {
-            invocations.push(req);
-            return responder(req);
-        },
-    };
-    const service = new TelegramService(1, "hash");
-    const internals = service;
-    internals.client = fakeClient;
-    internals.connected = true;
-    return service;
-}
-describe("summarizeStarsAmount", () => {
-    it("stringifies amount (bigInt) and passes nanos through", () => {
-        const out = summarizeStarsAmount(new Api.StarsAmount({ amount: bigInt(12345), nanos: 67 }));
-        assert.deepStrictEqual(out, { amount: "12345", nanos: 67 });
-    });
-});
-describe("summarizeStarsTransactionPeer", () => {
-    it("maps app/play/premiumBot/fragment/ads/api/unsupported", () => {
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAppStore()), { kind: "appStore" });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerPlayMarket()), {
-            kind: "playMarket",
-        });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerPremiumBot()), {
-            kind: "premiumBot",
-        });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerFragment()), { kind: "fragment" });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAds()), { kind: "ads" });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAPI()), { kind: "api" });
-        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerUnsupported()), {
-            kind: "unsupported",
-        });
-    });
-    it("maps StarsTransactionPeer with a user peer", () => {
-        const out = summarizeStarsTransactionPeer(new Api.StarsTransactionPeer({ peer: new Api.PeerUser({ userId: bigInt(42) }) }));
-        assert.deepStrictEqual(out, { kind: "peer", peer: { kind: "user", id: "42" } });
-    });
-});
-describe("summarizeStarsTransaction", () => {
-    it("maps core fields and flags", () => {
-        const tx = new Api.StarsTransaction({
-            id: "tx-1",
-            stars: new Api.StarsAmount({ amount: bigInt(500), nanos: 0 }),
-            date: 1710000000,
-            peer: new Api.StarsTransactionPeerAppStore(),
-            refund: true,
-            gift: true,
-            title: "Top-up",
-            msgId: 55,
-            transactionDate: 1710000100,
-            transactionUrl: "https://example.com/x",
-        });
-        const out = summarizeStarsTransaction(tx);
-        assert.strictEqual(out.id, "tx-1");
-        assert.deepStrictEqual(out.stars, { amount: "500", nanos: 0 });
-        assert.strictEqual(out.date, 1710000000);
-        assert.deepStrictEqual(out.peer, { kind: "appStore" });
-        assert.strictEqual(out.refund, true);
-        assert.strictEqual(out.gift, true);
-        assert.strictEqual(out.title, "Top-up");
-        assert.strictEqual(out.msgId, 55);
-        assert.strictEqual(out.transactionDate, 1710000100);
-        assert.strictEqual(out.transactionUrl, "https://example.com/x");
-        assert.strictEqual(out.description, undefined);
-    });
-});
-describe("summarizeStarsSubscription", () => {
-    it("maps id, peer, pricing and flags", () => {
-        const sub = new Api.StarsSubscription({
-            id: "sub-1",
-            peer: new Api.PeerChannel({ channelId: bigInt(100) }),
-            untilDate: 1720000000,
-            pricing: new Api.StarsSubscriptionPricing({ period: 2592000, amount: bigInt(150) }),
-            canceled: true,
-            title: "Premium group",
-            invoiceSlug: "slug-x",
-        });
-        const out = summarizeStarsSubscription(sub);
-        assert.strictEqual(out.id, "sub-1");
-        assert.deepStrictEqual(out.peer, { kind: "channel", id: "100" });
-        assert.strictEqual(out.untilDate, 1720000000);
-        assert.deepStrictEqual(out.pricing, { period: 2592000, amount: "150" });
-        assert.strictEqual(out.canceled, true);
-        assert.strictEqual(out.title, "Premium group");
-        assert.strictEqual(out.invoiceSlug, "slug-x");
-        assert.strictEqual(out.missingBalance, undefined);
-    });
-});
-describe("summarizeStarsStatus", () => {
-    it("maps balance, history, subscriptions and offsets", () => {
-        const resp = new Api.payments.StarsStatus({
-            balance: new Api.StarsAmount({ amount: bigInt(1000), nanos: 5 }),
-            history: [
-                new Api.StarsTransaction({
-                    id: "t1",
-                    stars: new Api.StarsAmount({ amount: bigInt(10), nanos: 0 }),
-                    date: 1,
-                    peer: new Api.StarsTransactionPeerPremiumBot(),
-                }),
-            ],
-            subscriptions: [
-                new Api.StarsSubscription({
-                    id: "s1",
-                    peer: new Api.PeerChannel({ channelId: bigInt(7) }),
-                    untilDate: 100,
-                    pricing: new Api.StarsSubscriptionPricing({ period: 30, amount: bigInt(5) }),
-                }),
-            ],
-            subscriptionsNextOffset: "sub-cursor",
-            subscriptionsMissingBalance: bigInt(250),
-            nextOffset: "tx-cursor",
-            chats: [],
-            users: [],
-        });
-        const out = summarizeStarsStatus(resp);
-        assert.deepStrictEqual(out.balance, { amount: "1000", nanos: 5 });
-        assert.strictEqual(out.history?.length, 1);
-        assert.strictEqual(out.history?.[0].id, "t1");
-        assert.strictEqual(out.subscriptions?.length, 1);
-        assert.strictEqual(out.subscriptions?.[0].id, "s1");
-        assert.strictEqual(out.subscriptionsNextOffset, "sub-cursor");
-        assert.strictEqual(out.subscriptionsMissingBalance, "250");
-        assert.strictEqual(out.nextOffset, "tx-cursor");
-    });
-    it("omits empty history/subscriptions and empty offset strings", () => {
-        const resp = new Api.payments.StarsStatus({
-            balance: new Api.StarsAmount({ amount: bigInt(0), nanos: 0 }),
-            history: [],
-            subscriptions: [],
-            subscriptionsNextOffset: "",
-            nextOffset: "",
-            chats: [],
-            users: [],
-        });
-        const out = summarizeStarsStatus(resp);
-        assert.strictEqual(out.history, undefined);
-        assert.strictEqual(out.subscriptions, undefined);
-        assert.strictEqual(out.subscriptionsNextOffset, undefined);
-        assert.strictEqual(out.nextOffset, undefined);
-        assert.strictEqual(out.subscriptionsMissingBalance, undefined);
-    });
-});
-describe("TelegramService.getStarsStatus", () => {
-    it("invokes payments.GetStarsStatus with resolved peer and returns summary", async () => {
-        const invocations = [];
-        const service = makeService(invocations, () => new Api.payments.StarsStatus({
-            balance: new Api.StarsAmount({ amount: bigInt(42), nanos: 0 }),
-            chats: [],
-            users: [],
-        }));
-        const internals = service;
-        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(1), accessHash: bigInt(2) });
-        const out = await service.getStarsStatus("me");
-        const call = invocations.find((r) => r instanceof Api.payments.GetStarsStatus);
-        assert.ok(call);
-        assert.deepStrictEqual(out.balance, { amount: "42", nanos: 0 });
-    });
-});
-describe("isStarsEnabled gate", () => {
-    it("is off by default", () => {
-        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
-        delete process.env.MCP_TELEGRAM_ENABLE_STARS;
-        try {
-            assert.strictEqual(isStarsEnabled(), false);
-        }
-        finally {
-            if (prev !== undefined)
-                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
-        }
-    });
-    it("turns on when env is '1'", () => {
-        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
-        process.env.MCP_TELEGRAM_ENABLE_STARS = "1";
-        try {
-            assert.strictEqual(isStarsEnabled(), true);
-        }
-        finally {
-            if (prev === undefined)
-                delete process.env.MCP_TELEGRAM_ENABLE_STARS;
-            else
-                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
-        }
-    });
-    it("stays off for any non-'1' value", () => {
-        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
-        process.env.MCP_TELEGRAM_ENABLE_STARS = "true";
-        try {
-            assert.strictEqual(isStarsEnabled(), false);
-        }
-        finally {
-            if (prev === undefined)
-                delete process.env.MCP_TELEGRAM_ENABLE_STARS;
-            else
-                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
-        }
-    });
-});

package/dist/__tests__/stars-transactions.test.d.ts

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

package/dist/__tests__/stars-transactions.test.js

@@ -1,82 +0,0 @@
-import assert from "node:assert";
-import { describe, it } from "node:test";
-import bigInt from "big-integer";
-import { Api } from "telegram/tl/index.js";
-import { TelegramService } from "../telegram-client.js";
-function makeService(invocations, responder) {
-    const fakeClient = {
-        invoke: async (req) => {
-            invocations.push(req);
-            return responder(req);
-        },
-    };
-    const service = new TelegramService(1, "hash");
-    const internals = service;
-    internals.client = fakeClient;
-    internals.connected = true;
-    return service;
-}
-describe("TelegramService.getStarsTransactions", () => {
-    it("invokes payments.GetStarsTransactions with resolved peer, default offset='' and limit=50", async () => {
-        const invocations = [];
-        const service = makeService(invocations, () => new Api.payments.StarsStatus({
-            balance: new Api.StarsAmount({ amount: bigInt(100), nanos: 0 }),
-            history: [
-                new Api.StarsTransaction({
-                    id: "tx-A",
-                    stars: new Api.StarsAmount({ amount: bigInt(25), nanos: 0 }),
-                    date: 1710000000,
-                    peer: new Api.StarsTransactionPeerAppStore(),
-                }),
-            ],
-            nextOffset: "next-cursor",
-            chats: [],
-            users: [],
-        }));
-        const internals = service;
-        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(1), accessHash: bigInt(2) });
-        const out = await service.getStarsTransactions("me");
-        const call = invocations.find((r) => r instanceof Api.payments.GetStarsTransactions);
-        assert.ok(call, "GetStarsTransactions must be invoked");
-        assert.strictEqual(call.offset, "");
-        assert.strictEqual(call.limit, 50);
-        assert.strictEqual(call.inbound, undefined);
-        assert.strictEqual(call.outbound, undefined);
-        assert.strictEqual(call.ascending, undefined);
-        assert.strictEqual(call.subscriptionId, undefined);
-        assert.deepStrictEqual(out.balance, { amount: "100", nanos: 0 });
-        assert.strictEqual(out.history?.length, 1);
-        assert.strictEqual(out.history?.[0].id, "tx-A");
-        assert.strictEqual(out.nextOffset, "next-cursor");
-    });
-    it("forwards filter and pagination options verbatim", async () => {
-        const invocations = [];
-        const service = makeService(invocations, () => new Api.payments.StarsStatus({
-            balance: new Api.StarsAmount({ amount: bigInt(0), nanos: 0 }),
-            chats: [],
-            users: [],
-        }));
-        const internals = service;
-        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(7), accessHash: bigInt(8) });
-        await service.getStarsTransactions("me", {
-            inbound: true,
-            outbound: false,
-            ascending: true,
-            subscriptionId: "sub-9",
-            offset: "cursor-xyz",
-            limit: 25,
-        });
-        const call = invocations.find((r) => r instanceof Api.payments.GetStarsTransactions);
-        assert.ok(call);
-        assert.strictEqual(call.inbound, true);
-        assert.strictEqual(call.outbound, false);
-        assert.strictEqual(call.ascending, true);
-        assert.strictEqual(call.subscriptionId, "sub-9");
-        assert.strictEqual(call.offset, "cursor-xyz");
-        assert.strictEqual(call.limit, 25);
-    });
-    it("throws when not connected", async () => {
-        const service = new TelegramService(1, "hash");
-        await assert.rejects(() => service.getStarsTransactions("me"), /Not connected/i);
-    });
-});

package/dist/__tests__/stories.test.d.ts

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