@gearbox-protocol/cli-utils 5.67.1 → 5.68.0

package/dist/CensoredString.d.ts

@@ -1,6 +1,6 @@
 export declare class CensoredString<V extends string = string> {
     #private;
-    static transform<T extends string>(value: T): CensoredString<T>;
+    static transform<T extends string>(value: T | CensoredString<T>): CensoredString<T>;
     constructor(value: V);
     get value(): V;
     toString(): string;

package/dist/CensoredString.js

@@ -2,6 +2,9 @@ export class CensoredString {
     #value;
     #censored;
     static transform(value) {
+        if (value instanceof CensoredString) {
+            return value;
+        }
         return new CensoredString(value);
     }
     constructor(value) {

package/dist/CensoredURL.d.ts

@@ -3,7 +3,7 @@
  */
 export declare class CensoredURL {
     #private;
-    static transform(value: string): CensoredURL;
+    static transform(value: string | CensoredURL): CensoredURL;
     constructor(url: string);
     get value(): string;
     toString(): string;

package/dist/CensoredURL.js

@@ -5,6 +5,9 @@ export class CensoredURL {
     #value;
     #censored;
     static transform(value) {
+        if (value instanceof CensoredURL) {
+            return value;
+        }
         return new CensoredURL(value);
     }
     constructor(url) {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./CensoredString.js";
 export * from "./CensoredURL.js";
 export * from "./createRevolverTransport.js";
+export * from "./notifications/index.js";
 export * from "./providers.js";
 export * from "./providers-schema.js";
 export * from "./resolveYamlFiles.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./CensoredString.js";
 export * from "./CensoredURL.js";
 export * from "./createRevolverTransport.js";
+export * from "./notifications/index.js";
 export * from "./providers.js";
 export * from "./providers-schema.js";
 export * from "./resolveYamlFiles.js";

package/dist/notifications/NotificationsService.d.ts

@@ -0,0 +1,19 @@
+import { type ILogger } from "@gearbox-protocol/sdk";
+import type { Address } from "viem";
+import { type SignlServiceOptions } from "./SignlNotifier.js";
+import type { NotificationConfig } from "./schema.js";
+import type { INotificationService, NotificationLike } from "./types.js";
+export interface NotificationsServiceOptions {
+    notifications: Array<NotificationConfig & {
+        recipient?: Address;
+    }>;
+    signl?: SignlServiceOptions;
+}
+export declare class NotificationsService implements INotificationService {
+    #private;
+    constructor(options: NotificationsServiceOptions, logger?: ILogger);
+    registerRecipient(address: Address, options: NotificationConfig): void;
+    signl(message: string): void;
+    alert(msg: NotificationLike): void;
+    notify(msg: NotificationLike): void;
+}

package/dist/notifications/NotificationsService.js

@@ -0,0 +1,66 @@
+import { ADDRESS_0X0, AddressMap } from "@gearbox-protocol/sdk";
+import { createNotifier } from "./createNotifier.js";
+import SignlNotifier from "./SignlNotifier.js";
+export class NotificationsService {
+    #logger;
+    #notifiers = new AddressMap();
+    #signlNotifier;
+    constructor(options, logger) {
+        this.#logger = logger;
+        for (const n of options.notifications) {
+            const recipient = n.recipient ?? ADDRESS_0X0;
+            const notifier = createNotifier(n, logger);
+            if (notifier) {
+                this.#notifiers.upsert(recipient, notifier);
+            }
+        }
+        if (options.signl) {
+            this.#signlNotifier = new SignlNotifier(options.signl);
+        }
+        else {
+            this.#logger?.warn("signl notifier not configured");
+        }
+    }
+    registerRecipient(address, options) {
+        const notifier = createNotifier(options, this.#logger);
+        if (notifier) {
+            this.#notifiers.upsert(address, notifier);
+        }
+    }
+    signl(message) {
+        this.#signlNotifier?.alert(message);
+    }
+    alert(msg) {
+        this.#notify(msg, "alert");
+    }
+    notify(msg) {
+        this.#notify(msg, "notification");
+    }
+    #notify(msg, severity) {
+        const message = this.#toNotification(msg);
+        for (const [addr, notifier] of this.#notifiers.entries()) {
+            const recipient = addr === ADDRESS_0X0 ? undefined : addr;
+            const recipientNotification = message.messageFor(recipient);
+            if (recipientNotification) {
+                notifier.notify(this.#toDedupableNotification(recipientNotification), severity);
+            }
+        }
+    }
+    #toNotification(message) {
+        // global notification without deduplication
+        if (typeof message === "string" || !("messageFor" in message)) {
+            return {
+                messageFor: (recipient) => (recipient ? undefined : message),
+            };
+        }
+        return message;
+    }
+    #toDedupableNotification(msg) {
+        if (typeof msg === "string") {
+            return {
+                plain: msg,
+            };
+        }
+        return msg;
+    }
+}

package/dist/notifications/SignlNotifier.d.ts

@@ -0,0 +1,12 @@
+import type { ILogger } from "@gearbox-protocol/sdk";
+export interface SignlServiceOptions {
+    apiKey: string;
+    teamId: string;
+    retryInterval?: number;
+    retryCount?: number;
+}
+export default class SignlNotifier {
+    #private;
+    constructor(opts: SignlServiceOptions, logger?: ILogger);
+    alert(message: string): void;
+}

package/dist/notifications/SignlNotifier.js

@@ -0,0 +1,47 @@
+import { withRetry } from "viem";
+const DEFAULT_RETRY_INTERVAL = 1000;
+const DEFAULT_RETRY_COUNT = 5;
+export default class SignlNotifier {
+    #logger;
+    #apiKey;
+    #teamId;
+    #retryInterval;
+    #retryCount;
+    constructor(opts, logger) {
+        this.#apiKey = opts.apiKey;
+        this.#teamId = opts.teamId;
+        this.#retryInterval = opts.retryInterval ?? DEFAULT_RETRY_INTERVAL;
+        this.#retryCount = opts.retryCount ?? DEFAULT_RETRY_COUNT;
+        this.#logger = logger;
+    }
+    alert(message) {
+        void this.#sendAlert(message).catch(e => this.#logger?.error(e));
+    }
+    async #sendAlert(message) {
+        const text = message.slice(0, 64); // it's to be shown in mobile notifications anyways
+        this.#logger?.debug("sending signl alert");
+        await withRetry(async () => {
+            const resp = await fetch(`https://connect.signl4.com/api/v2/alerts?x-s4-api-key=${this.#apiKey}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    category: "emergency",
+                    severity: 0,
+                    teamId: this.#teamId,
+                    text,
+                    title: "GEARBOX ALERT",
+                }),
+            });
+            if (resp.ok) {
+                this.#logger?.warn("signl alert sent");
+                const data = await resp.json();
+                this.#logger?.info(`signl alert response: ${JSON.stringify(data)}`);
+            }
+            else {
+                throw new Error(`signl api error ${resp.status}: ${resp.statusText}`);
+            }
+        }, { delay: this.#retryInterval, retryCount: this.#retryCount });
+    }
+}

package/dist/notifications/SlackNotifier.d.ts

@@ -0,0 +1,8 @@
+import type { ILogger } from "@gearbox-protocol/sdk";
+import type { SlackConfig } from "./schema.js";
+import type { IDedupableNotification, INotifier, NotificationSeverity } from "./types.js";
+export declare class SlackNotifier implements INotifier {
+    #private;
+    constructor(config: SlackConfig, logger?: ILogger);
+    notify(message: IDedupableNotification, severity: NotificationSeverity): void;
+}

package/dist/notifications/SlackNotifier.js

@@ -0,0 +1,38 @@
+// TODO: no throttling or deduplication yet
+export class SlackNotifier {
+    #config;
+    #logger;
+    constructor(config, logger) {
+        this.#config = config;
+        this.#logger = logger;
+    }
+    notify(message, severity) {
+        if (this.#config.alertsOnly && severity === "notification") {
+            return;
+        }
+        const emoji = severity === "alert" ? "🚨" : "ℹ️";
+        const messageText = typeof message === "string" ? message : message.plain;
+        void this.#sendToSlack(`${emoji} Alert: ${messageText}`);
+    }
+    async #sendToSlack(text) {
+        try {
+            this.#logger?.debug(`Sending message to Slack: ${text}`);
+            // Use fetch instead of axios to avoid adding dependencies
+            const response = await fetch(this.#config.webhookUrl.value, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ text }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            this.#logger?.debug("Slack message sent successfully");
+        }
+        catch (error) {
+            this.#logger?.error("Error sending Slack message:", error);
+            throw error;
+        }
+    }
+}

package/dist/notifications/TelegramNotifier.d.ts

@@ -0,0 +1,14 @@
+import type { ILogger } from "@gearbox-protocol/sdk";
+import type { TelegramConfig } from "./schema.js";
+import type { IDedupableNotification, INotifier, NotificationSeverity } from "./types.js";
+export type TelegramNotifierOptions = TelegramConfig & {
+    retryInterval?: number;
+    retryCount?: number;
+    maxChunkSize?: number;
+    fetchFn?: typeof fetch;
+};
+export declare class TelegramNotifier implements INotifier {
+    #private;
+    constructor(opts: TelegramNotifierOptions, logger?: ILogger);
+    notify(message: IDedupableNotification, severity: NotificationSeverity): void;
+}

package/dist/notifications/TelegramNotifier.js

@@ -0,0 +1,119 @@
+import { md } from "@vlad-yakovlev/telegram-md";
+import Queue from "p-queue";
+import { withRetry } from "viem";
+import { ThrottleManager } from "./ThrottleManager.js";
+const DEFAULT_RETRY_INTERVAL = 1000;
+const DEFAULT_RETRY_COUNT = 5;
+const DEFAULT_MAX_CHUNK_SIZE = 4096;
+export class TelegramNotifier {
+    #logger;
+    #alertsChannel;
+    #notificationsChannel;
+    #botToken;
+    #prefix;
+    #retryInterval;
+    #retryCount;
+    #maxChunkSize;
+    #fetchFn;
+    #queue = new Queue({
+        concurrency: 1,
+        // https://core.telegram.org/bots/faq#my-bot-is-hitting-limits-how-do-i-avoid-this
+        // 20 messages/minute limit
+        interval: 60_000,
+        intervalCap: 20,
+        strict: true,
+    });
+    #throttleManager = new ThrottleManager();
+    constructor(opts, logger) {
+        this.#logger = logger;
+        this.#alertsChannel = opts.alertsChannel.value;
+        this.#botToken = opts.token.value;
+        this.#notificationsChannel = opts.notificationsChannel?.value;
+        this.#prefix = opts.prefix;
+        this.#retryInterval = opts.retryInterval ?? DEFAULT_RETRY_INTERVAL;
+        this.#retryCount = opts.retryCount ?? DEFAULT_RETRY_COUNT;
+        this.#maxChunkSize = opts.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;
+        this.#fetchFn = opts.fetchFn ?? fetch;
+    }
+    notify(message, severity) {
+        const dest = severity === "alert" ? this.#alertsChannel : this.#notificationsChannel;
+        if (!dest) {
+            return;
+        }
+        this.#enqueueTelegram(message, dest, severity === "alert");
+    }
+    async #enqueueTelegram(message, channelId, severe = false) {
+        if (!this.#throttleManager.canSend(message.dedupeKey)) {
+            return;
+        }
+        const payloads = this.#toTelegramPayloads(message);
+        for (const payload of payloads) {
+            this.#queue.add(() => this.#sendToTelegram(payload, channelId, severe).catch(e => this.#logger?.error(e)), {
+                priority: severe ? 100 : 0,
+                timeout: this.#retryInterval * this.#retryCount * 2,
+            });
+        }
+        this.#throttleManager.onSent(message.dedupeKey, message.throttleFn);
+    }
+    async #sendToTelegram(payload, channelId, severe = false) {
+        const severity = severe ? "alert" : "notification";
+        this.#logger?.debug(`sending telegram ${severity} to channel ${channelId}...`);
+        const url = `https://api.telegram.org/bot${this.#botToken}/sendMessage`;
+        try {
+            await withRetry(async () => {
+                const resp = await this.#fetchFn(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        ...payload,
+                        chat_id: channelId,
+                    }),
+                });
+                if (resp.ok) {
+                    this.#logger?.debug(`telegram ${severity} sent successfully`);
+                }
+                else {
+                    const txt = await resp.text();
+                    throw new Error(`api error ${resp.status}: ${txt}`);
+                }
+            }, { delay: this.#retryInterval, retryCount: this.#retryCount });
+        }
+        catch (e) {
+            this.#logger?.error(`cannot send telegram ${severity}: ${e}`);
+        }
+    }
+    #toTelegramPayloads(message) {
+        const { md: mdMessage, plain } = message;
+        if (!mdMessage) {
+            return this.#slicePlainText(plain);
+        }
+        let text = mdMessage;
+        if (this.#prefix) {
+            text = md.join([md.bold(this.#prefix), text], " ");
+        }
+        const mdText = text.toString();
+        if (mdText.length > this.#maxChunkSize) {
+            return this.#slicePlainText(plain);
+        }
+        return [{ text: mdText, parse_mode: "MarkdownV2" }];
+    }
+    /**
+     * Telegram has a limit on message size (default 4096 characters).
+     * This function slices the text into chunks respecting the limit.
+     * Each chunk is prefixed with the prefix (if set), ensuring the total length <= maxChunkSize.
+     * @param text - The text to slice.
+     * @returns An array of texts.
+     */
+    #slicePlainText(text) {
+        const chunks = [];
+        const prefix = this.#prefix ? `${this.#prefix} ` : "";
+        const maxChunkSize = this.#maxChunkSize - prefix.length;
+        for (let i = 0; i < text.length; i += maxChunkSize) {
+            const chunkText = text.slice(i, i + maxChunkSize);
+            chunks.push({ text: `${prefix}${chunkText}` });
+        }
+        return chunks;
+    }
+}

package/dist/notifications/ThrottleManager.d.ts

@@ -0,0 +1,18 @@
+import type { ThrottleFn } from "./types.js";
+export declare function defaultBackoffFn(prevWait: number): number;
+/**
+ * Manages per-feed throttling with exponential backoff.
+ * Each dedupe key has its own independent throttle timer.
+ */
+export declare class ThrottleManager {
+    #private;
+    /**
+     * Checks if it's permitted to send a message for the given dedupe key
+     * @returns
+     */
+    canSend(dedupeKey?: string): boolean;
+    /**
+     * Records that notification was sent for the given dedupe key
+     */
+    onSent(dedupeKey?: string, throttleFn?: ThrottleFn): void;
+}

package/dist/notifications/ThrottleManager.js

@@ -0,0 +1,40 @@
+import { LRUCache } from "lru-cache";
+export function defaultBackoffFn(prevWait) {
+    return Math.min(prevWait ? prevWait * 2 : 10 * 60 * 1000, // 10 minutes
+    24 * 60 * 60 * 1000);
+}
+/**
+ * Manages per-feed throttling with exponential backoff.
+ * Each dedupe key has its own independent throttle timer.
+ */
+export class ThrottleManager {
+    #state = new LRUCache({ max: 5000 });
+    /**
+     * Checks if it's permitted to send a message for the given dedupe key
+     * @returns
+     */
+    canSend(dedupeKey) {
+        if (!dedupeKey) {
+            return true;
+        }
+        const state = this.#getState(dedupeKey);
+        const timeSinceLastAlert = Date.now() - state.lastAlertTime;
+        return timeSinceLastAlert >= state.currentWait;
+    }
+    /**
+     * Records that notification was sent for the given dedupe key
+     */
+    onSent(dedupeKey, throttleFn = defaultBackoffFn) {
+        if (!dedupeKey) {
+            return;
+        }
+        const state = this.#getState(dedupeKey);
+        this.#state.set(dedupeKey, {
+            lastAlertTime: Date.now(),
+            currentWait: throttleFn(state.currentWait),
+        });
+    }
+    #getState(dedupeKey) {
+        return this.#state.get(dedupeKey) ?? { lastAlertTime: 0, currentWait: 0 };
+    }
+}

package/dist/notifications/createNotifier.d.ts

@@ -0,0 +1,4 @@
+import type { ILogger } from "@gearbox-protocol/sdk";
+import { NotificationConfig } from "./schema.js";
+import type { INotifier } from "./types.js";
+export declare function createNotifier(config: NotificationConfig, logger?: ILogger): INotifier | undefined;

package/dist/notifications/createNotifier.js

@@ -0,0 +1,18 @@
+import { prettifyError } from "zod";
+import { SlackNotifier } from "./SlackNotifier.js";
+import { NotificationConfig } from "./schema.js";
+import { TelegramNotifier } from "./TelegramNotifier.js";
+export function createNotifier(config, logger) {
+    const parsed = NotificationConfig.safeParse(config);
+    if (!parsed.success) {
+        console.log(">>>>", parsed.error);
+        logger?.warn(`invalid notification config: ${prettifyError(parsed.error)}`);
+        return undefined;
+    }
+    switch (parsed.data.type) {
+        case "telegram":
+            return new TelegramNotifier(parsed.data, logger);
+        case "slack":
+            return new SlackNotifier(parsed.data, logger);
+    }
+}

package/dist/notifications/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./createNotifier.js";
+export * from "./NotificationsService.js";
+export * from "./schema.js";
+export * from "./types.js";

package/dist/notifications/index.js

@@ -0,0 +1,4 @@
+export * from "./createNotifier.js";
+export * from "./NotificationsService.js";
+export * from "./schema.js";
+export * from "./types.js";

package/dist/notifications/schema.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod/v4";
+import { CensoredString } from "../CensoredString.js";
+export declare const TelegramConfig: z.ZodObject<{
+    type: z.ZodLiteral<"telegram">;
+    token: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    alertsChannel: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    notificationsChannel: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>>;
+    prefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TelegramConfig = z.infer<typeof TelegramConfig>;
+export declare const SlackConfig: z.ZodObject<{
+    type: z.ZodLiteral<"slack">;
+    webhookUrl: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    alertsOnly: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<boolean, any>>>;
+}, z.core.$strip>;
+export type SlackConfig = z.infer<typeof SlackConfig>;
+export declare const NotificationConfig: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"telegram">;
+    token: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    alertsChannel: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    notificationsChannel: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>>;
+    prefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"slack">;
+    webhookUrl: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<CensoredString<string>, CensoredString<string>>]>, z.ZodTransform<CensoredString<string>, string | CensoredString<string>>>;
+    alertsOnly: z.ZodOptional<z.ZodPipe<z.ZodAny, z.ZodTransform<boolean, any>>>;
+}, z.core.$strip>], "type">;
+export type NotificationConfig = z.infer<typeof NotificationConfig>;

package/dist/notifications/schema.js

@@ -0,0 +1,38 @@
+import { z } from "zod/v4";
+import { CensoredString } from "../CensoredString.js";
+import { boolLike } from "../schema-primitives.js";
+export const TelegramConfig = z.object({
+    type: z.literal("telegram"),
+    token: z
+        .union([z.string(), z.instanceof(CensoredString)])
+        .transform(CensoredString.transform),
+    alertsChannel: z
+        .union([z.string().startsWith("-"), z.instanceof(CensoredString)])
+        .transform(CensoredString.transform),
+    /**
+     * Optional channel to send notifications to
+     * If not set, notifications will not be sent
+     */
+    notificationsChannel: z
+        .union([z.string().startsWith("-"), z.instanceof(CensoredString)])
+        .transform(CensoredString.transform)
+        .optional(),
+    prefix: z.string().optional(),
+});
+export const SlackConfig = z.object({
+    type: z.literal("slack"),
+    /**
+     * Slack webhook URL for sending notifications
+     */
+    webhookUrl: z
+        .union([z.string(), z.instanceof(CensoredString)])
+        .transform(CensoredString.transform),
+    /**
+     * If true, only alerts will be sent. Informational notifications are suppressed
+     */
+    alertsOnly: boolLike().optional(),
+});
+export const NotificationConfig = z.discriminatedUnion("type", [
+    TelegramConfig,
+    SlackConfig,
+]);

package/dist/notifications/types.d.ts

@@ -0,0 +1,88 @@
+import type { Markdown } from "@vlad-yakovlev/telegram-md";
+import type { Address } from "viem";
+import type { NotificationConfig } from "./schema.js";
+export type NotificationSeverity = "alert" | "notification";
+/**
+ * Notification that can be deduplicated
+ */
+export interface IDedupableNotification {
+    /**
+     * Messages with the same dedupe key will be throttled to avoid spam
+     * If not provided, the message will not be throttled
+     */
+    dedupeKey?: string;
+    /**
+     * Function to calculate the wait time between deduped messages
+     * If not provided, the default backoff will be used
+     */
+    throttleFn?: ThrottleFn;
+    /**
+     * Plaintext notification message
+     */
+    plain: string;
+    /**
+     * Optional markdown verison of notification message
+     */
+    md?: Markdown;
+}
+/**
+ * Function to calculate the wait time between deduped messages
+ * @param prevWaitMs The wait time of the previous message, 0 for the first message
+ * @returns The wait time for the next message in milliseconds
+ */
+export type ThrottleFn = (prevWaitMs: number) => number;
+/**
+ * Implement this interface for your notification classes
+ */
+export interface INotification {
+    /**
+     * Function to generate the message for a recipient. Undefined means global message (gearbox notifications)
+     * This allows us to put the logic to fan out message to different recipients inside the class that implements INotificationMessage,
+     * and not to put this logic into the service that sends the notifications (you can still put it there, though)
+     *
+     * @param recipient The recipient to generate the message for, or undefined for the default/global recipient (gearbox notifications)
+     * @returns The message for the recipient, or undefined for no message
+     */
+    messageFor: (recipient?: Address) => string | IDedupableNotification | undefined;
+}
+/**
+ * A notification message, dumb strings and markdowns are treated as global notifications
+ */
+export type NotificationLike = string | IDedupableNotification | INotification;
+/**
+ * Notification service with deduplication and fan out logic
+ */
+export interface INotificationService {
+    /**
+     * Send an alert to Signl
+     * @param message
+     * @returns
+     */
+    signl: (message: string) => void;
+    /**
+     * Sends high priority notification
+     * @param message
+     * @returns
+     */
+    alert: (message: NotificationLike) => void;
+    /**
+     * Sends low priority notification
+     * @param message
+     * @returns
+     */
+    notify: (message: NotificationLike) => void;
+    /**
+     * Register a recipient for notifications
+     * @param address The address of the recipient
+     * @param options The options for the recipient
+     */
+    registerRecipient: (address: Address, options: NotificationConfig) => void;
+}
+export interface INotifier {
+    /**
+     * Sends notification
+     * @param message
+     * @returns
+     */
+    notify: (message: IDedupableNotification, severity: NotificationSeverity) => void;
+}

package/dist/notifications/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gearbox-protocol/cli-utils",
   "description": "Utils for creating cli apps",
-  "version": "5.67.1",
+  "version": "5.68.0",
   "homepage": "https://gearbox.fi",
   "keywords": [
     "gearbox"
@@ -33,9 +33,12 @@
     "@aws-sdk/client-secrets-manager": "^3.971.0",
     "@aws-sdk/client-ssm": "^3.971.0",
     "@gearbox-protocol/sdk": ">=12.5.0",
+    "@vlad-yakovlev/telegram-md": "^2.1.0",
     "abitype": "^1.2.3",
     "commander": "^14.0.2",
     "lodash-es": "^4.17.22",
+    "lru-cache": "^11.2.4",
+    "p-queue": "^9.1.0",
     "viem": "^2.44.4",
     "yaml": "^2.8.2",
     "zod": "^4.3.5"