opnet 1.7.21 → 1.7.23

package/src/threading/SharedThreader.ts

@@ -0,0 +1,259 @@
+import { Logger } from '@btc-vision/logger';
+import {
+    PendingTask,
+    QueuedTask,
+    ResultMessage,
+    ThreaderOptions,
+    UniversalWorker,
+    WorkerScript,
+} from './interfaces/IThread.js';
+
+import { createWorker, isNode } from './WorkerCreator.js';
+
+export abstract class BaseThreader<TOp extends string, TData, TResult> extends Logger {
+    public readonly logColor: string = '#FF5733';
+
+    protected abstract readonly workerScript: WorkerScript;
+
+    private workers: UniversalWorker<TOp, TData, TResult>[] = [];
+    private available: UniversalWorker<TOp, TData, TResult>[] = [];
+    private pending = new Map<number, PendingTask<TResult>>();
+    private queue: QueuedTask<TOp, TData, TResult>[] = [];
+    private idCounter = 0;
+    private readonly poolSize: number;
+    private initialized = false;
+    private initializing: Promise<void> | null = null;
+
+    private tasksProcessed = 0;
+    private tasksFailed = 0;
+    private lastStatsLog = 0;
+    private readonly statsInterval = 30_000;
+
+    private cleanupBound = false;
+
+    protected constructor(options: ThreaderOptions = {}) {
+        super();
+
+        this.poolSize =
+            options.poolSize ??
+            (isNode
+                ? 6
+                : Math.max(Math.max(1, Math.ceil((navigator?.hardwareConcurrency ?? 8) / 2)), 6));
+    }
+
+    public get stats(): {
+        pending: number;
+        queued: number;
+        available: number;
+        total: number;
+        processed: number;
+        failed: number;
+    } {
+        return {
+            pending: this.pending.size,
+            queued: this.queue.length,
+            available: this.available.length,
+            total: this.workers.length,
+            processed: this.tasksProcessed,
+            failed: this.tasksFailed,
+        };
+    }
+
+    public async terminate(): Promise<void> {
+        if (!this.initialized && !this.initializing) return;
+
+        const queuedCount = this.queue.length;
+        const pendingCount = this.pending.size;
+
+        for (const task of this.queue) {
+            task.reject(new Error('Threader terminated'));
+        }
+
+        for (const [, handler] of this.pending) {
+            handler.reject(new Error('Threader terminated'));
+        }
+
+        for (const worker of this.workers) {
+            await worker.terminate();
+        }
+
+        this.queue = [];
+        this.pending.clear();
+        this.workers = [];
+        this.available = [];
+        this.initialized = false;
+        this.initializing = null;
+
+        if (queuedCount > 0 || pendingCount > 0) {
+            this.info(
+                `Terminated. Rejected ${queuedCount} queued and ${pendingCount} pending tasks. Total processed: ${this.tasksProcessed}, failed: ${this.tasksFailed}`,
+            );
+        }
+    }
+
+    public async drain(): Promise<void> {
+        if (!this.initialized) return;
+
+        const queuedCount = this.queue.length;
+        const pendingCount = this.pending.size;
+
+        this.info(
+            `Draining. Rejecting ${queuedCount} queued, waiting for ${pendingCount} pending...`,
+        );
+
+        for (const task of this.queue) {
+            task.reject(new Error('Threader draining'));
+        }
+        this.queue = [];
+
+        if (this.pending.size > 0) {
+            await new Promise<void>((resolve) => {
+                const checkDone = () => {
+                    if (this.pending.size === 0) {
+                        resolve();
+                    }
+                };
+
+                const originalPending = new Map(this.pending);
+                for (const [id, handler] of originalPending) {
+                    const origResolve = handler.resolve;
+                    const origReject = handler.reject;
+
+                    handler.resolve = (v) => {
+                        origResolve(v);
+                        checkDone();
+                    };
+
+                    handler.reject = (e) => {
+                        origReject(e);
+                        checkDone();
+                    };
+
+                    this.pending.set(id, handler);
+                }
+
+                checkDone();
+            });
+        }
+
+        await this.terminate();
+    }
+
+    protected runWithTransfer(
+        op: TOp,
+        data: TData,
+        transferables: ArrayBuffer[],
+    ): Promise<TResult> {
+        return new Promise(async (resolve, reject) => {
+            await this.init();
+
+            this.queue.push({ resolve, reject, op, data, transferables });
+            this.processQueue();
+        });
+    }
+
+    protected run(op: TOp, data: TData): Promise<TResult> {
+        return new Promise(async (resolve, reject) => {
+            await this.init();
+
+            this.queue.push({ resolve, reject, op, data });
+            this.processQueue();
+        });
+    }
+
+    private bindCleanupHandlers(): void {
+        if (this.cleanupBound) return;
+        this.cleanupBound = true;
+
+        const cleanup = () => {
+            this.terminate().catch(() => {});
+        };
+
+        if (isNode) {
+            process.once('beforeExit', cleanup);
+            process.once('SIGINT', cleanup);
+            process.once('SIGTERM', cleanup);
+        } else if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', cleanup);
+            window.addEventListener('unload', cleanup);
+        } else if (typeof self !== 'undefined') {
+            self.addEventListener('beforeunload', cleanup);
+        }
+    }
+
+    private async init(): Promise<void> {
+        if (this.initialized) return;
+        if (this.initializing) return this.initializing;
+
+        this.bindCleanupHandlers();
+
+        this.initializing = (async () => {
+            const startTime = Date.now();
+
+            const workers = await Promise.all(
+                Array.from({ length: this.poolSize }, () =>
+                    createWorker<TOp, TData, TResult>(this.workerScript),
+                ),
+            );
+
+            for (const worker of workers) {
+                worker.onMessage((msg: ResultMessage<TResult>) => {
+                    const handler = this.pending.get(msg.id);
+                    if (handler) {
+                        this.pending.delete(msg.id);
+
+                        if (msg.error) {
+                            this.tasksFailed++;
+                            handler.reject(new Error(msg.error));
+                        } else {
+                            this.tasksProcessed++;
+
+                            handler.resolve(msg.result as TResult);
+                        }
+                    }
+
+                    this.available.push(worker);
+                    this.logStatsIfNeeded();
+                    this.processQueue();
+                });
+
+                this.workers.push(worker);
+                this.available.push(worker);
+            }
+
+            this.initialized = true;
+        })();
+
+        return this.initializing;
+    }
+
+    private logStatsIfNeeded(): void {
+        const now = Date.now();
+        if (now - this.lastStatsLog < this.statsInterval) return;
+
+        this.lastStatsLog = now;
+        const s = this.stats;
+        this.debug(
+            `Stats: ${s.processed} processed, ${s.failed} failed, ${s.pending} pending, ${s.queued} queued, ${s.available}/${s.total} workers available`,
+        );
+    }
+
+    private processQueue(): void {
+        if (this.queue.length > 100 && this.available.length === 0) {
+            this.warn(`Queue backing up: ${this.queue.length} tasks waiting, no workers available`);
+        }
+
+        while (this.queue.length > 0 && this.available.length > 0) {
+            const task = this.queue.shift();
+            if (!task) break;
+
+            const worker = this.available.pop();
+            if (!worker) break;
+
+            const id = this.idCounter++;
+            this.pending.set(id, task);
+
+            worker.postMessage({ id, op: task.op, data: task.data }, task.transferables);
+        }
+    }
+}

