@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/utils/AsyncRateLimiter.d.ts

@@ -0,0 +1,23 @@
+export interface RateLimiterOptions {
+    maxConcurrent: number;
+    minDelayMs?: number;
+}
+type Task<T> = () => Promise<T>;
+export default class AsyncRateLimiter {
+    private maxConcurrent;
+    private minDelayMs;
+    private activeCount;
+    private queue;
+    private lastStartTime;
+    constructor(options: RateLimiterOptions);
+    execute<T>(task: Task<T>): Promise<T>;
+    private runNext;
+    private waitForDelay;
+    stats(): {
+        active: number;
+        queued: number;
+    };
+}
+export declare function withRetry<T>(task: () => Promise<T>, retries?: number, delayMs?: number): Promise<T>;
+export {};
+//# sourceMappingURL=AsyncRateLimiter.d.ts.map

package/build/utils/AsyncRateLimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncRateLimiter.d.ts","sourceRoot":"","sources":["../../src/utils/AsyncRateLimiter.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,KAAK,IAAI,CAAC,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhC,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACjC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,aAAa,CAAK;gBAEd,OAAO,EAAE,kBAAkB;IAKjC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAwB3C,OAAO,CAAC,OAAO;YASD,YAAY;IAS1B,KAAK;;;;CAMR;AAED,wBAAsB,SAAS,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,SAAI,EACX,OAAO,SAAM,GACd,OAAO,CAAC,CAAC,CAAC,CAgBZ"}

package/build/utils/AsyncRateLimiter.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = withRetry;
+class AsyncRateLimiter {
+    constructor(options) {
+        var _a;
+        this.activeCount = 0;
+        this.queue = [];
+        this.lastStartTime = 0;
+        this.maxConcurrent = options.maxConcurrent;
+        this.minDelayMs = (_a = options.minDelayMs) !== null && _a !== void 0 ? _a : 0;
+    }
+    execute(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const wrapped = () => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield this.waitForDelay();
+                        this.activeCount++;
+                        this.lastStartTime = Date.now();
+                        const result = yield task();
+                        resolve(result);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                    finally {
+                        this.activeCount--;
+                        this.runNext();
+                    }
+                });
+                this.queue.push(wrapped);
+                this.runNext();
+            });
+        });
+    }
+    runNext() {
+        while (this.activeCount < this.maxConcurrent &&
+            this.queue.length > 0) {
+            const task = this.queue.shift();
+            task();
+        }
+    }
+    waitForDelay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const elapsed = Date.now() - this.lastStartTime;
+            const wait = Math.max(0, this.minDelayMs - elapsed);
+            if (wait > 0) {
+                yield new Promise(r => setTimeout(r, wait));
+            }
+        });
+    }
+    stats() {
+        return {
+            active: this.activeCount,
+            queued: this.queue.length
+        };
+    }
+}
+exports.default = AsyncRateLimiter;
+function withRetry(task_1) {
+    return __awaiter(this, arguments, void 0, function* (task, retries = 3, delayMs = 500) {
+        let lastError;
+        for (let i = 0; i < retries; i++) {
+            try {
+                if (i > 0)
+                    console.log(`Retrying ${i}...`);
+                return yield task();
+            }
+            catch (err) {
+                console.error(`Error retying: `, err);
+                lastError = err;
+                yield new Promise(r => setTimeout(r, delayMs));
+            }
+        }
+        throw lastError;
+    });
+}

package/build/utils/AsyncTTLCache.d.ts

@@ -0,0 +1,12 @@
+declare class AsyncTTLCache {
+    static instance: AsyncTTLCache;
+    private inflight;
+    stale_time_ms: number;
+    private cache;
+    private constructor();
+    static getInstance(): AsyncTTLCache;
+    private resolve_inflight;
+    get_value<K, V>(key: string, data: K, fetch_task: (data: K) => Promise<V>): Promise<any>;
+}
+export default AsyncTTLCache;
+//# sourceMappingURL=AsyncTTLCache.d.ts.map

package/build/utils/AsyncTTLCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncTTLCache.d.ts","sourceRoot":"","sources":["../../src/utils/AsyncTTLCache.ts"],"names":[],"mappings":"AAOA,cAAM,aAAa;IACf,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAwC;IAEjD,aAAa,EAAE,MAAM,CAAC;IAE7B,OAAO,CAAC,KAAK,CAAmB;IAEhC,OAAO;IAKP,MAAM,CAAC,WAAW;YAYJ,gBAAgB;IAUjB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;CAiCzF;AAED,eAAe,aAAa,CAAC"}

