@gearbox-protocol/cli-utils 6.16.2 → 9.0.0-beta.12

package/dist/Zommand.js

@@ -1,98 +0,0 @@
-import { Command, Option } from "@commander-js/extra-typings";
-import * as z4 from "zod/v4/core";
-import { decompressObject } from "./compressedConfig.js";
-import { resolveYamlFiles } from "./resolveYamlFiles.js";
-export const zommandRegistry = z4.registry();
-export class Zommand extends Command {
-    #schema;
-    #templatedData;
-    #envToObjectKeys = {};
-    constructor(name, opts) {
-        super(name);
-        const { schema, templateData, configFile = true, inlineConfig = true, } = opts;
-        this.#schema = schema;
-        this.#templatedData = templateData;
-        const def = this.#schema._zod.def;
-        if (def.type === "object") {
-            this.#addOptionsFromObject(def);
-        }
-        else if (def.type === "union") {
-            for (const o of def.options) {
-                const opt = o;
-                if (opt._zod.def.type === "object") {
-                    this.#addOptionsFromObject(opt._zod.def);
-                }
-            }
-        }
-        else {
-            throw new Error(`expected object schema, got ${this.#schema._zod.def.type}`);
-        }
-        if (configFile) {
-            let opt = new Option("--config [file]", "config file (or s3 link");
-            if (typeof configFile === "string") {
-                opt = opt.default(configFile);
-            }
-            this.addOption(opt);
-        }
-        if (inlineConfig) {
-            this.addOption(new Option("--inline-config [config]", "inline config"));
-        }
-    }
-    #addOptionsFromObject(def) {
-        const shape = def.shape;
-        for (const [key, optionSchema] of Object.entries(shape)) {
-            const meta = zommandRegistry.get(optionSchema);
-            if (!meta) {
-                continue;
-            }
-            // this avoids duplicate options in case of discriminated unions
-            const existing = this.options.find(o => o.flags === meta.flags);
-            if (!existing) {
-                let description = meta.description;
-                if (meta.env) {
-                    description = `${description} (env variable ${meta.env})`;
-                }
-                this.addOption(new Option(meta.flags, description));
-                if (meta.env) {
-                    this.#envToObjectKeys[meta.env] = key;
-                }
-            }
-        }
-    }
-    action(fn) {
-        return super.action(async (...args) => {
-            const argz = args;
-            const _cmd = argz.splice(-1);
-            const [{ config, inlineConfig, ...opts }] = argz.splice(-1);
-            let fromYaml = {};
-            if (config) {
-                fromYaml = await resolveYamlFiles(config, {
-                    ...process.env,
-                    ...this.#templatedData,
-                });
-            }
-            let fromInlineConfig = {};
-            if (inlineConfig) {
-                fromInlineConfig = await decompressObject(inlineConfig, this.#templatedData);
-            }
-            else if (process.env.INLINE_CONFIG) {
-                fromInlineConfig = await decompressObject(process.env.INLINE_CONFIG, this.#templatedData);
-            }
-            const schemaFromEnv = {};
-            for (const [env, key] of Object.entries(this.#envToObjectKeys)) {
-                if (process.env[env]) {
-                    schemaFromEnv[key] = process.env[env];
-                }
-            }
-            // deep merge is not required: env and cli flags are for top-level only
-            const combined = {
-                ...schemaFromEnv,
-                ...fromYaml,
-                ...fromInlineConfig,
-                ...opts,
-            };
-            const data = z4.parse(this.#schema, combined);
-            await fn.apply(this, [...argz, data, this]);
-        });
-    }
-}

package/dist/compressedConfig.d.ts

@@ -1,10 +0,0 @@
-/**
- * Compress a plain JS object into a base64url string
- * suitable for env vars.
- */
-export declare function compressObject(obj: unknown): string;
-/**
- * Decompress a base64url string back into a JS object
- * Allows to pass template data to resolve promises/env
- */
-export declare function decompressObject<T = unknown>(value: string, templateData?: Record<string, unknown>): Promise<T>;

package/dist/compressedConfig.js

@@ -1,22 +0,0 @@
-import { deflateSync, inflateSync } from "node:zlib";
-import { resolveFromObject } from "./resolveYamlFiles.js";
-/**
- * Compress a plain JS object into a base64url string
- * suitable for env vars.
- */
-export function compressObject(obj) {
-    const json = JSON.stringify(obj);
-    const compressed = deflateSync(Buffer.from(json, "utf8"));
-    return compressed.toString("base64url");
-}
-/**
- * Decompress a base64url string back into a JS object
- * Allows to pass template data to resolve promises/env
- */
-export async function decompressObject(value, templateData) {
-    const compressed = Buffer.from(value, "base64url");
-    const str = inflateSync(compressed).toString("utf8");
-    const json = JSON.parse(str);
-    const result = await resolveFromObject(json, templateData);
-    return result;
-}

package/dist/createPinoCensor.d.ts

@@ -1,5 +0,0 @@
-/**
- * Gathers known secrets from a config and returns a function that replaces each raw secret with its masked representation.
- * Intended for pino's `hooks.streamWrite`
- */
-export declare function createPinoCensor(config: unknown): (s: string) => string;

package/dist/createPinoCensor.js

@@ -1,53 +0,0 @@
-import { CensoredString } from "./CensoredString.js";
-import { CensoredURL } from "./CensoredURL.js";
-/**
- * Raw values shorter than this are not censored, to avoid masking unrelated
- * substrings throughout the log output.
- */
-const MIN_SECRET_LENGTH = 4;
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function collectSecrets(value, out) {
-    if (value == null) {
-        return;
-    }
-    if (value instanceof CensoredString || value instanceof CensoredURL) {
-        const raw = value.value;
-        if (raw.length >= MIN_SECRET_LENGTH) {
-            out.set(raw, value.toString());
-        }
-        return;
-    }
-    if (typeof value !== "object") {
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            collectSecrets(item, out);
-        }
-        return;
-    }
-    for (const item of Object.values(value)) {
-        collectSecrets(item, out);
-    }
-}
-/**
- * Gathers known secrets from a config and returns a function that replaces each raw secret with its masked representation.
- * Intended for pino's `hooks.streamWrite`
- */
-export function createPinoCensor(config) {
-    const map = new Map();
-    collectSecrets(config, map);
-    if (map.size === 0) {
-        return s => s;
-    }
-    // Longer secrets first so a secret that is a substring of another does not
-    // shadow the longer match.
-    const pattern = [...map.keys()]
-        .sort((a, b) => b.length - a.length)
-        .map(escapeRegExp)
-        .join("|");
-    const re = new RegExp(pattern, "g");
-    return s => s.replace(re, m => map.get(m) ?? m);
-}

package/dist/fetchRetry.d.ts

@@ -1,7 +0,0 @@
-interface RetrySettings {
-    retries?: number;
-    retryInterval?: number;
-    validateResponse?: (response: Response) => void;
-}
-export declare function fetchRetry(input: string | URL, init?: RequestInit & RetrySettings): Promise<Response>;
-export {};

package/dist/fetchRetry.js

@@ -1,26 +0,0 @@
-// Mirror of packages/shared/src/fetchRetry.ts; keep in sync.
-import { sleep } from "./sleep.js";
-const DEFAULT_RETRIES = 5;
-const DEFAULT_RETRY_INTERVAL = 1000;
-export async function fetchRetry(input, init = {}) {
-    const { retries = DEFAULT_RETRIES, retryInterval = DEFAULT_RETRY_INTERVAL, validateResponse, ...options } = init;
-    try {
-        const response = await fetch(input, options);
-        validateResponse?.(response);
-        return response;
-    }
-    catch (e) {
-        if (retries > 0) {
-            await sleep(retryInterval);
-            return fetchRetry(input, {
-                ...options,
-                retries: retries - 1,
-                retryInterval,
-                validateResponse,
-            });
-        }
-        else {
-            throw e;
-        }
-    }
-}

package/dist/getFirstHttpTransportOptions.d.ts

@@ -1,7 +0,0 @@
-import type { HttpTransportConfig } from "viem";
-import type { ProvidersSchema } from "./providers-schema.js";
-export interface HttpTransportOptions {
-    url?: string | undefined;
-    config: HttpTransportConfig;
-}
-export declare function getFirstHttpTransportOptions(config: ProvidersSchema): HttpTransportOptions;

package/dist/getFirstHttpTransportOptions.js

@@ -1,13 +0,0 @@
-import { getProviders } from "./getProviders.js";
-export function getFirstHttpTransportOptions(config) {
-    const [provider] = getProviders(config);
-    if (!provider) {
-        throw new Error("No provider found");
-    }
-    return {
-        url: provider.url,
-        config: {
-            ...provider.httpTransportOptions,
-        },
-    };
-}

package/dist/getPromisePath.d.ts

@@ -1,7 +0,0 @@
-/**
- * Similar to lodash.get, but supports promises
- * @param object
- * @param keys
- * @returns
- */
-export default function getPromisePath<V = any>(object: any, path: string): Promise<V>;

package/dist/getPromisePath.js

@@ -1,18 +0,0 @@
-/**
- * Similar to lodash.get, but supports promises
- * @param object
- * @param keys
- * @returns
- */
-export default async function getPromisePath(object, path) {
-    return getPromised(object, path.split("."));
-}
-async function getPromised(object, keys) {
-    if (keys.length === 0) {
-        return Promise.resolve(object);
-    }
-    const [key, ...rest] = keys;
-    const value = object[key];
-    const resolved = await Promise.resolve(value);
-    return getPromised(resolved, rest);
-}

package/dist/getProviders.d.ts

@@ -1,4 +0,0 @@
-import type { ILogger } from "@gearbox-protocol/sdk";
-import type { ProviderConfig } from "@gearbox-protocol/sdk/dev";
-import type { ProvidersSchema } from "./providers-schema.js";
-export declare function getProviders(config: ProvidersSchema, logger?: ILogger): ProviderConfig[];

package/dist/getProviders.js

@@ -1,104 +0,0 @@
-import { CensoredURL } from "./CensoredURL.js";
-import { getAlchemyUrl, getAnkrUrl, getDrpcUrl, getErpcKey, getThirdWebUrl, } from "./providers.js";
-export function getProviders(config, logger) {
-    const { network, enabledProviders = [
-        "erpc",
-        "custom",
-        "drpc",
-        "alchemy",
-        "ankr",
-        "thirdweb",
-    ], alchemyKeys = [], ankrKeys = [], drpcKeys = [], thirdwebKeys = [], jsonRpcProviders = [], erpcProjectId, erpcUrl, } = config;
-    const result = [];
-    for (const p of enabledProviders) {
-        switch (p) {
-            case "alchemy":
-                result.push(...alchemyKeys.map(k => ({
-                    name: "alchemy",
-                    url: getAlchemyUrl(network, k.value),
-                })));
-                break;
-            case "drpc":
-                result.push(...drpcKeys.map(k => ({
-                    name: "drpc",
-                    url: getDrpcUrl(network, k.value),
-                })));
-                break;
-            case "ankr":
-                result.push(...ankrKeys.map(k => ({
-                    name: "ankr",
-                    url: getAnkrUrl(network, k.value),
-                })));
-                break;
-            case "thirdweb":
-                result.push(...thirdwebKeys.map(k => ({
-                    name: "thirdweb",
-                    url: getThirdWebUrl(network, k.value),
-                })));
-                break;
-            case "custom":
-                result.push(...jsonRpcProviders.map((url) => {
-                    const urlObj = new URL(url.value);
-                    const hasCredentials = urlObj.username || urlObj.password;
-                    let cleanUrl = url.value;
-                    let httpTransportOptions = {};
-                    if (hasCredentials) {
-                        // Create URL without credentials
-                        const cleanUrlObj = new URL(url.value);
-                        cleanUrlObj.username = "";
-                        cleanUrlObj.password = "";
-                        cleanUrl = cleanUrlObj.toString();
-                        // Create Basic Auth header
-                        const credentials = `${urlObj.username}:${urlObj.password}`;
-                        const encodedCredentials = Buffer.from(credentials).toString("base64");
-                        httpTransportOptions = {
-                            fetchOptions: {
-                                headers: {
-                                    Authorization: `Basic ${encodedCredentials}`,
-                                },
-                            },
-                        };
-                    }
-                    return {
-                        name: getTopLevelDomain(urlObj),
-                        url: cleanUrl,
-                        httpTransportOptions,
-                    };
-                }));
-                break;
-            case "erpc":
-                if (erpcProjectId && erpcUrl) {
-                    result.push({
-                        name: "erpc",
-                        url: getErpcKey(network, erpcProjectId, erpcUrl),
-                    });
-                }
-                break;
-        }
-    }
-    if (logger) {
-        const providers = result
-            .filter(p => !!p.url)
-            .map(p => ({
-            name: p.name,
-            url: new CensoredURL(p.url),
-        }));
-        logger.debug({ providers, network }, "gathered providers");
-    }
-    return result
-        .map(p => ({
-        ...p,
-        httpClientOptions: {
-            ...p.httpTransportOptions,
-            methods: { exclude: ["eth_fillTransaction"] },
-        },
-    }))
-        .filter(p => !!p.url);
-}
-/**
- * Take the last two parts for top-level domain (e.g., "google.com" from "a.b.c.google.com")
- **/
-function getTopLevelDomain({ hostname }) {
-    const parts = hostname.split(".");
-    return parts.length >= 2 ? parts.slice(-2).join(".") : hostname;
-}

package/dist/notifications/NotificationsService.d.ts

@@ -1,19 +0,0 @@
-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, dedupeKey?: string): void;
-    alert(msg: NotificationLike): void;
-    notify(msg: NotificationLike): void;
-}

