opnet 1.7.21 → 1.7.22

package/build/threading/WorkerCreator.js

@@ -0,0 +1,57 @@
+export const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+export async function createWorker(workerScript) {
+    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 = null;
+        worker.on('message', (msg) => {
+            if (messageCallback)
+                messageCallback(msg);
+        });
+        worker.unref();
+        return {
+            postMessage: (msg, transferables) => {
+                if (transferables && transferables.length > 0) {
+                    worker.postMessage(msg, transferables);
+                }
+                else {
+                    worker.postMessage(msg);
+                }
+            },
+            onMessage: (callback) => {
+                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, transferables) => {
+                if (transferables && transferables.length > 0) {
+                    worker.postMessage(msg, transferables);
+                }
+                else {
+                    worker.postMessage(msg);
+                }
+            },
+            onMessage: (callback) => {
+                worker.onmessage = (e) => callback(e.data);
+            },
+            terminate: () => {
+                worker.terminate();
+                URL.revokeObjectURL(url);
+            },
+        };
+    }
+}

package/build/threading/interfaces/IThread.d.ts

@@ -0,0 +1,28 @@
+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/build/threading/interfaces/IThread.js

@@ -0,0 +1 @@
+export {};

package/build/threading/worker-scripts/JSONWorker.d.ts

@@ -0,0 +1,2 @@
+import { WorkerScript } from '../interfaces/IThread.js';
+export declare const jsonWorkerScript: WorkerScript;

package/build/threading/worker-scripts/JSONWorker.js