package/build/utils/AsyncTTLCache.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+class AsyncTTLCache {
+    constructor(stale_time_in_ms = 60000) {
+        this.inflight = new Map(); // Track requests in process of fetching price
+        this.stale_time_ms = stale_time_in_ms + Math.random() * 5000;
+        this.cache = new Map();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new AsyncTTLCache();
+        }
+        return this.instance;
+    }
+    // Handle error from external price provider (fetch task)
+    // Returns stale price on error 
+    // Throws error if no stale price in memory and provider threw an exception
+    resolve_inflight(key, existing_price) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolved = yield this.inflight.get(key);
+            if (resolved === undefined || resolved === null) {
+                if (!existing_price)
+                    throw new Error(`AsyncTTLCache: Error fetching fresh price from DB for key: ${key}`);
+                return existing_price.value;
+            }
+            return resolved;
+        });
+    }
+    get_value(key, data, fetch_task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let existing_entry = this.cache.get(key);
+            let now = new Date().getTime();
+            // Return cached value
+            if (existing_entry && now - existing_entry.last_update <= this.stale_time_ms) {
+                console.log(`AsyncTTLCache: Hitting cache... Value:`, existing_entry.value);
+                return existing_entry.value;
+            }
+            if (!existing_entry || now - existing_entry.last_update > this.stale_time_ms) {
+                if (this.inflight.has(key)) {
+                    return yield this.resolve_inflight(key, existing_entry);
+                }
+                const promise = fetch_task(data);
+                this.inflight.set(key, promise);
+                try {
+                    const updated = yield promise;
+                    this.inflight.delete(key);
+                    this.cache.set(key, { key, value: updated, last_update: now });
+                    return updated;
+                }
+                finally {
+                    this.inflight.delete(key);
+                }
+            }
+            console.log(`AsyncTTLCache: Hitting cache... Value:`, existing_entry.value);
+            return existing_entry.value;
+        });
+    }
+}
+exports.default = AsyncTTLCache;

package/build/utils/Logger.d.ts

@@ -0,0 +1,67 @@
+import ElasticSearch from '../services/ElasticSearch';
+export interface LogContext {
+    [key: string]: any;
+}
+declare class Logger {
+    private static instance;
+    private static elastic;
+    private pino;
+    private source;
+    private constructor();
+    /**
+     * Get or create the singleton root logger instance
+     */
+    static getInstance(source?: string, serviceName?: string): Logger;
+    /**
+     * Set the ElasticSearch instance for critical log indexing
+     */
+    static setElastic(elastic: ElasticSearch): void;
+    /**
+     * Create a child logger with a specific source/module name
+     * This is the recommended way to get a logger for a specific class or module
+     */
+    child(source: string, serviceName: string, context?: LogContext): Logger;
+    /**
+     * Debug level - development only, not sent to ElasticSearch
+     */
+    debug(message: string, data?: LogContext): void;
+    /**
+     * Info level - general operational logs
+     */
+    info(message: string, data?: LogContext): void;
+    /**
+     * Warn level - sent to ElasticSearch
+     */
+    warn(message: string, data?: LogContext): void;
+    /**
+     * Error level - sent to ElasticSearch
+     */
+    error(message: string, data?: LogContext): void;
+    /**
+     * Fatal level - sent to ElasticSearch
+     */
+    fatal(message: string, data?: LogContext): void;
+    /**
+     * Normalize data for logging - handle Error objects
+     */
+    private normalizeData;
+    /**
+     * Index critical logs to ElasticSearch (warn, error, fatal)
+     */
+    private indexToElastic;
+}
+/**
+ * Create a module-specific logger
+ *
+ * Usage:
+ * ```typescript
+ * import { createLogger } from '../utils/Logger';
+ * const logger = createLogger('MyClassName');
+ *
+ * logger.info('Processing started', { count: 10 });
+ * logger.error('Failed to process', { error });
+ * ```
+ */
+export declare const createLogger: (source: string, serviceName: string, context?: LogContext) => Logger;
+export default Logger;
+//# sourceMappingURL=Logger.d.ts.map

