@gearbox-protocol/cli-utils 6.11.0 → 6.13.1

package/dist/Whitelist.d.ts

@@ -0,0 +1,30 @@
+import type { ILogger, NetworkType } from "@gearbox-protocol/sdk";
+import { WhitelistItemSchema } from "./whitelist-schema.js";
+export interface WhitelistOptions {
+    url: string;
+    network: NetworkType;
+    logger?: ILogger;
+}
+/**
+ * Fetches a network-scoped whitelist from the deploy-tools backend and keeps
+ * it in memory with a 10-minute refresh interval.
+ *
+ * On fetch failure the previous in-memory copy is retained; if no successful
+ * fetch has occurred yet the whitelist is considered empty.
+ */
+export declare class Whitelist {
+    #private;
+    constructor({ url, network, logger }: WhitelistOptions);
+    /**
+     * Performs the initial fetch and starts the periodic refresh timer.
+     * Failure of the initial fetch is non-fatal: the whitelist stays empty.
+     */
+    start(): Promise<void>;
+    /** Stops the refresh timer. */
+    stop(): void;
+    /**
+     * Returns the matching whitelist entry for the given address, or
+     * `undefined` if absent or expired.
+     */
+    has(address: string): WhitelistItemSchema | undefined;
+}

package/dist/Whitelist.js

