@leofcoin/chain 1.8.12 → 1.8.14

package/exports/browser/chain.js

@@ -3977,7 +3977,12 @@ class Transaction extends Protocol {
             });
             await globalThis.transactionPoolStore.put(hash, message.encoded);
             // debug(`Added ${hash} to the transaction pool`)
-            peernet.publish('add-transaction', message.encoded);
+            try {
+                peernet.publish('add-transaction', message.encoded);
+            }
+            catch (publishError) {
+                console.warn('peernet publish failed: add-transaction', publishError?.message ?? publishError);
+            }
             const fee = await calculateFee(message.decoded);
             return { hash, data, fee, wait, message };
         }
@@ -4919,10 +4924,16 @@ class Machine {
         return this.getBlocks();
     }
     get lastBlock() {
-        return this.#askWorker('lastBlock');
+        return this.#askWorker('lastBlock').catch((error) => {
+            debug$2('lastBlock fallback after worker timeout:', error?.message ?? error);
+            return this.states.lastBlock;
+        });
     }
     get lastBlockHeight() {
-        return this.#askWorker('lastBlockHeight');
+        return this.#askWorker('lastBlockHeight').catch((error) => {
+            debug$2('lastBlockHeight fallback after worker timeout:', error?.message ?? error);
+            return Number(this.states.lastBlock?.index ?? 0);
+        });
     }
     getBlocks(from, to) {
         return this.#askWorker('blocks', { from, to });
@@ -5496,6 +5507,8 @@ class State extends Contract {
                         return { result: Uint8Array.from(Object.values(result)), peer };
                     }
                     catch (error) {
+                        const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown';
+                        debug$1(`lastBlock request failed: ${peerId}:`, error?.message ?? error);
                         throw error;
                     }
                 };
@@ -5523,9 +5536,16 @@ class State extends Contract {
                     request: 'knownBlocks'
                 });
                 let node = await globalThis.peernet.prepareMessage(data);
-                let message = await peer.request(node.encode());
-                message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.wantList.push(...message.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block)));
+                try {
+                    let message = await peer.request(node.encode());
+                    message = await new globalThis.peernet.protos['peernet-response'](message);
+                    this.wantList.push(...message.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block)));
+                }
+                catch (error) {
+                    const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown';
+                    debug$1(`knownBlocks request failed: ${peerId}:`, error?.message ?? error);
+                    throw error;
+                }
             }
         }
         return latest;
@@ -6274,9 +6294,16 @@ class Chain extends VersionControl {
     }
     async #makeRequest(peer, request) {
         const node = await this.#prepareRequest(request);
-        let response = await peer.request(node.encoded);
-        response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
-        return response.decoded.response;
+        try {
+            let response = await peer.request(node.encoded);
+            response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
+            return response.decoded.response;
+        }
+        catch (error) {
+            const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown';
+            debug(`peernet request failed: ${request} -> ${peerId}:`, error?.message ?? error);
+            throw error;
+        }
     }
     async getPeerTransactionPool(peer) {
         const transactionsInPool = await this.#makeRequest(peer, 'transactionPool');
@@ -6315,18 +6342,35 @@ class Chain extends VersionControl {
             debug(`versions don't match`);
             return;
         }
-        const lastBlock = await this.#makeRequest(peer, 'lastBlock');
+        let lastBlock;
+        try {
+            lastBlock = await this.#makeRequest(peer, 'lastBlock');
+        }
+        catch (error) {
+            const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
+            debug(`lastBlock request failed: ${peerName}:`, error?.message ?? error);
+            return;
+        }
         const localBlock = await this.lastBlock;
-        if (lastBlock.hash === '0x0')
+        if (!lastBlock || !lastBlock.hash || lastBlock.hash === '0x0') {
+            debug(`peer has no lastBlock: ${peerId}`);
             return;
+        }
         const higherThenCurrentLocal = !localBlock?.index ? true : lastBlock.index > localBlock.index;
         if (lastBlock) {
             if (!this.lastBlock || higherThenCurrentLocal) {
-                const knownBlocksResponse = await this.#makeRequest(peer, 'knownBlocks');
-                if (knownBlocksResponse.blocks)
-                    for (const hash of knownBlocksResponse.blocks) {
-                        this.wantList.push(hash);
-                    }
+                try {
+                    const knownBlocksResponse = await this.#makeRequest(peer, 'knownBlocks');
+                    if (knownBlocksResponse.blocks)
+                        for (const hash of knownBlocksResponse.blocks) {
+                            this.wantList.push(hash);
+                        }
+                }
+                catch (error) {
+                    const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
+                    debug(`knownBlocks request failed: ${peerName}:`, error?.message ?? error);
+                    return;
+                }
             }
         }
         if (this.wantList.length > 0) {
@@ -6341,13 +6385,26 @@ class Chain extends VersionControl {
                 await this.triggerSync();
         }
         setTimeout(async () => {
-            const peerTransactionPool = (higherThenCurrentLocal && (await this.getPeerTransactionPool(peer))) || [];
-            if (this.#participating && peerTransactionPool.length > 0)
-                return this.#runEpoch();
+            try {
+                const peerTransactionPool = (higherThenCurrentLocal && (await this.getPeerTransactionPool(peer))) || [];
+                if (this.#participating && peerTransactionPool.length > 0)
+                    return this.#runEpoch();
+            }
+            catch (error) {
+                const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
+                debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
+            }
         }, 3000);
-        const stateInfo = await this.#makeRequest(peer, 'stateInfo');
-        await this.syncChain(lastBlock);
-        this.machine.states.info = stateInfo;
+        try {
+            const stateInfo = await this.#makeRequest(peer, 'stateInfo');
+            await this.syncChain(lastBlock);
+            this.machine.states.info = stateInfo;
+        }
+        catch (error) {
+            const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
+            debug(`stateInfo/syncChain failed: ${peerName}:`, error?.message ?? error);
+            return;
+        }
     }
     #epochTimeout;
     async #transactionPoolHandler() {
@@ -6367,7 +6424,12 @@ class Chain extends VersionControl {
         }
         catch (error) {
             await transactionPoolStore.delete(hash);
-            globalThis.peernet.publish('invalid-transaction', hash);
+            try {
+                globalThis.peernet.publish('invalid-transaction', hash);
+            }
+            catch (publishError) {
+                debug('peernet publish failed: invalid-transaction', publishError?.message ?? publishError);
+            }
             globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error: error });
             throw { error, hash, from, to, params, nonce };
         }
@@ -6582,7 +6644,10 @@ class Chain extends VersionControl {
                         bw: bw.up + bw.down
                     });
                 }