package/build/utils/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../src/utils/Logger.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,2BAA2B,CAAC;AAItD,MAAM,WAAW,UAAU;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AASD,cAAM,MAAM;IACR,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAuB;IAC9C,OAAO,CAAC,MAAM,CAAC,OAAO,CAA8B;IACpD,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO;IAkCP;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,MAAM,GAAE,MAAc,EAAE,WAAW,GAAE,MAAsB,GAAG,MAAM;IAOvF;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAI/C;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM;IAcxE;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI;IAI/C;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI;IAI9C;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI;IAK9C;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI;IAO/C;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI;IAM/C;;OAEG;IACH,OAAO,CAAC,aAAa;IA8BrB;;OAEG;IACH,OAAO,CAAC,cAAc;CAezB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,MAAM,EAAE,aAAa,MAAM,EAAE,UAAU,UAAU,KAAG,MAExF,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/build/utils/Logger.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+class Logger {
+    constructor(options) {
+        this.source = options.source;
+        if (options.parentLogger) {
+            // Child logger - inherit from parent
+            this.pino = options.parentLogger.child({ source: this.source });
+        }
+        else {
+            // Root logger - create new pino instance
+            const isDev = process.env.NODE_ENV !== 'production';
+            this.pino = (0, pino_1.default)({
+                level: process.env.LOG_LEVEL || 'info',
+                transport: isDev
+                    ? {
+                        target: 'pino-pretty',
+                        options: {
+                            colorize: true,
+                            translateTime: 'SYS:standard',
+                            ignore: 'pid,hostname',
+                        },
+                    }
+                    : undefined,
+                base: {
+                    service: options.serviceName,
+                    env: process.env.NODE_ENV || 'development',
+                },
+                formatters: {
+                    level: (label) => ({ level: label }),
+                },
+                timestamp: pino_1.default.stdTimeFunctions.isoTime,
+            });
+        }
+    }
+    /**
+     * Get or create the singleton root logger instance
+     */
+    static getInstance(source = 'app', serviceName = 'app-service') {
+        if (!Logger.instance) {
+            Logger.instance = new Logger({ source, serviceName });
+        }
+        return Logger.instance;
+    }
+    /**
+     * Set the ElasticSearch instance for critical log indexing
+     */
+    static setElastic(elastic) {
+        Logger.elastic = elastic;
+    }
+    /**
+     * Create a child logger with a specific source/module name
+     * This is the recommended way to get a logger for a specific class or module
+     */
+    child(source, serviceName, context) {
+        const childLogger = new Logger({
+            source,
+            serviceName,
+            parentLogger: this.pino,
+        });
+        if (context) {
+            childLogger.pino = childLogger.pino.child(context);
+        }
+        return childLogger;
+    }
+    /**
+     * Debug level - development only, not sent to ElasticSearch
+     */
+    debug(message, data) {
+        this.pino.debug(Object.assign({ source: this.source }, data), message);
+    }
+    /**
+     * Info level - general operational logs
+     */
+    info(message, data) {
+        this.pino.info(Object.assign({ source: this.source }, data), message);
+    }
+    /**
+     * Warn level - sent to ElasticSearch
+     */
+    warn(message, data) {
+        this.pino.warn(Object.assign({ source: this.source }, data), message);
+        this.indexToElastic('Warning', message, data);
+    }
+    /**
+     * Error level - sent to ElasticSearch
+     */
+    error(message, data) {
+        // Handle Error objects specially
+        const logData = this.normalizeData(data);
+        this.pino.error(Object.assign({ source: this.source }, logData), message);
+        this.indexToElastic('Error', message, logData);
+    }
+    /**
+     * Fatal level - sent to ElasticSearch
+     */
+    fatal(message, data) {
+        const logData = this.normalizeData(data);
+        this.pino.fatal(Object.assign({ source: this.source }, logData), message);
+        this.indexToElastic('Error', message, logData);
+    }
+    /**
+     * Normalize data for logging - handle Error objects
+     */
+    normalizeData(data) {
+        if (!data)
+            return undefined;
+        // 🔥 If someone passed an Error directly
+        if (data instanceof Error) {
+            return {
+                error: {
+                    name: data.name,
+                    message: data.message,
+                    stack: data.stack,
+                },
+            };
+        }
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value instanceof Error) {
+                normalized[key] = {
+                    name: value.name,
+                    message: value.message,
+                    stack: value.stack,
+                };
+            }
+            else {
+                normalized[key] = value;
+            }
+        }
+        return normalized;
+    }
+    /**
+     * Index critical logs to ElasticSearch (warn, error, fatal)
+     */
+    indexToElastic(level, message, data) {
+        if (!Logger.elastic)
+            return;
+        // Fire and forget - don't await to avoid blocking
+        Logger.elastic
+            .index_log(this.source, 'log', level, message, data)
+            .catch((err) => {
+            // Log to console if ElasticSearch indexing fails
+            this.pino.error({ err, source: this.source }, 'Failed to index log to ElasticSearch');
+        });
+    }
+}
+Logger.instance = null;
+Logger.elastic = null;
+/**
+ * Create a module-specific logger
+ *
+ * Usage:
+ * ```typescript
+ * import { createLogger } from '../utils/Logger';
+ * const logger = createLogger('MyClassName');
+ *
+ * logger.info('Processing started', { count: 10 });
+ * logger.error('Failed to process', { error });
+ * ```
+ */
+const createLogger = (source, serviceName, context) => {
+    return Logger.getInstance().child(source, serviceName, context);
+};
+exports.createLogger = createLogger;
+exports.default = Logger;