package/src/threading/WorkerCreator.ts

@@ -0,0 +1,67 @@
+import { ResultMessage, TaskMessage, UniversalWorker, WorkerScript } from './interfaces/IThread.js';
+
+export const isNode =
+    typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+export async function createWorker<TOp extends string, TData, TResult>(
+    workerScript: WorkerScript,
+): Promise<UniversalWorker<TOp, TData, TResult>> {
+    if (isNode) {
+        const { Worker } = await import('worker_threads');
+        const worker = new Worker(workerScript, { eval: true });
+
+        worker.on('error', (err) => {
+            console.error('[WorkerCreator] Worker error:', err);
+        });
+
+        let messageCallback: ((msg: ResultMessage<TResult>) => void) | null = null;
+
+        worker.on('message', (msg: ResultMessage<TResult>) => {
+            if (messageCallback) messageCallback(msg);
+        });
+
+        // unref AFTER all listeners are set up
+        worker.unref();
+
+        return {
+            postMessage: (msg: TaskMessage<TOp, TData>, transferables?: ArrayBuffer[]) => {
+                if (transferables && transferables.length > 0) {
+                    worker.postMessage(msg, transferables);
+                } else {
+                    worker.postMessage(msg);
+                }
+            },
+            onMessage: (callback: (msg: ResultMessage<TResult>) => void) => {
+                messageCallback = callback;
+            },
+            terminate: async () => {
+                await worker.terminate();
+            },
+        };
+    } else {
+        const blob = new Blob([workerScript], { type: 'application/javascript' });
+        const url = URL.createObjectURL(blob);
+        const worker = new Worker(url);
+
+        worker.onerror = (err) => {
+            console.error('[WorkerCreator] Worker error:', err);
+        };
+
+        return {
+            postMessage: (msg: TaskMessage<TOp, TData>, transferables?: ArrayBuffer[]) => {
+                if (transferables && transferables.length > 0) {
+                    worker.postMessage(msg, transferables);
+                } else {
+                    worker.postMessage(msg);
+                }
+            },
+            onMessage: (callback: (msg: ResultMessage<TResult>) => void) => {
+                worker.onmessage = (e: MessageEvent<ResultMessage<TResult>>) => callback(e.data);
+            },
+            terminate: () => {
+                worker.terminate();
+                URL.revokeObjectURL(url);
+            },
+        };
+    }
+}