@@ -0,0 +1,76 @@
+export const jsonWorkerScript = `
+    (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/build/transactions/metadata/TransactionReceipt.js

@@ -1,4 +1,5 @@
-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';
 export class TransactionReceipt {
     receipt;
@@ -26,8 +27,7 @@ export class TransactionReceipt {
         const parsedEvents = {};
         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.map((event) => {
                     return this.decodeEvent(event);
                 });
@@ -39,11 +39,7 @@ export class TransactionReceipt {
             for (const event of events) {
                 const parsedEvent = this.decodeEvent(event);
                 const contractAddress = event.contractAddress;
-                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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opnet",
     "type": "module",
-    "version": "1.7.21",
+    "version": "1.7.22",
     "author": "OP_NET",
     "description": "The perfect library for building Bitcoin-based applications.",
     "engines": {
@@ -100,8 +100,9 @@
         "@btc-vision/bip32": "^6.0.3",
         "@btc-vision/bitcoin": "^6.4.11",
         "@btc-vision/bitcoin-rpc": "^1.0.5",
+        "@btc-vision/logger": "^1.0.7",
         "@btc-vision/post-quantum": "^0.5.3",
-        "@btc-vision/transaction": "^1.7.19",
+        "@btc-vision/transaction": "^1.7.22",
         "@noble/hashes": "^1.8.0",
         "bignumber.js": "^9.3.1",
         "buffer": "^6.0.3",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.7.21';
+export const version = '1.7.22';

package/src/block/Block.ts

@@ -42,13 +42,14 @@ export class Block implements Omit<IBlock, 'gasUsed' | 'ema' | 'baseGas' | 'depl
 
     public readonly checksumProofs: BlockHeaderChecksumProof;
 
-    public readonly transactions: TransactionBase<OPNetTransactionTypes>[] = [];
-    public readonly deployments: Address[] = [];
+    private readonly _rawBlock: IBlock;
+    private readonly _network: Network;
 
     constructor(block: IBlock, network: Network) {
-        if (!block) {
-            throw new Error('Invalid block.');
-        }
+        if (!block) throw new Error('Invalid block.');
+
+        this._rawBlock = block;
+        this._network = network;
 
         this.height = BigInt(block.height.toString());
 
@@ -78,16 +79,33 @@ export class Block implements Omit<IBlock, 'gasUsed' | 'ema' | 'baseGas' | 'depl
         this.receiptRoot = block.receiptRoot;
 
         this.checksumProofs = block.checksumProofs;
+    }
+
+    private _transactions?: TransactionBase<OPNetTransactionTypes>[];
+
+    public get transactions(): TransactionBase<OPNetTransactionTypes>[] {
+        if (!this._transactions) {
+            this._transactions = TransactionParser.parseTransactions(
+                this._rawBlock.transactions as ITransaction[],
+                this._network,
+            );
+        }
+        return this._transactions;
+    }
+
+    private _deployments?: Address[];
 
-        this.transactions = TransactionParser.parseTransactions(
-            block.transactions as ITransaction[],
-            network,
-        );
+    public get deployments(): Address[] {
+        if (!this._deployments) {
+            this._deployments = this._rawBlock.deployments
+                ? this._rawBlock.deployments.map((address) => Address.fromString(address))
+                : [];
+        }
+        return this._deployments;
+    }
 
-        this.deployments = block.deployments
-            ? block.deployments.map((address) => {
-                  return Address.fromString(address);
-              })
-            : [];
+    // For cases where you need raw without parsing
+    public get rawTransactions(): ITransaction[] {
+        return this._rawBlock.transactions as ITransaction[];
     }
 }

package/src/cache/LRUCaching.ts

@@ -0,0 +1,30 @@
+export class LRUCache<K, V> {
+    private readonly cache: Map<K, V>;
+    private readonly maxSize: number;
+
+    constructor(maxSize: number) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+
+    public get(key: K): V | undefined {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.cache.delete(key);
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+
+    public set(key: K, value: V): void {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        } else if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+}

package/src/cache/P2OPCache.ts

@@ -0,0 +1,22 @@
+import { Network } from '@btc-vision/bitcoin';
+import { Address } from '@btc-vision/transaction';
+import { LRUCache } from './LRUCaching.js';
+
+const P2OP_CACHE_MAX_SIZE = 5_000;
+const p2opCache = new LRUCache<string, string>(P2OP_CACHE_MAX_SIZE);
+const addressCache = new LRUCache<string, Address>(P2OP_CACHE_MAX_SIZE);
+
+export const getP2op = (rawAddress: string, network: Network): string => {
+    const cacheKey = `${network.bip32}:${network.pubKeyHash}:${network.bech32}:${rawAddress}`;
+    let cached = p2opCache.get(cacheKey);
+    if (cached === undefined) {
+        let addr = addressCache.get(rawAddress);
+        if (addr === undefined) {
+            addr = Address.fromString(rawAddress);
+            addressCache.set(rawAddress, addr);
+        }
+        cached = addr.p2op(network);
+        p2opCache.set(cacheKey, cached);
+    }
+    return cached;
+};

package/src/fetch/fetch-browser.js

@@ -11,7 +11,9 @@ if (!originalFetch) {
     throw new Error('Fetch API is not available.');
 }
 
-export class Agent {}
+export class Agent {
+    async close() {}
+}
 
 const def = {
     fetch(input, init) {

package/src/fetch/fetch.ts

@@ -1,19 +1,24 @@
 import pLimit from 'p-limit';
-import { Agent, fetch as undiciFetch, Response, setGlobalDispatcher } from 'undici';
-import { Fetcher } from './fetcher-type.js';
+import { Agent, fetch as undiciFetch, RequestInit, Response } from 'undici';
+import { FetcherWithCleanup } from './fetcher-type.js';
 
-export function getFetcher(configs: Agent.Options): Fetcher {
+export function getFetcher(configs: Agent.Options): FetcherWithCleanup {
     const agent = new Agent(configs);
-
-    setGlobalDispatcher(agent);
-
     const limit = pLimit(500);
 
-    async function limitedFetch(...args: Parameters<typeof undiciFetch>): Promise<Response> {
-        return limit(() => undiciFetch(...args));
+    async function limitedFetch(
+        input: Parameters<typeof undiciFetch>[0],
+        init?: RequestInit,
+    ): Promise<Response> {
+        return limit(() => undiciFetch(input, { ...init, dispatcher: agent }));
     }
 
-    return limitedFetch;
+    return {
+        fetch: limitedFetch,
+        close: async () => {
+            await agent.close();
+        },
+    };
 }
 
 export default getFetcher;

package/src/fetch/fetcher-type.ts

@@ -1,3 +1,8 @@
 import { RequestInfo, RequestInit, Response } from 'undici';
 
 export type Fetcher = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export interface FetcherWithCleanup {
+    fetch: Fetcher;
+    close: () => Promise<void>;
+}

package/src/providers/JSONRpcProvider.ts

@@ -3,7 +3,8 @@ import Agent from 'undici/types/agent.js';
 import { Response } from 'undici/types/fetch';
 
 import getFetcher from '../fetch/fetch.js';
-import { Fetcher } from '../fetch/fetcher-type.js';
+import { Fetcher, FetcherWithCleanup } from '../fetch/fetcher-type.js';
+import { jsonThreader } from '../threading/JSONThreader.js';
 import { AbstractRpcProvider } from './AbstractRpcProvider.js';
 import { JsonRpcPayload } from './interfaces/JSONRpc.js';
 import { JsonRpcCallResult, JsonRpcError, JsonRpcResult } from './interfaces/JSONRpcResult.js';
@@ -16,6 +17,8 @@ import { JsonRpcCallResult, JsonRpcError, JsonRpcResult } from './interfaces/JSO
 export class JSONRpcProvider extends AbstractRpcProvider {
     public readonly url: string;
 
+    private _fetcherWithCleanup: FetcherWithCleanup | undefined;
+
     constructor(
         url: string,
         network: Network,
@@ -27,20 +30,25 @@ export class JSONRpcProvider extends AbstractRpcProvider {
             pipelining: 2, // max pipelining per server
         },
         private useRESTAPI: boolean = true,
+        private readonly useThreadedParsing: boolean = true,
     ) {
         super(network);
 
         this.url = this.providerUrl(url);
     }
 
-    private _fetcher: Fetcher | undefined;
-
     private get fetcher(): Fetcher {
-        if (!this._fetcher) {
-            this._fetcher = getFetcher(this.fetcherConfigurations);
+        if (!this._fetcherWithCleanup) {
+            this._fetcherWithCleanup = getFetcher(this.fetcherConfigurations);
         }
+        return this._fetcherWithCleanup.fetch;
+    }
 
-        return this._fetcher;
+    public async close(): Promise<void> {
+        if (this._fetcherWithCleanup) {
+            await this._fetcherWithCleanup.close();
+            this._fetcherWithCleanup = undefined;
+        }
     }
 
     /**
@@ -58,11 +66,9 @@ export class JSONRpcProvider extends AbstractRpcProvider {
      * @returns {Promise<JsonRpcCallResult>} - The result of the call
      */
     public async _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcCallResult> {
-        // Create an AbortController instance
         const controller = new AbortController();
         const { signal } = controller;
 
-        // Start a timer that will abort the fetch after the timeout period
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
 
         const params = {
@@ -70,7 +76,6 @@ export class JSONRpcProvider extends AbstractRpcProvider {
             headers: {
                 'Content-Type': 'application/json',
                 'User-Agent': 'OPNET/1.0',
-                //'Accept-Encoding': 'gzip, deflate, br',
                 Accept: 'application/json',
                 'Accept-Charset': 'utf-8',
                 'Accept-Language': 'en-US',
@@ -87,7 +92,7 @@ export class JSONRpcProvider extends AbstractRpcProvider {
                 throw new Error(`Failed to fetch: ${resp.statusText}`);
             }
 
-            const fetchedData = (await resp.json()) as JsonRpcResult | JsonRpcError;
+            const fetchedData = await this.parseResponse<JsonRpcResult | JsonRpcError>(resp);
             if (!fetchedData) {
                 throw new Error('No data fetched');
             }
@@ -118,4 +123,13 @@ export class JSONRpcProvider extends AbstractRpcProvider {
             return `${url}/api/v1/json-rpc`;
         }
     }
+
+    private async parseResponse<T>(resp: Response): Promise<T> {
+        if (this.useThreadedParsing) {
+            const buffer = await resp.arrayBuffer();
+            return jsonThreader.parseBuffer<T>(buffer);
+        }
+
+        return (await resp.json()) as Promise<T>;
+    }
 }

package/src/threading/JSONThreader.ts

@@ -0,0 +1,62 @@
+import { ThreaderOptions, WorkerScript } from './interfaces/IThread.js';
+import { BaseThreader } from './SharedThreader.js';
+import { jsonWorkerScript } from './worker-scripts/JSONWorker.js';
+
+export type JsonValue =
+    | string
+    | number
+    | boolean
+    | null
+    | JsonValue[]
+    | { [key: string]: JsonValue };
+
+type JsonOp = 'parse' | 'stringify';
+type JsonInput = string | JsonValue | ArrayBuffer;
+type JsonOutput = string | JsonValue;
+
+export class JsonThreader extends BaseThreader<JsonOp, JsonInput, JsonOutput> {
+    protected readonly workerScript: WorkerScript = jsonWorkerScript;
+    private readonly threadingThreshold: number;
+
+    public constructor(options: ThreaderOptions & { threadingThreshold?: number } = {}) {
+        super(options);
+        this.threadingThreshold = options.threadingThreshold ?? 16_384; // 16KB default
+    }
+
+    public async parse<T = JsonValue>(json: string): Promise<T> {
+        if (json.length < this.threadingThreshold) {
+            return JSON.parse(json) as T;
+        }
+        const result = await this.run('parse', json);
+        return result as T;
+    }
+
+    public async parseBuffer<T = JsonValue>(buffer: ArrayBuffer): Promise<T> {
+        if (buffer.byteLength < this.threadingThreshold) {
+            const text = new TextDecoder().decode(buffer);
+            return JSON.parse(text) as T;
+        }
+        const result = await this.runWithTransfer('parse', buffer, [buffer]);
+        return result as T;
+    }
+
+    public async stringify(data: JsonValue): Promise<string> {
+        const result = JSON.stringify(data);
+        if (result.length < this.threadingThreshold) {
+            return result;
+        }
+        return (await this.run('stringify', data)) as string;
+    }
+}
+
+const GLOBAL_KEY = Symbol.for('opnet.jsonThreader');
+const globalObj = (typeof globalThis !== 'undefined' ? globalThis : global) as Record<
+    symbol,
+    JsonThreader
+>;
+
+if (!globalObj[GLOBAL_KEY]) {
+    globalObj[GLOBAL_KEY] = new JsonThreader();
+}
+
+export const jsonThreader: JsonThreader = globalObj[GLOBAL_KEY];