-                catch { }
+                catch (error) {
+                    const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown';
+                    debug(`bw request failed: ${peerId}:`, error?.message ?? error);
+                }
             }
             else if (globalThis.peernet.selectedAccount === validator) {
                 block.validators.push({
@@ -6622,7 +6687,12 @@ class Chain extends VersionControl {
             debug(`created block: ${hash} @${block.index}`);
             // Publish canonical encoded form via codec interface
             console.log(`[chain] 📤 Publishing block #${block.index} | hash: ${hash} | encoded bytes: ${blockMessage.encoded.length}`);
-            globalThis.peernet.publish('add-block', blockMessage.encoded);
+            try {
+                globalThis.peernet.publish('add-block', blockMessage.encoded);
+            }
+            catch (publishError) {
+                debug('peernet publish failed: add-block', publishError?.message ?? publishError);
+            }
             globalThis.pubsub.publish('add-block', blockMessage.encoded);
         }
         catch (error) {
@@ -6644,7 +6714,12 @@ class Chain extends VersionControl {
                 this.#runEpoch();
         }
         catch (e) {
-            globalThis.peernet.publish('invalid-transaction', hash);
+            try {
+                globalThis.peernet.publish('invalid-transaction', hash);
+            }
+            catch (publishError) {
+                debug('peernet publish failed: invalid-transaction', publishError?.message ?? publishError);
+            }
             throw new Error('invalid transaction');
         }
     }
@@ -6657,7 +6732,12 @@ class Chain extends VersionControl {
         const transactionMessage = await new TransactionMessage({ ...transaction });
         const event = await super.sendTransaction(transactionMessage);
         this.#sendTransaction(transactionMessage.encoded);
-        globalThis.peernet.publish('send-transaction', transactionMessage.encoded);
+        try {
+            globalThis.peernet.publish('send-transaction', transactionMessage.encoded);
+        }
+        catch (publishError) {
+            debug('peernet publish failed: send-transaction', publishError?.message ?? publishError);
+        }
         return event;
     }
     async addContract(transaction, contractMessage) {

package/exports/browser/workers/block-worker.js

@@ -1,4 +1,4 @@
-import { E as EasyWorker, B as BlockMessage } from './worker-CPvGlmOu-CPvGlmOu.js';
+import { E as EasyWorker, B as BlockMessage } from './worker-iOnLaHA--iOnLaHA-.js';
 
 const worker = new EasyWorker();
 globalThis.BigNumber = BigNumber;

package/exports/browser/workers/machine-worker.js

@@ -1,4 +1,4 @@
-import { E as EasyWorker, C as ContractMessage, T as TransactionMessage } from './worker-CPvGlmOu-CPvGlmOu.js';
+import { E as EasyWorker, C as ContractMessage, T as TransactionMessage } from './worker-iOnLaHA--iOnLaHA-.js';
 
 /* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
 /**
@@ -104,58 +104,73 @@ var bytecodes = {
 };
 
 class LittlePubSub {
-    subscribers = {};
+    subscribers = new Map();
     verbose;
     constructor(verbose) {
-        this.verbose = verbose;
-    }
-    _handleContext(handler, context) {
-        if (typeof context === 'undefined') {
-            context = handler;
-        }
-        return context;
+        this.verbose = verbose ?? false;
     }
     hasSubscribers(event) {
-        return this.subscribers[event] ? true : false;
+        return this.subscribers.has(event);
+    }
+    subscriberCount(event) {
+        return this.subscribers.get(event)?.handlers.length ?? 0;
+    }
+    clear() {
+        this.subscribers.clear();
     }
     getValue(event) {
-        if (this.subscribers[event])
-            return this.subscribers[event].value;
-        return undefined;
+        return this.subscribers.get(event)?.value;
     }
     subscribe(event, handler, options) {
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = { handlers: [], value: undefined };
-        const context = this._handleContext(handler, options?.context);
-        const _handler = handler.bind(context);
-        this.subscribers[event].handlers.push(_handler);
-        if (this.subscribers[event].value !== undefined)
-            _handler(this.subscribers[event].value, undefined);
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        // Only bind if context is provided
+        const context = options?.context;
+        const boundHandler = context
+            ? handler.bind(context)
+            : handler;
+        subscriber.handlers.push({ original: handler, bound: boundHandler });
+        // Call handler immediately if value already exists
+        if (subscriber.value !== undefined) {
+            boundHandler(subscriber.value, undefined);
+        }
+        // Return unsubscribe function
+        return () => this.unsubscribe(event, handler, options);
     }
     unsubscribe(event, handler, options) {
-        if (!options)
-            options = { keepValue: false };
-        if (!this.hasSubscribers(event))
+        const subscriber = this.subscribers.get(event);
+        if (subscriber === undefined)
             return;
-        const context = this._handleContext(handler, options.context);
-        const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
-        this.subscribers[event].handlers.splice(index);
-        // delete event if no handlers left but supports keeping value for later use
-        // (like when unsubscribing from a value that is still needed because others might subscibe to it)
-        if (this.subscribers[event].handlers.length === 0 && !options.keepValue)
-            delete this.subscribers[event];
+        const handlers = subscriber.handlers;
+        // Find and remove handler by original reference
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            if (handlers[i].original === handler) {
+                handlers.splice(i, 1);
+                break;
+            }
+        }
+        // Delete event if no handlers left (unless keepValue is true)
+        if (handlers.length === 0 && !options?.keepValue) {
+            this.subscribers.delete(event);
+        }
     }
     publish(event, value, verbose) {
-        // always set value even when having no subscribers
-        if (!this.hasSubscribers(event))
-            this.subscribers[event] = {
-                handlers: []
-            };
-        const oldValue = this.subscribers[event]?.value;
+        let subscriber = this.subscribers.get(event);
+        if (subscriber === undefined) {
+            subscriber = { handlers: [], value: undefined };
+            this.subscribers.set(event, subscriber);
+        }
+        const oldValue = subscriber.value;
+        // Only trigger handlers if verbose or value changed
         if (this.verbose || verbose || oldValue !== value) {
-            this.subscribers[event].value = value;
-            for (const handler of this.subscribers[event].handlers) {
-                handler(value, oldValue);
+            subscriber.value = value;
+            const handlers = subscriber.handlers;
+            const len = handlers.length;
+            for (let i = 0; i < len; i++) {
+                handlers[i].bound(value, oldValue);
             }
         }
     }
@@ -163,12 +178,21 @@ class LittlePubSub {
         this.publish(event, value, true);
     }
     once(event, options) {
-        return new Promise((resolve) => {
-            const cb = (value) => {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            const handler = (value) => {
+                if (timeoutId !== undefined)
+                    clearTimeout(timeoutId);
                 resolve(value);
-                this.unsubscribe(event, cb, options);
+                this.unsubscribe(event, handler, options);
             };
-            this.subscribe(event, cb, options);
+            this.subscribe(event, handler, options);
+            if (options?.timeout !== undefined) {
+                timeoutId = setTimeout(() => {
+                    this.unsubscribe(event, handler, options);
+                    reject(new Error(`Timeout waiting for event "${event}"`));
+                }, options.timeout);
+            }
         });
     }
 }