package/build/utils/MemoryMonitor.d.ts

@@ -0,0 +1,12 @@
+declare class MemoryMonitor {
+    private timer;
+    private timeout;
+    private usage;
+    private MAX_MEMORY_USAGE;
+    constructor(maxMemoryUsage: number);
+    monitorMemory(): void;
+    stopMonitoring(): void;
+    checkMemory(): void;
+}
+export default MemoryMonitor;
+//# sourceMappingURL=MemoryMonitor.d.ts.map

package/build/utils/MemoryMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryMonitor.d.ts","sourceRoot":"","sources":["../../src/utils/MemoryMonitor.ts"],"names":[],"mappings":"AAOA,cAAM,aAAa;IACf,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,gBAAgB,CAAS;gBAErB,cAAc,EAAE,MAAM;IASlC,aAAa;IAWb,cAAc;IAMd,WAAW;CAqCd;AAED,eAAe,aAAa,CAAC"}

package/build/utils/MemoryMonitor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MemoryMonitor {
+    constructor(maxMemoryUsage) {
+        this.usage = [];
+        this.timer = null;
+        this.timeout = 10 * 60 * 1000; // every minute
+        this.MAX_MEMORY_USAGE = maxMemoryUsage;
+        this.monitorMemory();
+    }
+    // Start polling memory usage
+    monitorMemory() {
+        // Initial check
+        this.checkMemory();
+        // Start polling memory usage
+        this.timer = setInterval(() => {
+            this.checkMemory();
+        }, this.timeout);
+    }
+    // Stop polling memory usage
+    stopMonitoring() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+    }
+    checkMemory() {
+        const used = process.memoryUsage();
+        const currentUsage = {
+            rss: Math.round(used.rss / 1024 / 1024),
+            heapTotal: Math.round(used.heapTotal / 1024 / 1024),
+            heapUsed: Math.round(used.heapUsed / 1024 / 1024),
+            external: Math.round(used.external / 1024 / 1024),
+            timestamp: new Date().toISOString(),
+            heapUsagePercentage: Math.round((used.heapUsed / used.heapTotal) * 100)
+        };
+        // Keep last 10 measurements for trend
+        if (this.usage.length > 10) {
+            this.usage.shift();
+        }
+        this.usage.push(currentUsage);
+        // Calculate min/max over last 10 measurements
+        if (this.usage.length === 10) {
+            const stats = Object.assign(Object.assign({}, currentUsage), { heapUsed: {
+                    current: currentUsage.heapUsed,
+                    min: Math.min(...this.usage.map(u => u.heapUsed)),
+                    max: Math.max(...this.usage.map(u => u.heapUsed))
+                }, heapTotal: {
+                    current: currentUsage.heapTotal,
+                    min: Math.min(...this.usage.map(u => u.heapTotal)),
+                    max: Math.max(...this.usage.map(u => u.heapTotal))
+                } });
+            console.log(stats);
+        }
+        else {
+            console.log(currentUsage);
+        }
+    }
+}
+exports.default = MemoryMonitor;

package/build/utils/Parsing.d.ts

@@ -0,0 +1,13 @@
+import { EventObject } from "../interfaces";
+export declare const sanitizeBigInt: (obj: any) => any;
+export declare const hex_to_decimal_string: (hex: string) => string;
+export declare function hexToString(hex: string): string;
+export declare const parseLogToEvent: (log: any) => EventObject;
+export declare const parseRedisUrl: (url: string) => {
+    host: string;
+    port: number;
+    password: any;
+    ssl: boolean;
+    abortConnect: boolean;
+};
+//# sourceMappingURL=Parsing.d.ts.map

package/build/utils/Parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parsing.d.ts","sourceRoot":"","sources":["../../src/utils/Parsing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,eAAO,MAAM,cAAc,GAAI,KAAK,GAAG,KAAG,GA0BzC,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,KAAG,MAInD,CAAA;AAGD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,UAWtC;AAGD,eAAO,MAAM,eAAe,GAAI,KAAK,GAAG,gBAYvC,CAAA;AAGD,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM;;;;;;CA4BxC,CAAA"}