package/src/threading/interfaces/IThread.ts

@@ -0,0 +1,38 @@
+export interface TaskMessage<TOp extends string = string, TData = unknown> {
+    id: number;
+    op: TOp;
+    data: TData;
+}
+
+export interface ResultMessage<TResult = unknown> {
+    id: number;
+    result?: TResult;
+    error?: string;
+}
+
+export interface PendingTask<TResult = unknown> {
+    resolve: (value: TResult) => void;
+    reject: (error: Error) => void;
+}
+
+export interface QueuedTask<
+    TOp extends string = string,
+    TData = unknown,
+    TResult = unknown,
+> extends PendingTask<TResult> {
+    op: TOp;
+    data: TData;
+    transferables?: ArrayBuffer[];
+}
+
+export interface ThreaderOptions {
+    poolSize?: number;
+}
+
+export interface UniversalWorker<TOp extends string = string, TData = unknown, TResult = unknown> {
+    postMessage(msg: TaskMessage<TOp, TData>, transferables?: readonly Transferable[]): void;
+    onMessage(callback: (msg: ResultMessage<TResult>) => void): void;
+    terminate(): void | Promise<void>;
+}
+
+export type WorkerScript = string;

package/src/threading/worker-scripts/JSONWorker.ts

@@ -0,0 +1,78 @@
+import { WorkerScript } from '../interfaces/IThread.js';
+
+export const jsonWorkerScript: WorkerScript = `
+    (async () => {
+        let parentPort = null;
+        let isBrowser = typeof self !== 'undefined' && typeof self.onmessage !== 'undefined';
+        
+        if (!isBrowser) {
+            const wt = await import('node:worker_threads');
+            parentPort = wt.parentPort;
+        }
+        
+        const send = (msg) => {
+            if (isBrowser) {
+                postMessage(msg);
+            } else if (parentPort) {
+                parentPort.postMessage(msg);
+            } else {
+                console.error('[JsonWorker] No way to send message:', msg);
+            }
+        };
+        
+        const handler = (e) => {
+            // Node: e is the message directly
+            // Browser: e is MessageEvent, e.data is the message
+            const msg = isBrowser ? e.data : e;
+                        
+            // Handle raw ArrayBuffer (shouldn't happen but defensive)
+            if (msg instanceof ArrayBuffer) {
+                console.error('[JsonWorker] Received raw ArrayBuffer instead of message object. Length:', msg.byteLength);
+                return;
+            }
+            
+            const { id, op, data } = msg ?? {};
+            
+            if (typeof id !== 'number') {
+                console.error('[JsonWorker] Invalid message, missing id. Got:', msg);
+                return;
+            }
+            
+            try {
+                let result;
+                if (op === 'parse') {
+                    if (data === undefined || data === null) {
+                        throw new Error('No data provided for parse operation');
+                    }
+                    const text = data instanceof ArrayBuffer 
+                        ? new TextDecoder().decode(data) 
+                        : data;
+                    result = JSON.parse(text);
+                } else if (op === 'stringify') {
+                    result = JSON.stringify(data);
+                } else {
+                    throw new Error('Unknown operation: ' + op);
+                }
+                send({ id, result });
+            } catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                console.error('[JsonWorker] Error processing task ' + id + ':', error);
+                send({ id, error });
+            }
+        };
+        
+        if (isBrowser) {
+            self.onmessage = handler;
+            self.onerror = (err) => {
+                console.error('[JsonWorker] Uncaught error:', err);
+            };
+        } else if (parentPort) {
+            parentPort.on('message', handler);
+            parentPort.on('error', (err) => {
+                console.error('[JsonWorker] Uncaught error:', err);
+            });
+        } else {
+            console.error('[JsonWorker] No parentPort and not browser - worker cannot receive messages');
+        }
+    })();
+`;