package/dist/notifications/NotificationsService.js

@@ -1,76 +0,0 @@
-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, dedupeKey) {
-        this.#signlNotifier?.alert(message, dedupeKey);
-    }
-    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) {
-                const notification = this.#toDedupableNotification(recipientNotification);
-                notifier.notify(notification, severity);
-                // log global notifications
-                if (addr === ADDRESS_0X0) {
-                    if (severity === "alert") {
-                        this.#logger?.warn(notification.plain);
-                    }
-                    else {
-                        this.#logger?.debug(notification.plain);
-                    }
-                }
-            }
-        }
-    }
-    #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

@@ -1,13 +0,0 @@
-import type { ILogger } from "@gearbox-protocol/sdk";
-import type { SignlConfig } from "./schema.js";
-import type { ThrottleFn } from "./types.js";
-export type SignlServiceOptions = SignlConfig & {
-    retryInterval?: number;
-    retryCount?: number;
-    throttleFn?: ThrottleFn;
-};
-export default class SignlNotifier {
-    #private;
-    constructor(opts: SignlServiceOptions, logger?: ILogger);
-    alert(message: string, dedupeKey?: string): void;
-}

package/dist/notifications/SignlNotifier.js

@@ -1,58 +0,0 @@
-import { withRetry } from "viem";
-import { ThrottleManager } from "./ThrottleManager.js";
-const DEFAULT_RETRY_INTERVAL = 1000;
-const DEFAULT_RETRY_COUNT = 5;
-export default class SignlNotifier {
-    #logger;
-    #apiKey;
-    #teamId;
-    #retryInterval;
-    #retryCount;
-    #throttleManager = new ThrottleManager();
-    #throttleFn;
-    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;
-        this.#throttleFn = opts.throttleFn;
-        this.#logger?.info(opts, "signl notifier configured");
-    }
-    alert(message, dedupeKey) {
-        void this.#sendAlert(message, dedupeKey).catch(e => this.#logger?.error(e));
-    }
-    async #sendAlert(message, dedupeKey) {
-        if (dedupeKey && !this.#throttleManager.canSend(dedupeKey)) {
-            return;
-        }
-        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.value}`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    category: "emergency",
-                    severity: 0,
-                    teamId: this.#teamId.value,
-                    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 });
-        if (dedupeKey) {
-            this.#throttleManager.onSent(dedupeKey, this.#throttleFn);
-        }
-    }
-}

package/dist/notifications/SlackNotifier.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,38 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-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;
-}