@@ -0,0 +1,84 @@
+import { setInterval } from "node:timers";
+import { AddressMap } from "@gearbox-protocol/sdk";
+import { z } from "zod/v4";
+import { fetchRetry } from "./fetchRetry.js";
+import { WhitelistItemSchema } from "./whitelist-schema.js";
+const REFRESH_INTERVAL_MS = 10 * 60 * 1000;
+const WhitelistResponse = z.array(WhitelistItemSchema);
+/**
+ * Fetches a network-scoped whitelist from the deploy-tools backend and keeps
+ * it in memory with a 10-minute refresh interval.
+ *
+ * On fetch failure the previous in-memory copy is retained; if no successful
+ * fetch has occurred yet the whitelist is considered empty.
+ */
+export class Whitelist {
+    #url;
+    #network;
+    #logger;
+    #items = new AddressMap();
+    #refreshInterval;
+    constructor({ url, network, logger }) {
+        this.#url = url;
+        this.#network = network;
+        this.#logger = logger?.child?.({ name: "whitelist" }) ?? logger;
+    }
+    /**
+     * Performs the initial fetch and starts the periodic refresh timer.
+     * Failure of the initial fetch is non-fatal: the whitelist stays empty.
+     */
+    async start() {
+        this.#logger?.info(`loading ${this.#network} whitelist from ${this.#url}, refresh every ${REFRESH_INTERVAL_MS / 1000}s`);
+        await this.#refresh();
+        this.#refreshInterval = setInterval(() => {
+            this.#refresh().catch(e => {
+                this.#logger?.warn(`unexpected whitelist refresh error: ${e}`);
+            });
+        }, REFRESH_INTERVAL_MS);
+    }
+    /** Stops the refresh timer. */
+    stop() {
+        if (this.#refreshInterval) {
+            clearInterval(this.#refreshInterval);
+            this.#refreshInterval = undefined;
+        }
+    }
+    /**
+     * Fetches the whitelist from the backend, parses it and atomically
+     * replaces the in-memory map. On any error logs a warning and retains
+     * the previous map.
+     */
+    async #refresh() {
+        try {
+            const resp = await fetchRetry(this.#url);
+            if (!resp.ok) {
+                throw new Error(`whitelist fetch failed: ${resp.status} ${resp.statusText}`);
+            }
+            const data = await resp.json();
+            const items = WhitelistResponse.parse(data).filter(i => i.network === this.#network);
+            const next = new AddressMap();
+            for (const item of items) {
+                next.upsert(item.address, item);
+            }
+            this.#items = next;
+            this.#logger?.debug(`loaded ${items.length} whitelist entries for ${this.#network}`);
+        }
+        catch (e) {
+            this.#logger?.warn(`failed to refresh whitelist from ${this.#url}, keeping previous version: ${e}`);
+        }
+    }
+    /**
+     * Returns the matching whitelist entry for the given address, or
+     * `undefined` if absent or expired.
+     */
+    has(address) {
+        const item = this.#items.get(address);
+        if (!item) {
+            return undefined;
+        }
+        if (item.expiresAt !== undefined && Date.now() / 1000 >= item.expiresAt) {
+            return undefined;
+        }
+        return item;
+    }
+}

package/dist/fetchRetry.d.ts

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

@@ -0,0 +1,26 @@
+// 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/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./CensoredString.js";
 export * from "./CensoredURL.js";
 export * from "./compressedConfig.js";
+export * from "./fetchRetry.js";
 export * from "./getFirstHttpTransportOptions.js";
 export * from "./getProviders.js";
 export * from "./notifications/index.js";
@@ -10,5 +11,8 @@ export * from "./resolveYamlFiles.js";
 export * from "./SecretsManager.js";
 export * from "./SSMManager.js";
 export * from "./schema-primitives.js";
+export * from "./sleep.js";
 export * from "./uncensorMap.js";
+export * from "./Whitelist.js";
+export * from "./whitelist-schema.js";
 export * from "./Zommand.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./CensoredString.js";
 export * from "./CensoredURL.js";
 export * from "./compressedConfig.js";
+export * from "./fetchRetry.js";
 export * from "./getFirstHttpTransportOptions.js";
 export * from "./getProviders.js";
 export * from "./notifications/index.js";
@@ -10,5 +11,8 @@ export * from "./resolveYamlFiles.js";
 export * from "./SecretsManager.js";
 export * from "./SSMManager.js";
 export * from "./schema-primitives.js";
+export * from "./sleep.js";
 export * from "./uncensorMap.js";
+export * from "./Whitelist.js";
+export * from "./whitelist-schema.js";
 export * from "./Zommand.js";

package/dist/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/sleep.js

@@ -0,0 +1,6 @@
+// Mirror of packages/shared/src/sleep.ts; keep in sync.
+export async function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/whitelist-schema.d.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/v4";
+export declare const WhitelistItemsSchema: z.ZodObject<{
+    network: z.ZodEnum<{
+        Mainnet: "Mainnet";
+        Arbitrum: "Arbitrum";
+        Optimism: "Optimism";
+        Base: "Base";
+        Sonic: "Sonic";
+        MegaETH: "MegaETH";
+        Monad: "Monad";
+        Berachain: "Berachain";
+        Avalanche: "Avalanche";
+        BNB: "BNB";
+        WorldChain: "WorldChain";
+        Etherlink: "Etherlink";
+        Hemi: "Hemi";
+        Lisk: "Lisk";
+        Plasma: "Plasma";
+        Somnia: "Somnia";
+    }>;
+    addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
+    reason: z.ZodDefault<z.ZodString>;
+    issue: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WhitelistItemsSchema = z.infer<typeof WhitelistItemsSchema>;
+export declare const WhitelistItemSchema: z.ZodObject<{
+    network: z.ZodEnum<{
+        Mainnet: "Mainnet";
+        Arbitrum: "Arbitrum";
+        Optimism: "Optimism";
+        Base: "Base";
+        Sonic: "Sonic";
+        MegaETH: "MegaETH";
+        Monad: "Monad";
+        Berachain: "Berachain";
+        Avalanche: "Avalanche";
+        BNB: "BNB";
+        WorldChain: "WorldChain";
+        Etherlink: "Etherlink";
+        Hemi: "Hemi";
+        Lisk: "Lisk";
+        Plasma: "Plasma";
+        Somnia: "Somnia";
+    }>;
+    category: z.ZodString;
+    address: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    reason: z.ZodDefault<z.ZodString>;
+    issue: z.ZodOptional<z.ZodString>;
+    contractType: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WhitelistItemSchema = z.infer<typeof WhitelistItemSchema>;

package/dist/whitelist-schema.js

@@ -0,0 +1,21 @@
+// Mirror of packages/shared/src/whitelist-schema.ts; keep in sync.
+import { NetworkType } from "@gearbox-protocol/sdk";
+import { z } from "zod/v4";
+import { addressLike } from "./schema-primitives.js";
+export const WhitelistItemsSchema = z.object({
+    network: NetworkType,
+    addresses: z.array(addressLike()).min(1),
+    reason: z.string().default(""),
+    issue: z.string().optional(),
+    expiresAt: z.number().optional(),
+});
+export const WhitelistItemSchema = z.object({
+    network: NetworkType,
+    category: z.string(),
+    address: addressLike(),
+    reason: z.string().default(""),
+    issue: z.string().optional(),
+    contractType: z.string().optional(),
+    createdAt: z.number(),
+    expiresAt: z.number().optional(),
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gearbox-protocol/cli-utils",
   "description": "Utils for creating cli apps",
-  "version": "6.11.0",
+  "version": "6.13.1",
   "homepage": "https://gearbox.fi",
   "keywords": [
     "gearbox"