package/build/utils/Parsing.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRedisUrl = exports.parseLogToEvent = exports.hex_to_decimal_string = exports.sanitizeBigInt = void 0;
+exports.hexToString = hexToString;
+const sanitizeBigInt = (obj) => {
+    if (obj === null || obj === undefined)
+        return obj;
+    // Handle BigInt
+    if (typeof obj === "bigint") {
+        return obj.toString();
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return obj.map(val => (0, exports.sanitizeBigInt)(val));
+    }
+    // Handle objects
+    if (typeof obj === "object") {
+        const newObj = {};
+        for (const key in obj) {
+            if (Object.hasOwnProperty.call(obj, key)) {
+                newObj[key] = (0, exports.sanitizeBigInt)(obj[key]);
+            }
+        }
+        return newObj;
+    }
+    // Return all other types as they are
+    return obj;
+};
+exports.sanitizeBigInt = sanitizeBigInt;
+const hex_to_decimal_string = (hex) => {
+    if (!hex)
+        return "0";
+    if (!hex.startsWith("0x"))
+        hex = "0x" + hex;
+    return BigInt(hex).toString(10);
+};
+exports.hex_to_decimal_string = hex_to_decimal_string;
+function hexToString(hex) {
+    // Ensure the hex string has the correct prefix
+    if (!hex.startsWith('0x')) {
+        hex = '0x' + hex;
+    }
+    // Remove the hex prefix and convert to a buffer
+    const buffer = Buffer.from(hex.slice(2), 'hex');
+    // Convert the buffer to a string
+    return buffer.toString('utf8');
+}
+// Filter out the numerical keys from log object
+const parseLogToEvent = (log) => {
+    let eventElements = {};
+    for (const key in log) {
+        // Check if the key is a string (ignore the numeric keys)
+        if (isNaN(Number(key))) {
+            eventElements[key] = log[key];
+        }
+    }
+    return eventElements;
+};
+exports.parseLogToEvent = parseLogToEvent;
+const parseRedisUrl = (url) => {
+    // Remove 'redis://' prefix
+    const cleanUrl = url.replace('redis://', '');
+    // Split by comma to get key-value pairs
+    const pairs = cleanUrl.split(',');
+    const config = {};
+    pairs.forEach(pair => {
+        if (pair.includes('=')) {
+            const [key, ...valueParts] = pair.split('=');
+            const value = valueParts.join('=');
+            config[key.trim()] = value.trim();
+        }
+    });
+    // Extract host and port from first part
+    const [hostPort] = pairs[0].split(',');
+    const [host, port] = hostPort.split(':');
+    return {
+        host: host,
+        port: parseInt(port),
+        password: config.password,
+        ssl: config.ssl === 'True',
+        abortConnect: config.abortConnect === 'False'
+    };
+};
+exports.parseRedisUrl = parseRedisUrl;

package/build/utils/RpcLimiter.d.ts

@@ -0,0 +1,10 @@
+import { ChainId } from "../interfaces";
+import AsyncRateLimiter, { RateLimiterOptions } from "./AsyncRateLimiter";
+export declare class RpcLimiter {
+    static instance: RpcLimiter;
+    private limiters;
+    private constructor();
+    static getInstance(): RpcLimiter;
+    get(chain_id: ChainId, opts: RateLimiterOptions): AsyncRateLimiter;
+}
+//# sourceMappingURL=RpcLimiter.d.ts.map

package/build/utils/RpcLimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcLimiter.d.ts","sourceRoot":"","sources":["../../src/utils/RpcLimiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,gBAAgB,EAAE,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE1E,qBAAa,UAAU;IACnB,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC;IAE5B,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO;IAIP,MAAM,CAAC,WAAW;IAQlB,GAAG,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,kBAAkB;CAWlD"}

package/build/utils/RpcLimiter.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcLimiter = void 0;
+const AsyncRateLimiter_1 = __importDefault(require("./AsyncRateLimiter"));
+class RpcLimiter {
+    constructor() {
+        this.limiters = new Map();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new RpcLimiter();
+        }
+        return this.instance;
+    }
+    get(chain_id, opts) {
+        const existing = this.limiters.get(chain_id);
+        if (!existing) {
+            const limiter = new AsyncRateLimiter_1.default(opts);
+            this.limiters.set(chain_id, limiter);
+            return limiter;
+        }
+        return existing;
+    }
+}
+exports.RpcLimiter = RpcLimiter;