@augustdigital/sdk 4.27.4-alpha.0 → 5.1.1

package/lib/core/fetcher.js

@@ -26,6 +26,71 @@ const web3_1 = require("./helpers/web3");
 const core_2 = require("./constants/core");
 const vaults_1 = require("./helpers/vaults");
 const analytics_1 = require("./analytics");
+const sanitize_1 = require("./analytics/sanitize");
+const errors_1 = require("./errors");
+function errorFromResponseStatus(status, message, options) {
+    if (status === 401) {
+        return new errors_1.AugustAuthError('AUTH_UNAUTHORIZED', message, options);
+    }
+    if (status === 403) {
+        return new errors_1.AugustAuthError('AUTH_FORBIDDEN', message, options);
+    }
+    if (status === 429) {
+        return new errors_1.AugustRateLimitError(message, options);
+    }
+    return new errors_1.AugustServerError(status, message, options);
+}
+function buildRequestAbortSignal(options) {
+    const timeoutMs = options?.timeoutMs ?? core_2.REQUEST_TIMEOUT_MS;
+    const timeoutController = new AbortController();
+    let didTimeout = false;
+    const timeoutId = setTimeout(() => {
+        didTimeout = true;
+        timeoutController.abort();
+    }, timeoutMs);
+    let signal = timeoutController.signal;
+    let relayCleanup = () => { };
+    if (options?.signal) {
+        if (typeof AbortSignal.any === 'function') {
+            signal = AbortSignal.any([timeoutController.signal, options.signal]);
+        }
+        else if (options.signal.aborted) {
+            timeoutController.abort();
+        }
+        else {
+            const relay = () => timeoutController.abort();
+            options.signal.addEventListener('abort', relay, { once: true });
+            relayCleanup = () => options.signal.removeEventListener('abort', relay);
+        }
+    }
+    return {
+        signal,
+        timeoutId,
+        timeoutMs,
+        timedOut: () => didTimeout,
+        cleanup: () => {
+            clearTimeout(timeoutId);
+            relayCleanup();
+        },
+    };
+}
+let _overrideDeprecationWarned = false;
+function warnOverrideDeprecation(callerTag) {
+    if (_overrideDeprecationWarned)
+        return;
+    _overrideDeprecationWarned = true;
+    console.warn(`[@augustdigital/sdk] ${callerTag}: option "override" is deprecated and will be removed in a future major version. Pass a valid apiKey instead.`);
+}
+function readResponseHeader(headers, name) {
+    if (!headers)
+        return undefined;
+    const h = headers;
+    if (typeof h.get === 'function') {
+        return h.get(name) ?? undefined;
+    }
+    const v = headers[name];
+    return typeof v === 'string' ? v : undefined;
+}
 exports.CACHE = new lru_cache_1.LRUCache({
     max: 1000,
     ttl: 1000 * 60 * 60 * 24,
@@ -57,52 +122,85 @@ const PRICE_ERROR_CACHE = new lru_cache_1.LRUCache({
     allowStale: false,
 });
 const PRICE_REQUESTS = new Map();
+function buildAugustUrl(server, relativeUrl) {
+    const serverKey = server;
+    const base = core_2.WEBSERVER_URL[serverKey];
+    if (!base) {
+        throw new errors_1.AugustValidationError('INVALID_URL', `Unknown August server "${String(server)}". Expected one of: ${Object.keys(core_2.WEBSERVER_URL).join(', ')}`);
+    }
+    if (typeof relativeUrl !== 'string' || relativeUrl.length === 0) {
+        throw new errors_1.AugustValidationError('INVALID_URL', 'relativeUrl must be a non-empty string');
+    }
+    if (/^\s*[a-z][a-z0-9+.-]*:|^\s*\/\//i.test(relativeUrl)) {
+        throw new errors_1.AugustValidationError('INVALID_URL', `relativeUrl must be a path, not an absolute or protocol-relative URL`);
+    }
+    const candidate = `${base}${relativeUrl}`;
+    let url;
+    try {
+        url = new URL(candidate);
+    }
+    catch {
+        throw new errors_1.AugustValidationError('INVALID_URL', `Invalid URL path: ${(0, sanitize_1.sanitizeString)(relativeUrl)}`);
+    }
+    const baseOrigin = new URL(base).origin;
+    if (url.origin !== baseOrigin) {
+        throw new errors_1.AugustValidationError('INVALID_URL', `URL origin mismatch: refusing to fetch ${url.origin} from a "${serverKey}" request scoped to ${baseOrigin}`);
+    }
+    return url.toString();
+}
 async function fetchAugustWithKey(apiKey, relativeUrl, options) {
+    if (options?.override) {
+        warnOverrideDeprecation('fetchAugustWithKey');
+    }
     if (!apiKey && !options?.override) {
-        return { status: 500, statusText: 'x-api-key is undefined' };
+        throw new errors_1.AugustAuthError('AUTH_MISSING_KEY', 'fetchAugustWithKey: apiKey is required (set keys.august on the SDK constructor, or pass an explicit apiKey).');
     }
     const defaultHeaders = {
         'x-api-key': apiKey,
         'content-type': 'application/json',
         accept: 'application/json',
     };
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), core_2.REQUEST_TIMEOUT_MS);
+    const { signal: requestSignal, timeoutMs: effectiveTimeoutMs, timedOut, cleanup, } = buildRequestAbortSignal(options);
     const startTime = performance.now();
     const server = options?.server || 'production';
     try {
-        const res = await fetch(`${core_2.WEBSERVER_URL[server]}${relativeUrl}`, {
+        const safeUrl = buildAugustUrl(server, relativeUrl);
+        const res = await fetch(safeUrl, {
             headers: {
                 ...defaultHeaders,
                 ...options?.headers,
             },
             method: options?.method ?? 'GET',
             body: JSON.stringify(options?.data),
-            signal: controller.signal,
+            signal: requestSignal,
         });
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, res.status, server);
-        const correlationId = res.headers['x-correlation-id'];
+        const correlationId = readResponseHeader(res.headers, 'x-correlation-id');
         const logger = logger_1.Logger.getLogger();
         if (!res.ok || res.status !== 200) {
             if (correlationId && logger) {
                 logger.setTag('correlation_id', correlationId);
             }
-            const error = new Error(`Request failed: ${res.status}`);
+            const error = errorFromResponseStatus(res.status, `Request failed: ${res.status}`, { correlationId });
             logger?.captureException(error, { correlationId, status: res.status });
             throw error;
         }
         return res;
     }
     catch (error) {
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, 0, server);
-        if (error.name === 'AbortError') {
-            const timeoutError = new Error(`Request timeout after ${core_2.REQUEST_TIMEOUT_MS / 1000}s: ${relativeUrl}`);
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err.name === 'AbortError') {
+            if (!timedOut()) {
+                throw err;
+            }
+            const timeoutError = new errors_1.AugustTimeoutError((0, sanitize_1.sanitizeString)(`Request timeout after ${effectiveTimeoutMs / 1000}s: ${relativeUrl}`), effectiveTimeoutMs);
             logger_1.Logger.log.error('fetchAugustWithKey', timeoutError, { relativeUrl });
             throw timeoutError;
         }
-        throw error;
+        throw err;
     }
 }
 async function fetchAugustPublic(relativeUrl, options) {
@@ -110,42 +208,46 @@ async function fetchAugustPublic(relativeUrl, options) {
         'content-type': 'application/json',
         accept: 'application/json',
     };
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), core_2.REQUEST_TIMEOUT_MS);
+    const { signal: requestSignal, timeoutMs: effectiveTimeoutMs, timedOut, cleanup, } = buildRequestAbortSignal(options);
     const startTime = performance.now();
     try {
-        const res = await fetch(`${core_2.WEBSERVER_URL['public']}${relativeUrl}`, {
+        const safeUrl = buildAugustUrl('public', relativeUrl);
+        const res = await fetch(safeUrl, {
             headers: {
                 ...defaultHeaders,
                 ...options?.headers,
             },
             method: options?.method ?? 'GET',
             body: JSON.stringify(options?.data),
-            signal: controller.signal,
+            signal: requestSignal,
         });
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, res.status, 'public');
-        const correlationId = res.headers['x-correlation-id'];
+        const correlationId = readResponseHeader(res.headers, 'x-correlation-id');
         const logger = logger_1.Logger.getLogger();
         if (!res.ok || res.status !== 200) {
             if (correlationId && logger) {
                 logger.setTag('correlation_id', correlationId);
             }
-            const error = new Error(`Request failed: ${res.status}`);
+            const error = errorFromResponseStatus(res.status, `Request failed: ${res.status}`, { correlationId });
             logger?.captureException(error, { correlationId, status: res.status });
             throw error;
         }
         return res;
     }
     catch (error) {
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, 0, 'public');
-        if (error.name === 'AbortError') {
-            const timeoutError = new Error(`Request timeout after ${core_2.REQUEST_TIMEOUT_MS / 1000}s: ${relativeUrl}`);
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err.name === 'AbortError') {
+            if (!timedOut()) {
+                throw err;
+            }
+            const timeoutError = new errors_1.AugustTimeoutError((0, sanitize_1.sanitizeString)(`Request timeout after ${effectiveTimeoutMs / 1000}s: ${relativeUrl}`), effectiveTimeoutMs);
             logger_1.Logger.log.error('fetchAugustPublic', timeoutError, { relativeUrl });
             throw timeoutError;
         }
-        throw error;
+        throw err;
     }
 }
 async function fetchAugustWithBearer(bearerToken, relativeUrl, options) {
@@ -154,43 +256,47 @@ async function fetchAugustWithBearer(bearerToken, relativeUrl, options) {
         'content-type': 'application/json',
         accept: 'application/json',
     };
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), core_2.REQUEST_TIMEOUT_MS);
+    const { signal: requestSignal, timeoutMs: effectiveTimeoutMs, timedOut, cleanup, } = buildRequestAbortSignal(options);
     const startTime = performance.now();
     const server = options?.server ?? 'production';
     try {
-        const res = await fetch(`${core_2.WEBSERVER_URL[server]}${relativeUrl}`, {
+        const safeUrl = buildAugustUrl(server, relativeUrl);
+        const res = await fetch(safeUrl, {
             headers: {
                 ...defaultHeaders,
-                ...options.headers,
+                ...options?.headers,
             },
-            method: options.method,
-            body: JSON.stringify(options.data),
-            signal: controller.signal,
+            method: options?.method ?? 'GET',
+            body: JSON.stringify(options?.data),
+            signal: requestSignal,
         });
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, res.status, server);
-        const correlationId = res.headers['x-correlation-id'];
+        const correlationId = readResponseHeader(res.headers, 'x-correlation-id');
         const logger = logger_1.Logger.getLogger();
         if (!res.ok || res.status !== 200) {
             if (correlationId && logger) {
                 logger.setTag('correlation_id', correlationId);
             }
-            const error = new Error(`Request failed: ${res.status}`);
+            const error = errorFromResponseStatus(res.status, `Request failed: ${res.status}`, { correlationId });
             logger?.captureException(error, { correlationId, status: res.status });
             throw error;
         }
         return res;
     }
     catch (error) {
-        clearTimeout(timeoutId);
+        cleanup();
         (0, analytics_1.trackApiCall)(relativeUrl, options?.method ?? 'GET', startTime, 0, server);
-        if (error.name === 'AbortError') {
-            const timeoutError = new Error(`Request timeout after ${core_2.REQUEST_TIMEOUT_MS / 1000}s: ${relativeUrl}`);
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (err.name === 'AbortError') {
+            if (!timedOut()) {
+                throw err;
+            }
+            const timeoutError = new errors_1.AugustTimeoutError((0, sanitize_1.sanitizeString)(`Request timeout after ${effectiveTimeoutMs / 1000}s: ${relativeUrl}`), effectiveTimeoutMs);
             logger_1.Logger.log.error('fetchAugustWithBearer', timeoutError, { relativeUrl });
             throw timeoutError;
         }
-        throw error;
+        throw err;
     }
 }
 function isRetryableError(error) {
@@ -273,10 +379,11 @@ async function fetchTokenizedVaults(pool, headers, loadSubaccounts, loadSnapshot
         keyParts.push('no-snapshots');
     const key = keyParts.join('-');
     let tokenizedVaults;
-    if (exports.CACHE.get(key)) {
-        tokenizedVaults = exports.CACHE.get(key);
+    const cachedResponse = await (0, exports.getSafeCache)(key);
+    if (cachedResponse) {
+        tokenizedVaults = cachedResponse;
     }
-    else {
+    if (!tokenizedVaults) {
         let endpoint = core_2.WEBSERVER_ENDPOINTS.public.tokenizedVault.list;
         const params = new URLSearchParams();
         if (loadSubaccounts === false) {
@@ -294,7 +401,8 @@ async function fetchTokenizedVaults(pool, headers, loadSubaccounts, loadSnapshot
         });
         tokenizedVaults =
             (await tokenizedVaultsResponse.json());
-        exports.CACHE.set(key, tokenizedVaults);
+        const ttl = 1000 * 60 * 15;
+        exports.CACHE.set(key, tokenizedVaults, { ttl });
     }
     if (pool &&
         ((0, ethers_1.isAddress)(pool) ||

package/lib/core/helpers/web3.d.ts

@@ -1,4 +1,4 @@
-import { ethers, Interface, InterfaceAbi } from 'ethers';
+import { ethers, Interface, InterfaceAbi, JsonRpcProvider } from 'ethers';
 import type { Abi } from 'abitype';
 import type { TypedContract } from '../../types/typed-contract';
 import { IAddress, IChainId, IContractRunner, IExplorerType, IInfuraOptions } from '../../types';
@@ -11,8 +11,8 @@ export declare function createContract<const TAbi extends Abi>({ provider, addre
     provider: IContractRunner;
     abi: TAbi;
 }): TypedContract<TAbi> | undefined;
-export declare const createProvider: (rpcUrl: string) => any;
-export declare const getInfuraProvider: (infura: IInfuraOptions) => ethers.JsonRpcProvider;
+export declare const createProvider: (rpcUrl: string, chainId?: number) => JsonRpcProvider;
+export declare const getInfuraProvider: (infura: IInfuraOptions) => JsonRpcProvider;
 export declare const explorerLink: (hex: IAddress, chain: IChainId, type: IExplorerType) => string;
 export declare const getDecimals: (provider: IContractRunner, address: IAddress, isVault?: boolean) => Promise<any>;
 export declare const getReceiptTokenAddress: (provider: IContractRunner, address: IAddress) => Promise<any>;

package/lib/core/helpers/web3.js

@@ -80,13 +80,26 @@ function createContract({ provider, address, abi, }) {
     }
     return contract;
 }
-const createProvider = (rpcUrl) => {
-    if (__1.CACHE.has(rpcUrl))
-        return __1.CACHE.get(rpcUrl);
-    const provider = new ethers_1.JsonRpcProvider(rpcUrl, undefined, {
-        batchMaxCount: 10,
-    });
-    __1.CACHE.set(rpcUrl, provider);
+const createProvider = (rpcUrl, chainId) => {
+    if (typeof rpcUrl !== 'string' || rpcUrl.trim().length === 0) {
+        const forChain = chainId ? ` for chain ${chainId}` : '';
+        throw new Error(`createProvider: no RPC URL provided${forChain}. ` +
+            'Pass an RPC URL when constructing AugustSDK ' +
+            '(`new AugustSDK({ providers: { [chainId]: url } })`), ' +
+            `or set the AUGUST_RPC_${chainId ?? '<chainId>'} environment variable.`);
+    }
+    const cacheKey = chainId ? `${rpcUrl}|${chainId}` : rpcUrl;
+    if (__1.CACHE.has(cacheKey))
+        return __1.CACHE.get(cacheKey);
+    const provider = chainId
+        ? new ethers_1.JsonRpcProvider(rpcUrl, ethers_1.Network.from(chainId), {
+            staticNetwork: ethers_1.Network.from(chainId),
+            batchMaxCount: 10,
+        })
+        : new ethers_1.JsonRpcProvider(rpcUrl, undefined, {
+            batchMaxCount: 10,
+        });
+    __1.CACHE.set(cacheKey, provider);
     return provider;
 };
 exports.createProvider = createProvider;
@@ -114,7 +127,8 @@ const getInfuraProvider = (infura) => {
             break;
         }
     }
-    return new ethers_1.JsonRpcProvider(`${baseUrl}.infura.io/v3/${infura.apiKey}`);
+    const url = `${baseUrl}.infura.io/v3/${infura.apiKey}`;
+    return (0, exports.createProvider)(url, infura.chainId);
 };
 exports.getInfuraProvider = getInfuraProvider;
 const explorerLink = (hex, chain, type) => {
@@ -123,6 +137,24 @@ const explorerLink = (hex, chain, type) => {
     return `${__1.NETWORKS[chain].explorer}/${type}/${hex}`;
 };
 exports.explorerLink = explorerLink;
+function providerScope(provider) {
+    let chainId;
+    try {
+        const net = provider
+            ._network;
+        chainId = net?.chainId;
+    }
+    catch {
+        chainId = undefined;
+    }
+    if (chainId !== undefined && chainId !== null) {
+        return `chain:${String(chainId)}`;
+    }
+    const conn = provider._getConnection?.();
+    if (conn?.url)
+        return `url:${conn.url}`;
+    return 'unknown';
+}
 const getDecimals = async (provider, address, isVault = true) => {
     if (address === ethers_1.ZeroAddress) {
         __1.Logger.log.info('getDecimals', 'address is zero address');
@@ -132,7 +164,7 @@ const getDecimals = async (provider, address, isVault = true) => {
         return constants_1.fallbackDecimals;
     if (!(address && provider))
         return;
-    const key = `decimals-${address}`;
+    const key = `decimals-${providerScope(provider)}-${address}`;
     try {
         if (__1.CACHE.get(key))
             return __1.CACHE.get(key);
@@ -163,7 +195,7 @@ exports.getDecimals = getDecimals;
 const getReceiptTokenAddress = async (provider, address) => {
     if (!(address && provider))
         return;
-    const key = `receipt-token-${address}`;
+    const key = `receipt-token-${providerScope(provider)}-${address}`;
     try {
         if (__1.CACHE.get(key))
             return __1.CACHE.get(key);
@@ -184,7 +216,7 @@ const getSymbol = async (provider, address, isVault = true) => {
     }
     if (!(address && provider))
         return;
-    const key = `symbol-${address}`;
+    const key = `symbol-${providerScope(provider)}-${address}`;
     try {
         if (__1.CACHE.get(key))
             return __1.CACHE.get(key);

package/lib/core/index.d.ts

@@ -3,6 +3,8 @@ export * from './base.class';
 export * from './auth';
 export * from './logger';
 export * from './analytics';
+export * from './version-check';
+export * from './errors';
 export * from './constants/adapters';
 export * from './constants/core';
 export * from './constants/web3';

package/lib/core/index.js

@@ -19,6 +19,8 @@ __exportStar(require("./base.class"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./analytics"), exports);
+__exportStar(require("./version-check"), exports);
+__exportStar(require("./errors"), exports);
 __exportStar(require("./constants/adapters"), exports);
 __exportStar(require("./constants/core"), exports);
 __exportStar(require("./constants/web3"), exports);

package/lib/core/logger/index.d.ts

@@ -2,13 +2,23 @@ export type SDKLogger = {
     setTag: (key: string, value: string) => void;
     captureException: (err: unknown, context?: Record<string, any>) => void;
 };
+export interface ILogger {
+    debug?: (tag: string, context?: Record<string, unknown>) => void;
+    info?: (tag: string, context?: Record<string, unknown>) => void;
+    warn?: (tag: string, context?: Record<string, unknown>) => void;
+    error: (tag: string, error: unknown, context?: Record<string, unknown>) => void;
+}
 declare function setLogger(customLogger: SDKLogger): void;
+declare function setStructuredLogger(custom: ILogger | null): void;
 declare function getLogger(): SDKLogger | null;
+declare function getStructuredLogger(): ILogger | null;
 declare function setDevMode(devMode: boolean): void;
 declare function isDevMode(): boolean;
 declare const Logger: {
     setLogger: typeof setLogger;
+    setStructuredLogger: typeof setStructuredLogger;
     getLogger: typeof getLogger;
+    getStructuredLogger: typeof getStructuredLogger;
     setDevMode: typeof setDevMode;
     isDevMode: typeof isDevMode;
     log: {

package/lib/core/logger/index.js

@@ -34,14 +34,22 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = exports.Slack = void 0;
+const sanitize_1 = require("../analytics/sanitize");
 let logger = null;
+let structuredLogger = null;
 let isDev = false;
 function setLogger(customLogger) {
     logger = customLogger;
 }
+function setStructuredLogger(custom) {
+    structuredLogger = custom;
+}
 function getLogger() {
     return logger;
 }
+function getStructuredLogger() {
+    return structuredLogger;
+}
 function setDevMode(devMode) {
     isDev = devMode;
 }
@@ -50,26 +58,51 @@ function isDevMode() {
 }
 const log = {
     info: (tag, ...args) => {
+        const safeArgs = args.map((a) => (0, sanitize_1.sanitizeForLogging)(a));
         if (isDev) {
-            console.log(`[${tag}]`, ...args);
+            console.log(`[${tag}]`, ...safeArgs);
         }
+        structuredLogger?.info?.(tag, structuredContext(safeArgs));
     },
     warn: (tag, ...args) => {
+        const safeArgs = args.map((a) => (0, sanitize_1.sanitizeForLogging)(a));
         if (isDev) {
-            console.warn(`[${tag}]`, ...args);
+            console.warn(`[${tag}]`, ...safeArgs);
         }
         logger?.setTag('warning', tag);
+        structuredLogger?.warn?.(tag, structuredContext(safeArgs));
     },
     error: (tag, error, context) => {
+        const safeError = (0, sanitize_1.sanitizeError)(error);
+        const safeContext = context
+            ? (0, sanitize_1.sanitizeForLogging)(context)
+            : undefined;
         if (isDev) {
-            console.error(`[${tag}]`, error);
+            console.error(`[${tag}]`, safeError);
         }
-        logger?.captureException(error, { tag, ...context });
+        logger?.captureException(safeError, { tag, ...(safeContext ?? {}) });
+        structuredLogger?.error(tag, safeError, safeContext);
     },
 };
+function structuredContext(args) {
+    if (args.length === 0)
+        return undefined;
+    const [first, ...rest] = args;
+    if (first &&
+        typeof first === 'object' &&
+        !Array.isArray(first) &&
+        !(first instanceof Error)) {
+        return rest.length === 0
+            ? first
+            : { ...first, extras: rest };
+    }
+    return { args };
+}
 const Logger = {
     setLogger,
+    setStructuredLogger,
     getLogger,
+    getStructuredLogger,
     setDevMode,
     isDevMode,
     log,

package/lib/core/logger/slack.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SLACK = exports.DEFAULT_SLACK_WEBHOOK_URL = void 0;
 const core_1 = require("../helpers/core");
 const web3_1 = require("../helpers/web3");
+const sanitize_1 = require("../analytics/sanitize");
 exports.DEFAULT_SLACK_WEBHOOK_URL = 'T04CM84GAV6/B0A2DS3ST8C/FLtOA3Jna3FN7UO4DoGxHfhG';
 function error(options) {
     const { title, error, poolAddress, chainId, slackWebookUrl, address } = options;
@@ -31,18 +32,21 @@ function error(options) {
     }
     (async () => {
         const webhookUrl = `https://hooks.slack.com/services/${slackWebookUrl}`;
+        const safeError = (0, sanitize_1.sanitizeString)(String(error));
+        const safeTitle = (0, sanitize_1.sanitizeString)(String(title));
         const data = {
-            text: `*Error: ${title}*\n${new Date().toUTCString()}\n\nPool: [${(0, core_1.truncate)(poolAddress)}](${(0, web3_1.explorerLink)(poolAddress, chainId, 'address')})\n\n\nError: ${error}`,
+            text: `*Error: ${safeTitle}*\n${new Date().toUTCString()}\n\nPool: [${(0, core_1.truncate)(poolAddress)}](${(0, web3_1.explorerLink)(poolAddress, chainId, 'address')})\n\n\nError: ${safeError}`,
         };
         const res = await fetch(webhookUrl, {
             method: 'POST',
             body: JSON.stringify(data),
+            signal: AbortSignal.timeout(5000),
         });
         if (res?.status === 200)
             console.log('#Slack.error: successfully sent');
         else
             console.error('#Slack.error:', res.status, res.statusText);
-    })().catch((e) => console.error('#Slack.error:', e));
+    })().catch((e) => console.error('#Slack.error:', (0, sanitize_1.sanitizeString)(String(e?.message ?? e))));
 }
 exports.SLACK = {
     error,

package/lib/core/version-check.d.ts

@@ -0,0 +1,6 @@
+export declare function compareSemver(a: string, b: string): number;
+export interface IVersionCheckConfig {
+    enabled?: boolean;
+}
+export declare function runVersionCheck(config?: IVersionCheckConfig): void;
+export declare function _resetVersionCheckForTests(): void;