package/src/transactions/metadata/TransactionReceipt.ts

@@ -1,5 +1,6 @@
 import { Network } from '@btc-vision/bitcoin';
-import { Address, NetEvent } from '@btc-vision/transaction';
+import { NetEvent } from '@btc-vision/transaction';
+import { getP2op } from '../../cache/P2OPCache.js';
 import { CallResult } from '../../contracts/CallResult.js';
 import {
     ContractEvents,
@@ -46,7 +47,6 @@ export class TransactionReceipt implements ITransactionReceipt {
             : undefined;
 
         this.receiptProofs = receipt.receiptProofs || [];
-
         this.events = receipt.events ? this.parseEvents(receipt.events, network) : {};
 
         this.rawRevert = receipt.revert
@@ -54,7 +54,6 @@ export class TransactionReceipt implements ITransactionReceipt {
             : undefined;
 
         this.revert = this.rawRevert ? CallResult.decodeRevertData(this.rawRevert) : undefined;
-
         this.gasUsed = BigInt(receipt.gasUsed || '0x00') || 0n;
         this.specialGasUsed = BigInt(receipt.specialGasUsed || '0x00') || 0n;
     }
@@ -70,30 +69,22 @@ export class TransactionReceipt implements ITransactionReceipt {
         network: Network,
     ): ContractEvents {
         const parsedEvents: ContractEvents = {};
+
         if (!Array.isArray(events)) {
             for (const [key, value] of Object.entries(events)) {
-                const ca = Address.fromString(key);
-                const caP2op = ca.p2op(network);
+                const caP2op = getP2op(key, network);
                 const v = (value as NetEventDocument[]).map((event: NetEventDocument) => {
                     return this.decodeEvent(event);
                 });
 
                 parsedEvents[caP2op] = v;
-
                 this.rawEvents[key] = v;
             }
         } else {
             for (const event of events) {
                 const parsedEvent = this.decodeEvent(event);
                 const contractAddress = event.contractAddress;
-
-                // TODO: Add a weak cache to avoid parsing the same address multiple times?
-                const ca = Address.fromString(contractAddress);
-                const caP2op = ca.p2op(network);
-
-                if (!parsedEvents[caP2op]) {
-                    parsedEvents[caP2op] = [];
-                }
+                const caP2op = getP2op(contractAddress, network);
 
                 if (!parsedEvents[caP2op]) {
                     parsedEvents[caP2op] = [];

package/webpack.config.js

@@ -35,6 +35,8 @@ export default {
             os: import.meta.resolve('os-browserify/browser/'),
             stream: import.meta.resolve('stream-browserify'),
             process: import.meta.resolve('process/browser'),
+            'node:worker_threads': false,
+            worker_threads: false,
         },
     },
     cache: false,